444 lines
12 KiB
C++
444 lines
12 KiB
C++
API char ToLowerCase(char a) {
|
|
if (a >= 'A' && a <= 'Z') a += 32;
|
|
return a;
|
|
}
|
|
|
|
API char ToUpperCase(char a) {
|
|
if (a >= 'a' && a <= 'z') a -= 32;
|
|
return a;
|
|
}
|
|
|
|
API bool IsWhitespace(char w) {
|
|
bool result = w == '\n' || w == ' ' || w == '\t' || w == '\v' || w == '\r';
|
|
return result;
|
|
}
|
|
|
|
API bool IsAlphabetic(char a) {
|
|
bool result = (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z');
|
|
return result;
|
|
}
|
|
|
|
API bool IsIdent(char a) {
|
|
bool result = (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z') || a == '_';
|
|
return result;
|
|
}
|
|
|
|
API bool IsDigit(char a) {
|
|
bool result = a >= '0' && a <= '9';
|
|
return result;
|
|
}
|
|
|
|
API bool IsAlphanumeric(char a) {
|
|
bool result = IsDigit(a) || IsAlphabetic(a);
|
|
return result;
|
|
}
|
|
|
|
API bool IsSymbol(char w) {
|
|
bool result = (w >= '!' && w <= '/') || (w >= ':' && w <= '@') || (w >= '[' && w <= '`') || (w >= '{' && w <= '~');
|
|
return result;
|
|
}
|
|
|
|
API bool IsNonWord(char w) {
|
|
if (w == '_') return false;
|
|
bool result = IsSymbol(w) || IsWhitespace(w);
|
|
return result;
|
|
}
|
|
|
|
API bool IsWord(char w) {
|
|
bool result = !IsNonWord(w);
|
|
return result;
|
|
}
|
|
|
|
API bool IsBrace(char c) {
|
|
bool result = c == '{' || c == '}';
|
|
return result;
|
|
}
|
|
|
|
API bool IsParen(char c) {
|
|
bool result = c == '(' || c == ')';
|
|
return result;
|
|
}
|
|
|
|
API String Chop(String a, int64_t len) {
|
|
len = ClampTop(len, a.len);
|
|
String result = {a.data, a.len - len};
|
|
return result;
|
|
}
|
|
|
|
API String Skip(String a, int64_t len) {
|
|
len = ClampTop(len, a.len);
|
|
String result = {a.data + len, a.len - len};
|
|
return result;
|
|
}
|
|
|
|
API String GetPostfix(String a, int64_t len) {
|
|
len = ClampTop(len, a.len);
|
|
int64_t remain_len = a.len - len;
|
|
String result = {a.data + remain_len, len};
|
|
return result;
|
|
}
|
|
|
|
API String GetPrefix(String a, int64_t len) {
|
|
len = ClampTop(len, a.len);
|
|
String result = {a.data, len};
|
|
return result;
|
|
}
|
|
|
|
API char At(String a, int64_t idx) {
|
|
if (idx < a.len) {
|
|
return a.data[idx];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
API String GetSlice(String arr, int64_t first_index, int64_t one_past_last_index) {
|
|
// Negative indexes work in python style, they return you the index counting from end of list
|
|
if (one_past_last_index == SLICE_LAST) one_past_last_index = arr.len;
|
|
if (one_past_last_index < 0) one_past_last_index = arr.len + one_past_last_index;
|
|
|
|
if (first_index == SLICE_LAST) first_index = arr.len;
|
|
if (first_index < 0) first_index = arr.len + first_index;
|
|
|
|
String result = {arr.data, arr.len};
|
|
if (arr.len > 0) {
|
|
if (one_past_last_index > first_index) {
|
|
first_index = ClampTop(first_index, arr.len - 1);
|
|
one_past_last_index = ClampTop(one_past_last_index, arr.len);
|
|
result.data += first_index;
|
|
result.len = one_past_last_index - first_index;
|
|
} else {
|
|
result.len = 0;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
API bool AreEqual(String a, String b, unsigned ignore_case) {
|
|
if (a.len != b.len) return false;
|
|
for (int64_t i = 0; i < a.len; i++) {
|
|
char A = a.data[i];
|
|
char B = b.data[i];
|
|
if (ignore_case) {
|
|
A = ToLowerCase(A);
|
|
B = ToLowerCase(B);
|
|
}
|
|
if (A != B)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
API bool EndsWith(String a, String end, unsigned ignore_case) {
|
|
String a_end = GetPostfix(a, end.len);
|
|
bool result = AreEqual(end, a_end, ignore_case);
|
|
return result;
|
|
}
|
|
|
|
API bool StartsWith(String a, String start, unsigned ignore_case) {
|
|
String a_start = GetPrefix(a, start.len);
|
|
bool result = AreEqual(start, a_start, ignore_case);
|
|
return result;
|
|
}
|
|
|
|
API String Trim(String string) {
|
|
if (string.len == 0)
|
|
return string;
|
|
|
|
int64_t whitespace_begin = 0;
|
|
for (; whitespace_begin < string.len; whitespace_begin++) {
|
|
if (!IsWhitespace(string.data[whitespace_begin])) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
int64_t whitespace_end = string.len;
|
|
for (; whitespace_end != whitespace_begin; whitespace_end--) {
|
|
if (!IsWhitespace(string.data[whitespace_end - 1])) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (whitespace_begin == whitespace_end) {
|
|
string.len = 0;
|
|
} else {
|
|
string = GetSlice(string, whitespace_begin, whitespace_end);
|
|
}
|
|
|
|
return string;
|
|
}
|
|
|
|
API String TrimEnd(String string) {
|
|
int64_t whitespace_end = string.len;
|
|
for (; whitespace_end != 0; whitespace_end--) {
|
|
if (!IsWhitespace(string.data[whitespace_end - 1])) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
String result = GetPrefix(string, whitespace_end);
|
|
return result;
|
|
}
|
|
|
|
API String Copy(Allocator allocator, String string) {
|
|
char *copy = (char *)AllocSize(allocator, sizeof(char) * (string.len + 1));
|
|
memcpy(copy, string.data, string.len);
|
|
copy[string.len] = 0;
|
|
String result = {copy, string.len};
|
|
return result;
|
|
}
|
|
|
|
API String Copy(Allocator allocator, char *string) {
|
|
return Copy(allocator, {string, (int64_t)strlen(string)});
|
|
}
|
|
|
|
API void NormalizePathInPlace(String s) {
|
|
for (int64_t i = 0; i < s.len; i++) {
|
|
if (s.data[i] == '\\')
|
|
s.data[i] = '/';
|
|
}
|
|
}
|
|
|
|
API String NormalizePath(Allocator allocator, String s) {
|
|
String copy = Copy(allocator, s);
|
|
NormalizePathInPlace(copy);
|
|
return copy;
|
|
}
|
|
|
|
API bool Seek(String string, String find, int64_t *index_out, SeekFlag flags) {
|
|
bool ignore_case = flags & SeekFlag_IgnoreCase ? true : false;
|
|
bool result = false;
|
|
if (flags & SeekFlag_MatchFindLast) {
|
|
for (int64_t i = string.len; i != 0; i--) {
|
|
int64_t index = i - 1;
|
|
String substring = GetSlice(string, index, index + find.len);
|
|
if (AreEqual(substring, find, ignore_case)) {
|
|
bool ok_boundary = true;
|
|
if (flags & SeekFlag_WordBoundary) {
|
|
String left = GetSlice(string, i - 1, i);
|
|
String right = GetSlice(string, i + find.len, i + find.len + 1);
|
|
if (left.len != 0 && !IsNonWord(left.data[0])) {
|
|
ok_boundary = false;
|
|
}
|
|
if (right.len != 0 && !IsNonWord(right.data[0])) {
|
|
ok_boundary = false;
|
|
}
|
|
}
|
|
if (ok_boundary) {
|
|
if (index_out) {
|
|
*index_out = index;
|
|
}
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (int64_t i = 0; i < string.len; i++) {
|
|
String substring = GetSlice(string, i, i + find.len);
|
|
if (AreEqual(substring, find, ignore_case)) {
|
|
bool ok_boundary = true;
|
|
if (flags & SeekFlag_WordBoundary) {
|
|
String left = GetSlice(string, i - 1, i);
|
|
String right = GetSlice(string, i + find.len, i + find.len + 1);
|
|
if (left.len != 0 && !IsNonWord(left.data[0])) {
|
|
ok_boundary = false;
|
|
}
|
|
if (right.len != 0 && !IsNonWord(right.data[0])) {
|
|
ok_boundary = false;
|
|
}
|
|
}
|
|
if (ok_boundary) {
|
|
if (index_out) {
|
|
*index_out = i;
|
|
}
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
API String CutLastSlash(String *s) {
|
|
String result = *s;
|
|
Seek(*s, "/", &s->len, SeekFlag_MatchFindLast);
|
|
result = Skip(result, s->len);
|
|
return result;
|
|
}
|
|
|
|
API String ChopLastSlash(String s) {
|
|
String result = s;
|
|
Seek(s, "/", &result.len, SeekFlag_MatchFindLast);
|
|
return result;
|
|
}
|
|
|
|
API String ChopLastPeriod(String s) {
|
|
String result = s;
|
|
Seek(s, ".", &result.len, SeekFlag_MatchFindLast);
|
|
return result;
|
|
}
|
|
|
|
API String SkipToLastSlash(String s) {
|
|
int64_t pos;
|
|
String result = s;
|
|
if (Seek(s, "/", &pos, SeekFlag_MatchFindLast)) {
|
|
result = Skip(result, pos + 1);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
API String SkipToLastPeriod(String s) {
|
|
int64_t pos;
|
|
String result = s;
|
|
if (Seek(s, ".", &pos, SeekFlag_MatchFindLast)) {
|
|
result = Skip(result, pos + 1);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
API String CutPrefix(String *string, int64_t len) {
|
|
String result = GetPrefix(*string, len);
|
|
*string = Skip(*string, len);
|
|
return result;
|
|
}
|
|
|
|
API String CutPostfix(String *string, int64_t len) {
|
|
String result = GetPostfix(*string, len);
|
|
*string = Chop(*string, len);
|
|
return result;
|
|
}
|
|
|
|
API String FormatV(Allocator allocator, const char *data, va_list args1) {
|
|
va_list args2;
|
|
va_copy(args2, args1);
|
|
int64_t len = stbsp_vsnprintf(0, 0, data, args2);
|
|
va_end(args2);
|
|
|
|
char *result = (char *)AllocSize(allocator, sizeof(char) * (len + 1));
|
|
stbsp_vsnprintf(result, (int)(len + 1), data, args1);
|
|
String res = {result, len};
|
|
return res;
|
|
}
|
|
|
|
API String Format(Allocator allocator, const char *data, ...) {
|
|
STRING_FORMAT(allocator, data, result);
|
|
return result;
|
|
}
|
|
|
|
API Array<String> Split(Allocator allocator, String string, String delimiter) {
|
|
Array<String> result = {allocator};
|
|
int64_t index = 0;
|
|
while (Seek(string, delimiter, &index)) {
|
|
String before_match = {string.data, index};
|
|
Add(&result, before_match);
|
|
string = Skip(string, index + delimiter.len);
|
|
}
|
|
Add(&result, string);
|
|
return result;
|
|
}
|
|
|
|
API String Merge(Allocator allocator, Array<String> list, String separator) {
|
|
int64_t char_count = 0;
|
|
For(list) char_count += it.len;
|
|
if (char_count == 0) return {};
|
|
int64_t node_count = list.len;
|
|
|
|
int64_t base_size = (char_count + 1);
|
|
int64_t sep_size = (node_count - 1) * separator.len;
|
|
int64_t size = base_size + sep_size;
|
|
char *buff = (char *)AllocSize(allocator, sizeof(char) * (size + 1));
|
|
String string = {buff, 0};
|
|
For(list) {
|
|
Assert(string.len + it.len <= size);
|
|
memcpy(string.data + string.len, it.data, it.len);
|
|
string.len += it.len;
|
|
if (!IsLast(list, it)) {
|
|
memcpy(string.data + string.len, separator.data, separator.len);
|
|
string.len += separator.len;
|
|
}
|
|
}
|
|
Assert(string.len == size - 1);
|
|
string.data[size] = 0;
|
|
return string;
|
|
}
|
|
|
|
API Int GetSize(Array<String> array) {
|
|
Int result = 0;
|
|
For (array) result += it.len;
|
|
return result;
|
|
}
|
|
|
|
API bool Chop(String *string, String ending) {
|
|
if (EndsWith(*string, ending)) {
|
|
*string = Chop(*string, ending.len);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
API String SkipNumberEx(String *string) {
|
|
String col = {string->data, 0};
|
|
for (int64_t i = 0; i < string->len; i += 1) {
|
|
if (IsDigit(string->data[i])) {
|
|
col.len += 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
*string = Skip(*string, col.len);
|
|
return col;
|
|
}
|
|
|
|
API Int SkipNumber(String *string) {
|
|
String col = SkipNumberEx(string);
|
|
if (col.len == 0) return -1;
|
|
Int result = strtoll(col.data, NULL, 10);
|
|
return result;
|
|
}
|
|
|
|
API String SkipUntil(String *string, String str) {
|
|
String begin = *string;
|
|
begin.len = 0;
|
|
for (; string->len; begin.len += 1) {
|
|
String match = GetPrefix(*string, str.len);
|
|
if (StartsWith(match, str)) break;
|
|
*string = Skip(*string, 1);
|
|
}
|
|
return begin;
|
|
}
|
|
|
|
API String SkipWhitespace(String *string) {
|
|
String begin = {string->data, 0};
|
|
for (Int i = 0; i < string->len; i += 1) {
|
|
if (!IsWhitespace(string->data[i])) break;
|
|
*string = Skip(*string, 1);
|
|
begin.len += 1;
|
|
}
|
|
return begin;
|
|
}
|
|
|
|
|
|
API String ChopNumberEx(String *string) {
|
|
String col = {};
|
|
for (int64_t i = string->len - 1; i >= 0; i -= 1) {
|
|
if (IsDigit(string->data[i])) {
|
|
col.data = string->data + i;
|
|
col.len += 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
*string = Chop(*string, col.len);
|
|
return col;
|
|
}
|
|
|
|
API Int ChopNumber(String *string) {
|
|
Scratch scratch;
|
|
String col = ChopNumberEx(string);
|
|
if (col.len == 0) return -1;
|
|
Int result = strtoll(col.data, NULL, 10) - 1;
|
|
return result;
|
|
}
|