rstd_core.h (3273B)
1 #ifndef RSTD_CORE_H 2 #define RSTD_CORE_H 3 4 ///////////////////////// 5 // NOTE: Standard Macros 6 #define function static 7 #define global static 8 #define local_persist static 9 10 #ifndef asm 11 #define asm __asm__ 12 #endif 13 14 #ifndef typeof 15 #define typeof __typeof__ 16 #endif 17 18 #define alignof _Alignof 19 #define static_assert _Static_assert 20 21 #define countof(a) (sizeof(a) / sizeof(*a)) 22 23 #define arg_list(type, ...) (type []){__VA_ARGS__}, sizeof((type []){__VA_ARGS__}) / sizeof(type) 24 25 #define Abs(a) ((a) < 0 ? (-a) : (a)) 26 #define Between(x, a, b) ((x) >= (a) && (x) <= (b)) 27 #define Clamp(x, a, b) ((x) < (a) ? (a) : (x) > (b) ? (b) : (x)) 28 #define Min(a, b) ((a) < (b) ? (a) : (b)) 29 #define Max(a, b) ((a) > (b) ? (a) : (b)) 30 31 #define IsDigit(c) (Between((c), '0', '9')) 32 33 #ifdef _DEBUG 34 #define assert(c) do { if (!(c)) debugbreak(); } while (0) 35 #else /* !_DEBUG */ 36 #define assert(c) 37 #endif /* !_DEBUG */ 38 39 #define InvalidCodePath assert(0) 40 #define InvalidDefaultCase default:{ assert(0); }break 41 42 //////////////////////// 43 // NOTE: Core Functions 44 45 #if COMPILER_MSVC 46 47 function force_inline u32 48 clz_u32(u32 a) 49 { 50 u32 result = 32, index; 51 if (a) { 52 _BitScanReverse(&index, a); 53 result = index; 54 } 55 return result; 56 } 57 58 function force_inline u32 59 ctz_u32(u32 a) 60 { 61 u32 result = 32, index; 62 if (a) { 63 _BitScanForward(&index, a); 64 result = index; 65 } 66 return result; 67 } 68 69 function force_inline u64 70 clz_u64(u64 a) 71 { 72 u64 result = 64, index; 73 if (a) { 74 _BitScanReverse64(&index, a); 75 result = index; 76 } 77 return result; 78 } 79 80 function force_inline u64 81 ctz_u64(u64 a) 82 { 83 u64 result = 64, index; 84 if (a) { 85 _BitScanForward64(&index, a); 86 result = index; 87 } 88 return result; 89 } 90 91 #else /* !COMPILER_MSVC */ 92 93 function force_inline u32 94 clz_u32(u32 a) 95 { 96 u32 result = 32; 97 if (a) result = (u32)__builtin_clz(a); 98 return result; 99 } 100 101 function force_inline u32 102 ctz_u32(u32 a) 103 { 104 u32 result = 32; 105 if (a) result = (u32)__builtin_ctz(a); 106 return result; 107 } 108 109 function force_inline u64 110 clz_u64(u64 a) 111 { 112 u64 result = 64; 113 if (a) result = (u64)__builtin_clzll(a); 114 return result; 115 } 116 117 function force_inline u64 118 ctz_u64(u64 a) 119 { 120 u64 result = 64; 121 if (a) result = (u64)__builtin_ctzll(a); 122 return result; 123 } 124 125 #endif /* !COMPILER_MSVC */ 126 127 function void * 128 memory_clear(void *restrict destination, u8 byte, s64 size) 129 { 130 u8 *p = destination; 131 while (size > 0) p[--size] = byte; 132 return p; 133 } 134 135 function void 136 memory_copy(void *restrict destination, void *restrict source, s64 size) 137 { 138 u8 *s = source, *d = destination; 139 for (; size > 0; size--) *d++ = *s++; 140 } 141 142 function force_inline s64 143 round_up_to(s64 value, s64 multiple) 144 { 145 s64 result = value; 146 if (value % multiple != 0) 147 result += multiple - value % multiple; 148 return result; 149 } 150 151 // NOTE: from Hacker's Delight 152 function force_inline u64 153 round_down_power_of_two(u64 a) 154 { 155 u64 result = 0x8000000000000000ULL >> clz_u64(a); 156 return result; 157 } 158 159 function force_inline u64 160 round_up_power_of_two(u64 a) 161 { 162 u64 result = 0x8000000000000000ULL >> (clz_u64(a - 1) - 1); 163 return result; 164 } 165 166 167 ////////////////////////// 168 // NOTE: String Functions 169 170 function str8 171 str8_from_c_str(char *s) 172 { 173 str8 result = {.data = (u8 *)s}; 174 if (s) { 175 while (*s) s++; 176 result.length = (u8 *)s - result.data; 177 } 178 return result; 179 } 180 181 #endif /* RSTD_CORE_H */