464 lines
9.3 KiB
C
464 lines
9.3 KiB
C
#pragma once
|
|
|
|
#if _MSC_VER
|
|
extern u32 _lzcnt_u32(u32);
|
|
extern u32 _tzcnt_u32(u32);
|
|
extern u64 _lzcnt_u64(u64);
|
|
extern u64 _tzcnt_u64(u64);
|
|
#endif
|
|
|
|
fn u8 leading_zeroes_u32(u32 value)
|
|
{
|
|
#if _MSC_VER
|
|
return (u8)_lzcnt_u32(value);
|
|
#else
|
|
return __builtin_clz(value);
|
|
#endif
|
|
}
|
|
|
|
fn u8 leading_zeroes_u64(u64 value)
|
|
{
|
|
#if _MSC_VER
|
|
return (u8)_lzcnt_u64(value);
|
|
#else
|
|
return __builtin_clzll(value);
|
|
#endif
|
|
}
|
|
|
|
fn u8 log2_alignment(u64 alignment)
|
|
{
|
|
assert(alignment != 0);
|
|
assert((alignment & (alignment - 1)) == 0);
|
|
u8 left = (sizeof(alignment) * 8) - 1;
|
|
u8 right = leading_zeroes_u64(alignment);
|
|
let_cast(u8, result, left - right);
|
|
return result;
|
|
}
|
|
|
|
fn u8 log2_u64(u64 v)
|
|
{
|
|
assert(v != 0);
|
|
return (sizeof(u64) * 8 - 1) - leading_zeroes_u64(v);
|
|
}
|
|
|
|
fn u8 log2_u32(u32 v)
|
|
{
|
|
assert(v != 0);
|
|
return (sizeof(u32) * 8 - 1) - leading_zeroes_u32(v);
|
|
}
|
|
|
|
fn u8 hex_digit_count(u64 v)
|
|
{
|
|
u8 result = 1;
|
|
if (v)
|
|
{
|
|
result = log2_u64(v) / log2_u64(16) + 1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
fn u128 u128_from_u64(u64 n)
|
|
{
|
|
#if defined(__TINYC__) || defined(_MSC_VER)
|
|
u128 result = { .low = n };
|
|
return result;
|
|
#else
|
|
return n;
|
|
#endif
|
|
}
|
|
|
|
fn u64 u64_from_u128(u128 n)
|
|
{
|
|
#if defined (__TINYC__) || defined(_MSC_VER)
|
|
return n.low;
|
|
#else
|
|
return (u64)n;
|
|
#endif
|
|
}
|
|
|
|
fn u128 u128_shift_right(u128 value, u16 n)
|
|
{
|
|
#if defined (__TINYC__) || defined(_MSC_VER)
|
|
u128 result = {};
|
|
|
|
if (n < 128)
|
|
{
|
|
if (n >= 64)
|
|
{
|
|
// If n >= 64, only the high part contributes to the low part
|
|
result.low = value.high >> (n - 64);
|
|
result.high = 0;
|
|
}
|
|
else
|
|
{
|
|
// Standard case: n < 64
|
|
result.low = (value.low >> n) | (value.high << (64 - n));
|
|
result.high = value.high >> n;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
#else
|
|
return value >> n;
|
|
#endif
|
|
}
|
|
|
|
fn u128 u128_shift_left(u128 value, u16 n)
|
|
{
|
|
#if defined(__TINYC__) || defined(_MSC_VER)
|
|
u128 result = {};
|
|
|
|
if (n < 128)
|
|
{
|
|
if (n >= 64)
|
|
{
|
|
// If n >= 64, only the low part contributes to the high part
|
|
result.high = value.low << (n - 64);
|
|
result.low = 0;
|
|
}
|
|
else
|
|
{
|
|
// Standard case: n < 64
|
|
result.high = (value.high << n) | (value.low >> (64 - n));
|
|
result.low = value.low << n;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
#else
|
|
return value << n;
|
|
#endif
|
|
}
|
|
|
|
fn u128 u128_u64_or(u128 a, u64 b)
|
|
{
|
|
#if defined(__TINYC__) || defined(_MSC_VER)
|
|
a.low |= b;
|
|
return a;
|
|
#else
|
|
return a | b;
|
|
#endif
|
|
}
|
|
|
|
fn u128 u128_u64_add(u128 a, u64 b)
|
|
{
|
|
#if defined(__TINYC__) || defined(_MSC_VER)
|
|
u128 result;
|
|
|
|
// Add the lower 64 bits and check for overflow
|
|
result.low = a.low + b;
|
|
u64 carry = (result.low < a.low) ? 1 : 0;
|
|
|
|
// Add the carry to the upper 64 bits
|
|
result.high = a.high + carry;
|
|
|
|
return result;
|
|
#else
|
|
return a + b;
|
|
#endif
|
|
}
|
|
|
|
// Multiply two u128 values
|
|
fn u128 u128_u64_mul(u128 a, u64 b)
|
|
{
|
|
#if defined(__TINYC__) || defined(_MSC_VER)
|
|
u128 result = {};
|
|
|
|
// Compute low and high parts of the product
|
|
u64 low_low = (a.low & 0xFFFFFFFF) * (b & 0xFFFFFFFF);
|
|
u64 low_high = (a.low >> 32) * (b & 0xFFFFFFFF);
|
|
u64 high_low = (a.low & 0xFFFFFFFF) * (b >> 32);
|
|
u64 high_high = (a.low >> 32) * (b >> 32);
|
|
|
|
// Combine partial products for the lower 64 bits
|
|
u64 carry = (low_low >> 32) + (low_high & 0xFFFFFFFF) + (high_low & 0xFFFFFFFF);
|
|
result.low = (low_low & 0xFFFFFFFF) | (carry << 32);
|
|
|
|
// Add carry from lower to the high product
|
|
result.high = a.high * b + (low_high >> 32) + (high_low >> 32) + (carry >> 32) + high_high;
|
|
|
|
return result;
|
|
#else
|
|
return a * b;
|
|
#endif
|
|
}
|
|
|
|
fn u64 u128_shift_right_by_64(u128 n)
|
|
{
|
|
#if defined(__TINYC__) || defined(_MSC_VER)
|
|
return n.high;
|
|
#else
|
|
return n >> 64;
|
|
#endif
|
|
}
|
|
|
|
// Lehmer's generator
|
|
// https://lemire.me/blog/2019/03/19/the-fastest-conventional-random-number-generator-that-can-pass-big-crush/
|
|
global_variable u128 rn_state;
|
|
fn u64 generate_random_number()
|
|
{
|
|
rn_state = u128_u64_mul(rn_state, 0xda942042e4dd58b5);
|
|
return u128_shift_right_by_64(rn_state);
|
|
}
|
|
|
|
fn u64 round_up_to_next_power_of_2(u64 n)
|
|
{
|
|
n -= 1;
|
|
n |= n >> 1;
|
|
n |= n >> 2;
|
|
n |= n >> 4;
|
|
n |= n >> 8;
|
|
n |= n >> 16;
|
|
n |= n >> 32;
|
|
n += 1;
|
|
return n;
|
|
}
|
|
|
|
fn u64 absolute_int(s64 n)
|
|
{
|
|
return n < 0 ? cast_to(u64, -n) : cast_to(u64, n);
|
|
}
|
|
|
|
fn u64 parse_decimal(String string)
|
|
{
|
|
u64 value = 0;
|
|
for (u64 i = 0; i < string.length; i += 1)
|
|
{
|
|
u8 ch = s_get(string, i);
|
|
assert(((ch >= '0') & (ch <= '9')));
|
|
value = (value * 10) + (ch - '0');
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
fn u8 get_next_ch_safe(String string, u64 index)
|
|
{
|
|
u64 next_index = index + 1;
|
|
u64 is_in_range = next_index < string.length;
|
|
u64 safe_index = safe_flag(next_index, is_in_range);
|
|
u8 unsafe_result = string.pointer[safe_index];
|
|
u64 safe_result = safe_flag(unsafe_result, is_in_range);
|
|
assert(safe_result < 256);
|
|
return (u8)safe_result;
|
|
}
|
|
|
|
fn u32 is_space(u8 ch, u8 next_ch)
|
|
{
|
|
u32 is_comment = (ch == '/') & (next_ch == '/');
|
|
u32 is_whitespace = ch == ' ';
|
|
u32 is_vertical_tab = ch == 0x0b;
|
|
u32 is_horizontal_tab = ch == '\t';
|
|
u32 is_line_feed = ch == '\n';
|
|
u32 is_carry_return = ch == '\r';
|
|
u32 result = (((is_vertical_tab | is_horizontal_tab) | (is_line_feed | is_carry_return)) | (is_comment | is_whitespace));
|
|
return result;
|
|
}
|
|
|
|
fn u64 is_lower(u8 ch)
|
|
{
|
|
return (ch >= 'a') & (ch <= 'z');
|
|
}
|
|
|
|
fn u64 is_upper(u8 ch)
|
|
{
|
|
return (ch >= 'A') & (ch <= 'Z');
|
|
}
|
|
|
|
fn u64 is_alphabetic(u8 ch)
|
|
{
|
|
return is_lower(ch) | is_upper(ch);
|
|
}
|
|
|
|
fn u64 is_decimal_digit(u8 ch)
|
|
{
|
|
return (ch >= '0') & (ch <= '9');
|
|
}
|
|
|
|
fn u64 is_alphanumeric(u8 ch)
|
|
{
|
|
return is_alphabetic(ch) | is_decimal_digit(ch);
|
|
}
|
|
|
|
fn u64 is_hex_digit_alpha_lower(u8 ch)
|
|
{
|
|
return (ch >= 'a') & (ch <= 'f');
|
|
}
|
|
|
|
fn u64 is_hex_digit_alpha_upper(u8 ch)
|
|
{
|
|
return (ch >= 'A') & (ch <= 'F');
|
|
}
|
|
|
|
fn u64 is_hex_digit_alpha(u8 ch)
|
|
{
|
|
return is_hex_digit_alpha_lower(ch) | is_hex_digit_alpha_upper(ch);
|
|
}
|
|
|
|
fn u64 is_hex_digit(u8 ch)
|
|
{
|
|
return is_decimal_digit(ch) | is_hex_digit_alpha(ch);
|
|
}
|
|
|
|
fn u8 hex_ch_to_int(u8 ch)
|
|
{
|
|
if ((ch >= '0') & (ch <= '9'))
|
|
{
|
|
return ch - '0';
|
|
}
|
|
else if ((ch >= 'a') & (ch <= 'f'))
|
|
{
|
|
return ch - 'a' + 10;
|
|
}
|
|
else if ((ch >= 'A') & (ch <= 'F'))
|
|
{
|
|
return ch - 'A' + 10;
|
|
}
|
|
else
|
|
{
|
|
unreachable();
|
|
}
|
|
}
|
|
|
|
fn u64 is_identifier_start(u8 ch)
|
|
{
|
|
u64 alphabetic = is_alphabetic(ch);
|
|
u64 is_underscore = ch == '_';
|
|
return alphabetic | is_underscore;
|
|
}
|
|
|
|
fn u64 is_identifier_ch(u8 ch)
|
|
{
|
|
u64 identifier_start = is_identifier_start(ch);
|
|
u64 decimal = is_decimal_digit(ch);
|
|
return identifier_start | decimal;
|
|
}
|
|
|
|
fn Hash64 hash_byte(Hash64 source, u8 ch)
|
|
{
|
|
source ^= ch;
|
|
source *= fnv_prime;
|
|
return source;
|
|
}
|
|
|
|
fn Hash64 hash_bytes(String bytes)
|
|
{
|
|
u64 result = fnv_offset;
|
|
for (u64 i = 0; i < bytes.length; i += 1)
|
|
{
|
|
result = hash_byte(result, bytes.pointer[i]);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
fn Hash32 hash64_to_hash32(Hash64 hash64)
|
|
{
|
|
Hash32 low = hash64 & 0xffff;
|
|
Hash32 high = (hash64 >> 32) & 0xffff;
|
|
Hash32 result = (high << 16) | low;
|
|
return result;
|
|
}
|
|
|
|
fn u64 align_forward_u32(u32 value, u32 alignment)
|
|
{
|
|
u32 mask = alignment - 1;
|
|
u32 result = (value + mask) & ~mask;
|
|
return result;
|
|
}
|
|
|
|
fn u32 align_backward_u32(u32 value, u32 alignment)
|
|
{
|
|
u32 result = value & ~(alignment - 1);
|
|
return result;
|
|
}
|
|
|
|
fn u64 align_forward_u64(u64 value, u64 alignment)
|
|
{
|
|
u64 mask = alignment - 1;
|
|
u64 result = (value + mask) & ~mask;
|
|
return result;
|
|
}
|
|
|
|
fn u64 align_backward_u64(u64 value, u64 alignment)
|
|
{
|
|
u64 result = value & ~(alignment - 1);
|
|
return result;
|
|
}
|
|
|
|
fn u8 is_power_of_two_u64(u64 value)
|
|
{
|
|
return (value & (value - 1)) == 0;
|
|
}
|
|
|
|
fn u8 first_bit_set_u32(u32 value)
|
|
{
|
|
#if _MSC_VER
|
|
DWORD result_dword;
|
|
u8 result_u8 = _BitScanForward(&result_dword, value);
|
|
unused(result_u8);
|
|
let_cast(u8, result, result_dword);
|
|
#else
|
|
let(result, (u8)__builtin_ffs((s32)value));
|
|
#endif
|
|
result -= result != 0;
|
|
return result;
|
|
}
|
|
|
|
fn u64 first_bit_set_u64(u64 value)
|
|
{
|
|
#if _MSC_VER
|
|
DWORD result_dword;
|
|
u8 result_u8 = _BitScanForward64(&result_dword, value);
|
|
unused(result_u8);
|
|
let_cast(u8, result, result_dword);
|
|
#else
|
|
let(result, (u8) __builtin_ffs((s64)value));
|
|
#endif
|
|
result -= result != 0;
|
|
return result;
|
|
}
|
|
|
|
fn Hash32 hash32_fib_end(Hash32 hash)
|
|
{
|
|
let(result, TRUNCATE(Hash32, ((hash + 1) * 11400714819323198485ull) >> 32));
|
|
return result;
|
|
}
|
|
|
|
fn Hash32 hash64_fib_end(Hash64 hash)
|
|
{
|
|
let(result, TRUNCATE(Hash32, ((hash + 1) * 11400714819323198485ull) >> 32));
|
|
return result;
|
|
}
|
|
|
|
fn u64 parse_hexadecimal(String string, u8* error)
|
|
{
|
|
u8* it = &string.pointer[string.length - 1];
|
|
u8 is_error = 0;
|
|
|
|
u64 result = 0;
|
|
|
|
while (it >= string.pointer)
|
|
{
|
|
u8 ch = *it;
|
|
|
|
u8 is_error_it = !is_hex_digit(ch);
|
|
is_error |= is_error_it;
|
|
if (is_error_it)
|
|
{
|
|
break;
|
|
}
|
|
|
|
u8 sub = is_decimal_digit(ch) ? '0' : (is_hex_digit_alpha_lower(ch) ? 'a' : 'A');
|
|
u8 hex_value = ch - sub + 10 * is_hex_digit_alpha(ch);
|
|
assert((hex_value & 0xf) == hex_value);
|
|
result = (result << 4) | hex_value;
|
|
|
|
it -= 1;
|
|
}
|
|
|
|
*error = is_error;
|
|
return result;
|
|
}
|