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
|
//~ Strings
#include <stdarg.h>
#include <stdio.h>
global_variable arena *StringsScratch = 0;
internal b32
IsPrintable(u8 Char)
{
b32 Result = (Char >= ' ' && Char <= '~');
return Result;
}
internal b32
IsRuneDigit(rune Char)
{
b32 Result = (Char >= '0' && Char <= '9');
return Result;
}
internal b32
IsRuneAlpha(rune Char)
{
b32 Result = ((Char >= 'A' && Char <= 'Z') ||
(Char >= 'a' && Char <= 'z'));
return Result;
}
internal b32
IsDigit(u8 Char)
{
b32 Result = (Char >= '0' && Char <= '9');
return Result;
}
internal b32
IsAlpha(u8 Char)
{
b32 Result = ((Char >= 'A' && Char <= 'Z') ||
(Char >= 'a' && Char <= 'z'));
return Result;
}
internal u8
ToLowercase(u8 Char)
{
u8 Result = Char;
if(Char >= 'A' && Char <= 'Z')
{
Result = (Char - (u8)('A' - 'a'));
}
return Result;
}
internal str8
S8SkipLastSlash(str8 String)
{
u64 LastSlash = 0;
for EachIndex(Idx, String.Size)
{
if(String.Data[Idx] == '/')
{
LastSlash = Idx;
}
}
LastSlash += 1;
str8 Result = S8From(String, LastSlash);
return Result;
}
internal b32
S8Match(str8 A, str8 B, b32 BIsPrefix)
{
b32 Match = false;
b32 Requirements = false;
Requirements |= ( BIsPrefix && (B.Size <= A.Size));
Requirements |= (!BIsPrefix && (B.Size == A.Size));
if(Requirements)
{
Match = true;
for EachIndex(Idx, B.Size)
{
if((A.Data[Idx] != B.Data[Idx]))
{
Match = false;
break;
}
}
}
return Match;
}
internal u64
StringLength(char *String)
{
u64 Result = 0;
while(*String)
{
String += 1;
Result += 1;
}
return Result;
}
internal str8
S8Cat(str8 Prefix, str8 Suffix)
{
arena *Arena = StringsScratch;
str8 Result = PushS8(Arena, Prefix.Size + Suffix.Size);
u64 At = 0;
for EachIndex(Idx, Prefix.Size)
{
Result.Data[At + Idx] = Prefix.Data[Idx];
}
At += Prefix.Size;
for EachIndex(Idx, Suffix.Size)
{
Result.Data[At + Idx] = Suffix.Data[Idx];
}
return Result;
}
internal str8
Str8Fmt(char *Format, ...)
{
str8 Result = {0};
arena *Arena = StringsScratch;
Result.Data = PushArray(Arena, u8, 256);
va_list Args;
va_start(Args, Format);
Result.Size = (u64)vsprintf((char *)Result.Data, Format, Args);
return Result;
}
#if !defined(BASE_EXTERNAL_LIBS)
# if !defined(XXH_IMPLEMENTATION)
# define XXH_INLINE_ALL
# define XXH_STATIC_LINKING_ONLY
# define XXH_IMPLEMENTATION
# endif
#endif
#include "lib/xxHash/xxhash.h"
internal u64
U64HashFromSeedStr8(u64 Seed, str8 String)
{
u64 Result = XXH3_64bits_withSeed(String.Data, String.Size, Seed);
return Result;
}
internal u64
U64HashFromStr8(str8 String)
{
u64 Result = U64HashFromSeedStr8(5381, String);
return Result;
}
|
