-
Notifications
You must be signed in to change notification settings - Fork 2
/
util-basics.h
370 lines (305 loc) · 9.82 KB
/
util-basics.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
#pragma once
#include <cmath>
#include <cstdarg>
#include <cstring>
#include <ctype.h>
#include <float.h>
#include <string>
#include <vector>
// Compile-time array size
template <typename T, int N> char(&dim_helper(T(&)[N]))[N];
#define dim(x) (sizeof(dim_helper(x)))
#define dim_field(S, m) dim(((S*)0)->m)
#define sizeof_field(S, m) (sizeof(((S*)0)->m))
// Compile-time assert
#define cassert(x) static_assert(x, #x)
namespace util
{
// "uint" is a lot shorter than "unsigned int"
typedef unsigned int uint;
// "byte" is a lot shorter than "unsigned char"
typedef unsigned char byte;
// More short names for integer types
typedef char i8;
typedef short i16;
typedef int i32;
typedef __int64 i64;
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;
typedef unsigned __int64 u64;
// Delicious pi
static const float pi = 3.141592654f;
// Convenient float constants
static const float epsilon = 1e-6f; // A reasonable general-purpose epsilon
extern const float infinity;
extern const float NaN;
// Generic swap
template <typename T>
void swap(T & a, T & b) { T c = a; a = b; b = c; }
// Generic min/max/abs/clamp/saturate
template <typename T>
T min(T a, T b) { return (a < b) ? a : b; }
template <typename T>
T max(T a, T b) { return (a < b) ? b : a; }
template <typename T>
T abs(T a) { return (a < T(0)) ? -a : a; }
template <typename T>
T clamp(T value, T lower, T upper) { return min(max(value, lower), upper); }
template <typename T>
T saturate(T value) { return clamp(value, T(0), T(1)); }
// Generic lerp
template <typename T>
T lerp(T a, T b, float u) { return a + (b - a) * u; }
// Generic square
template <typename T>
T square(T a) { return a*a; }
// Equality test with epsilon
inline bool isnear(float a, float b, float eps = util::epsilon)
{ return (abs(b - a) < eps); }
// Test for finiteness
inline bool isfinite(float f)
{
union { uint i; float f; } u;
u.f = f;
return ((u.i & 0x7f800000) != 0x7f800000);
}
// Rounding to nearest integer
inline int round(float f)
{ return int(floor(f + 0.5f)); }
// Modulus with always positive remainders (assuming positive divisor)
inline int modPositive(int dividend, int divisor)
{
int result = dividend % divisor;
if (result < 0)
result += divisor;
return result;
}
inline float modPositive(float dividend, float divisor)
{
float result = fmod(dividend, divisor);
if (result < 0)
result += divisor;
return result;
}
// Base-2 exp and log
inline float exp2f(float x) { return expf(0.693147181f * x); }
inline float log2f(float x) { return 1.442695041f * logf(x); }
// Integer log2, with rounding up or down
inline int log2_floor(int x) { if (x <= 0) return 0; unsigned long c = 0; _BitScanReverse(&c, x); return int(c); }
inline int log2_ceil(int x) { return (x > 0) ? (log2_floor(x - 1) + 1) : 0; }
// Round up or down to nearest power of 2
inline bool ispow2(int x) { return (x > 0) && ((x & (x - 1)) == 0); }
inline int pow2_floor(int x) { return (1 << log2_floor(x)); }
inline int pow2_ceil(int x) { return (1 << log2_ceil(x)); }
// Integer division, with rounding up (assuming positive arguments)
inline int div_ceil(int dividend, int divisor) { return (dividend + (divisor - 1)) / divisor; }
// Integer rounding to multiples
inline int roundDown(int i, int multiple) { return (i / multiple) * multiple; }
inline int roundUp(int i, int multiple) { return ((i + (multiple - 1)) / multiple) * multiple; }
// Offset a pointer by a given number of bytes, regardless of pointer's type
// (note: number of bytes can be negative)
template <typename T>
inline T * offsetPtr(T * ptr, int bytes)
{ return (T *)((byte *)ptr + bytes); }
// Print an error message to stderr and immediately exit with code 1
void __declspec(noreturn) exit(const char * fmt, ...);
// Load an entire file into memory
enum LFK // Load File Kind
{
LFK_Binary,
LFK_Text,
};
bool LoadFile(const char * path, std::vector<byte> * pDataOut, LFK lfk = LFK_Binary);
// In-place destructive string tokenizer - like strtok, but with external state.
// Returns pointer to the start of the next token, and updates str to point to the
// remainder of the string
char * tokenize(char * & str, const char * delim);
// Variant that treats consecutive delimiters as denoting empty tokens between them
char * tokenizeConsecutive(char * & str, const char * delim);
// In-place convert a string to lowercase
inline void makeLowercase(char * str)
{
if (!str) return;
for (; *str; ++str)
*str = char(tolower(*str));
}
inline void makeLowercase(std::string & str)
{ makeLowercase(&str[0]); }
// In-place character replacement
inline void replaceChars(char * str, char target, char replacement)
{
if (!str) return;
for (; *str; ++str)
if (*str == target) *str = replacement;
}
inline void replaceChars(std::string & str, char target, char replacement)
{ replaceChars(&str[0], target, replacement); }
// Find basename of a path
inline const char * findBasename(const char * path, char separator = '/')
{
if (const char * pLastSeparator = strrchr(path, separator))
return pLastSeparator + 1;
return path;
}
inline char * findBasename(char * path, char separator = '/')
{ return (char *)findBasename((const char *)path, separator); }
inline const char * findBasename(const std::string & str, char separator = '/')
{ return findBasename(&str[0], separator); }
inline char * findBasename(std::string & str, char separator = '/')
{ return findBasename(&str[0], separator); }
// Extract the directory part of a path as a separate string (includes trailing slash)
inline std::string findDirectory(const char * path, char separator = '/')
{ return std::string(path, findBasename(path, separator)); }
}
// Logging and errors
#include "util-log.h"
#include "util-err.h"
namespace util
{
// Text parsing helper - in-place destructively parse text files into lines and
// whitespace-delimited tokens. Input is entire text file as a null-terminated string.
class TextParsingHelper
{
public:
char * m_pCtxLine;
char * m_pCtxToken;
const char * m_origin; // Origin of text, for use in error messages
int m_iLine; // 1-based line number, for use in error messages
explicit TextParsingHelper(char * pText, const char * origin = "")
: m_pCtxLine(pText), m_pCtxToken(nullptr), m_origin(origin), m_iLine(0)
{
ASSERT_ERR(pText);
}
bool NextLine()
{
while (char * pLine = tokenizeConsecutive(m_pCtxLine, "\n"))
{
++m_iLine;
// Strip comments starting with #
if (char * pChzComment = strchr(pLine, '#'))
*pChzComment = 0;
// Skip ahead to the first non-whitespace character
while (*pLine == ' ' || *pLine == '\t')
++pLine;
// Skip blank lines
if (!*pLine)
continue;
// Ready to parse token-by-token
m_pCtxToken = pLine;
return true;
}
return false;
}
char * NextToken()
{ return tokenize(m_pCtxToken, " \t"); }
void ExpectEOL()
{
// Issue a warning if there's any more tokens in the current line
if (const char * pExtra = NextToken())
WARN("%s: syntax error at line %d: unexpected extra token \"%s\"; ignoring", m_origin, m_iLine, pExtra);
}
char * ExpectOneToken(const char * whatsMissing = "token")
{
(void)whatsMissing;
// Grab a token and warn if it's missing
char * pToken = NextToken();
if (!pToken)
WARN("%s: syntax error at line %d: missing %s", m_origin, m_iLine, whatsMissing);
return pToken;
}
bool ExpectTokens(char ** tokensOut, int numTokens, const char * whatsMissing = "token")
{
// Grab several tokens and warn if any are missing
for (int i = 0; i < numTokens; ++i)
{
char * pToken = ExpectOneToken(whatsMissing);
if (!pToken)
return false;
tokensOut[i] = pToken;
}
return true;
}
};
// Serializing helpers - read/write common data types from a byte stream
class SerializeHelper
{
public:
std::vector<byte> * m_pData;
explicit SerializeHelper(std::vector<byte> * pData)
: m_pData(pData)
{
ASSERT_ERR(pData);
}
void WriteBytes(const void * data, size_t sizeBytes)
{ m_pData->insert(m_pData->end(), (byte *)data, (byte *)data + sizeBytes); }
template <typename T>
void Write(const T & t)
{ WriteBytes(&t, sizeof(T)); }
void WriteString(const char * str)
{ WriteBytes(str, strlen(str) + 1); }
void WriteString(const std::string & str)
{ WriteBytes(str.c_str(), str.size() + 1); }
};
class DeserializeHelper
{
public:
const byte * m_pCur;
const byte * m_pEnd;
explicit DeserializeHelper(const byte * pData, size_t sizeBytes)
: m_pCur(pData),
m_pEnd(pData + sizeBytes)
{
ASSERT_ERR(pData);
}
bool AtEOF()
{ return m_pCur == m_pEnd; }
bool ReadBytes(void * pDataOut, size_t sizeBytes)
{
if (size_t(m_pEnd - m_pCur) < sizeBytes)
{
WARN("Corrupt serialized data: missing %zu bytes", sizeBytes);
return false;
}
memcpy(pDataOut, m_pCur, sizeBytes);
m_pCur += sizeBytes;
return true;
}
template <typename T>
bool Read(T * pTOut)
{ return ReadBytes(pTOut, sizeof(T)); }
bool ReadString(const char ** pStrOut)
{
ASSERT_ERR(pStrOut);
*pStrOut = (const char *)m_pCur;
// Advance past the string contents
while (m_pCur < m_pEnd && *m_pCur)
++m_pCur;
if (m_pCur == m_pEnd)
{
WARN("Corrupt serialized data: unterminated string");
return false;
}
// Advance past the null terminator
++m_pCur;
return true;
}
bool ReadString(std::string * pStrOut)
{
ASSERT_ERR(pStrOut);
const char * pStart = (const char *)m_pCur;
// Advance past the string contents
while (m_pCur < m_pEnd && *m_pCur)
++m_pCur;
if (m_pCur == m_pEnd)
{
WARN("Corrupt serialized data: unterminated string");
return false;
}
pStrOut->assign(pStart, (const char *)m_pCur);
// Advance past the null terminator
++m_pCur;
return true;
}
};
}