1214 lines
26 KiB
C
1214 lines
26 KiB
C
////////////////////////////////////////////////////////////
|
|
//~ Conversion helpers
|
|
|
|
String StringFromBool(Arena *arena, b32 b)
|
|
{
|
|
return b ? PushString(arena, Lit("true")) : PushString(arena, Lit("false"));
|
|
}
|
|
|
|
String StringFromChar(Arena *arena, char c)
|
|
{
|
|
u8 *dst = PushStructNoZero(arena, u8);
|
|
*dst = c;
|
|
return (String)
|
|
{
|
|
.len = 1,
|
|
.text = dst
|
|
};
|
|
}
|
|
|
|
String StringFromUint(Arena *arena, u64 n, u64 base, u64 zfill)
|
|
{
|
|
// Base too large
|
|
Assert(base <= (countof(IntChars) - 1));
|
|
String result = Zi;
|
|
TempArena scratch = BeginScratch(arena);
|
|
{
|
|
// Build backwards text starting from least significant digit
|
|
u8 *backwards_text = ArenaNext(scratch.arena, u8);
|
|
do
|
|
{
|
|
StringFromChar(scratch.arena, IntChars[n % base]);
|
|
++result.len;
|
|
n /= base;
|
|
} while (n > 0);
|
|
|
|
// Fill zeroes
|
|
while (result.len < zfill)
|
|
{
|
|
StringFromChar(scratch.arena, '0');
|
|
++result.len;
|
|
}
|
|
|
|
// Reverse text into final string
|
|
result.text = PushStructsNoZero(arena, u8, result.len);
|
|
for (u64 i = 0; i < result.len; ++i)
|
|
{
|
|
result.text[i] = backwards_text[result.len - i - 1];
|
|
}
|
|
|
|
}
|
|
EndScratch(scratch);
|
|
return result;
|
|
}
|
|
|
|
String StringFromUints(Arena *arena, u64 uints_count, u64 *uints, u64 base, u64 zfill)
|
|
{
|
|
String result = Zi;
|
|
result.text = ArenaNext(arena, u8);
|
|
result.len += StringFromChar(arena, '(').len;
|
|
for (u64 uint_idx = 0; uint_idx < uints_count; ++uint_idx)
|
|
{
|
|
result.len += StringFromUint(arena, uints[uint_idx], base, zfill).len;
|
|
if (uint_idx + 1 < uints_count)
|
|
{
|
|
result.len += PushString(arena, Lit(", ")).len;
|
|
}
|
|
}
|
|
result.len += StringFromChar(arena, ')').len;
|
|
return result;
|
|
}
|
|
|
|
String StringFromSint(Arena *arena, i64 n, u64 base, u64 zfill)
|
|
{
|
|
String result = Zi;
|
|
result.text = ArenaNext(arena, u8);
|
|
if (n < 0)
|
|
{
|
|
result.len += StringFromChar(arena, '-').len;
|
|
n = -n;
|
|
}
|
|
result.len += StringFromUint(arena, (u64)n, base, zfill).len;
|
|
return result;
|
|
}
|
|
|
|
String StringFromSints(Arena *arena, u64 sints_count, i64 *sints, u64 base, u64 zfill)
|
|
{
|
|
String result = Zi;
|
|
result.text = ArenaNext(arena, u8);
|
|
result.len += StringFromChar(arena, '(').len;
|
|
for (u64 sint_idx = 0; sint_idx < sints_count; ++sint_idx)
|
|
{
|
|
result.len += StringFromSint(arena, sints[sint_idx], base, zfill).len;
|
|
if (sint_idx + 1 < sints_count)
|
|
{
|
|
result.len += PushString(arena, Lit(", ")).len;
|
|
}
|
|
}
|
|
result.len += StringFromChar(arena, ')').len;
|
|
return result;
|
|
}
|
|
|
|
String StringFromFloat(Arena *arena, f64 src, u32 precision)
|
|
{
|
|
String result = Zi;
|
|
precision = MinU32(precision, 16);
|
|
|
|
if (IsNan(src))
|
|
{
|
|
result = PushString(arena, Lit("NaN"));
|
|
}
|
|
else if (IsInf(src))
|
|
{
|
|
if (src >= 0)
|
|
{
|
|
result = PushString(arena, Lit("inf"));
|
|
}
|
|
else
|
|
{
|
|
result = PushString(arena, Lit("-inf"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result.text = ArenaNext(arena, u8);
|
|
|
|
u64 p = PowU64(10, precision);
|
|
f64 multiplied = RoundF64(src * p);
|
|
|
|
i32 sign = (src >= 0) - (src < 0);
|
|
u64 part_whole = TruncF64(AbsF64(multiplied) / p);
|
|
|
|
u64 part_frac = RoundF64(AbsF64(AbsF64(src) - part_whole) * p);
|
|
|
|
// Push sign
|
|
if (sign < 0 && (part_whole != 0 || part_frac != 0))
|
|
{
|
|
result.len += StringFromChar(arena, '-').len;
|
|
}
|
|
|
|
// Push whole part
|
|
result.len += StringFromUint(arena, part_whole, 10, 0).len;
|
|
|
|
// Push frac part
|
|
if (part_frac != 0)
|
|
{
|
|
result.len += StringFromChar(arena, '.').len;
|
|
i64 frac_start_idx = result.len;
|
|
result.len += StringFromUint(arena, part_frac, 10, precision).len;
|
|
|
|
// Remove trailing zeroes
|
|
for (i64 char_idx = result.len - 1; char_idx > frac_start_idx; --char_idx)
|
|
{
|
|
u8 c = result.text[char_idx];
|
|
if (c == '0')
|
|
{
|
|
result.len -= 1;
|
|
PopBytesNoCopy(arena, 1);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
String StringFromFloats(Arena *arena, u64 floats_count, f64 *floats, u32 precision)
|
|
{
|
|
String result = Zi;
|
|
result.text = ArenaNext(arena, u8);
|
|
result.len += StringFromChar(arena, '(').len;
|
|
for (u64 float_idx = 0; float_idx < floats_count; ++float_idx)
|
|
{
|
|
result.len += StringFromFloat(arena, floats[float_idx], precision).len;
|
|
if (float_idx + 1 < floats_count)
|
|
{
|
|
result.len += PushString(arena, Lit(", ")).len;
|
|
}
|
|
}
|
|
result.len += StringFromChar(arena, ')').len;
|
|
return result;
|
|
}
|
|
|
|
String StringFromPtr(Arena *arena, void *ptr)
|
|
{
|
|
String prepend = PushString(arena, Lit("0x"));
|
|
String uint_str = StringFromUint(arena, (u64)ptr, 16, sizeof(ptr));
|
|
return (String)
|
|
{
|
|
.len = prepend.len + uint_str.len,
|
|
.text = prepend.text
|
|
};
|
|
}
|
|
|
|
String StringFromhandle(Arena *arena, u64 v0, u64 v1)
|
|
{
|
|
String result = Zi;
|
|
result.text = ArenaNext(arena, u8);
|
|
result.len += PushString(arena, Lit("h")).len;
|
|
result.len += StringFromUint(arena, v0, 16, 0).len;
|
|
result.len += PushString(arena, Lit("x")).len;
|
|
result.len += StringFromUint(arena, v1, 16, 0).len;
|
|
return result;
|
|
}
|
|
|
|
String StringFromUid(Arena *arena, Uid uid)
|
|
{
|
|
String result = Zi;
|
|
result.text = ArenaNext(arena, u8);
|
|
result.len += StringFromUint(arena, (uid.hi >> 32), 16, 8).len;
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
//~ Parsing helpers
|
|
|
|
b32 BoolFromString(String str)
|
|
{
|
|
b32 result = 0;
|
|
result = MatchString(str, Lit("true"));
|
|
return result;
|
|
}
|
|
|
|
f64 FloatFromString(String str)
|
|
{
|
|
f64 result = 0;
|
|
|
|
b32 ok = 1;
|
|
|
|
// Eat sign
|
|
u64 whole_start_idx = 0;
|
|
i32 sign = 1;
|
|
if (ok && str.len > 0)
|
|
{
|
|
if (whole_start_idx < str.len)
|
|
{
|
|
u8 c = str.text[whole_start_idx];
|
|
if (c == '-')
|
|
{
|
|
sign = -1;
|
|
whole_start_idx += 1;
|
|
}
|
|
else if (c == '+')
|
|
{
|
|
whole_start_idx += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find decimal place
|
|
u64 frac_start_idx = whole_start_idx;
|
|
for (; ok && frac_start_idx < str.len; ++frac_start_idx)
|
|
{
|
|
u8 c = str.text[frac_start_idx];
|
|
if (c == '.')
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Parse whole part
|
|
u64 whole_part = 0;
|
|
for (u64 char_idx = whole_start_idx; ok && char_idx < frac_start_idx; ++char_idx)
|
|
{
|
|
u8 c = str.text[char_idx];
|
|
if (c >= '0' && c <= '9')
|
|
{
|
|
u8 digit = c - '0';
|
|
whole_part += digit * PowU64(10, frac_start_idx - (char_idx + 1));
|
|
}
|
|
else
|
|
{
|
|
ok = 0;
|
|
}
|
|
}
|
|
|
|
// Parse frac part
|
|
u64 frac_part = 0;
|
|
for (u64 char_idx = frac_start_idx + 1; ok && char_idx < str.len; ++char_idx)
|
|
{
|
|
u8 c = str.text[char_idx];
|
|
if (c >= '0' && c <= '9')
|
|
{
|
|
u8 digit = c - '0';
|
|
frac_part += digit * PowU64(10, str.len - (char_idx + 1));
|
|
}
|
|
else
|
|
{
|
|
ok = 0;
|
|
}
|
|
}
|
|
|
|
if (ok)
|
|
{
|
|
if (frac_part != 0)
|
|
{
|
|
result = ((f64)whole_part + ((f64)frac_part / PowU64(10, str.len - (frac_start_idx + 1)))) * sign;
|
|
}
|
|
else
|
|
{
|
|
result = (f64)whole_part * sign;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = 0;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
//~ String helpers
|
|
|
|
String PushString(Arena *arena, String src)
|
|
{
|
|
String result = Zi;
|
|
result.len = src.len;
|
|
result.text = PushStructsNoZero(arena, u8, src.len);
|
|
CopyBytes(result.text, src.text, src.len);
|
|
return result;
|
|
}
|
|
|
|
String CopyString(String dst, String src)
|
|
{
|
|
String result = Zi;
|
|
result.len = MinU64(dst.len, src.len);
|
|
result.text = dst.text;
|
|
CopyBytes(result.text, src.text, result.len);
|
|
return result;
|
|
}
|
|
|
|
String RepeatString(Arena *arena, String src, u64 count)
|
|
{
|
|
u64 final_len = src.len * count;
|
|
u8 *final_text = PushStructsNoZero(arena, u8, final_len);
|
|
for (u64 i = 0; i < count; ++i)
|
|
{
|
|
CopyBytes(final_text + (src.len * i), src.text, src.len);
|
|
}
|
|
return (String)
|
|
{
|
|
.text = final_text,
|
|
.len = final_len
|
|
};
|
|
}
|
|
|
|
String CatString(Arena *arena, String str1, String str2)
|
|
{
|
|
String new_str = Zi;
|
|
new_str.len = str1.len + str2.len;
|
|
new_str.text = PushStructsNoZero(arena, u8, new_str.len);
|
|
CopyBytes(new_str.text, str1.text, str1.len);
|
|
CopyBytes(new_str.text + str1.len, str2.text, str2.len);
|
|
return new_str;
|
|
}
|
|
|
|
// `arena` is where pieces will be allocated. These strings point
|
|
// into the existing string and do not allocate any new text.
|
|
StringArray SplitString(Arena *arena, String str, String delim)
|
|
{
|
|
StringArray pieces = Zi;
|
|
pieces.strings = ArenaNext(arena, String);
|
|
i64 piece_start = 0;
|
|
for (i64 i = 0; i < (i64)str.len - (i64)delim.len;)
|
|
{
|
|
String cmp = Zi;
|
|
cmp.text = &str.text[i];
|
|
cmp.len = MinI64(str.len - i, delim.len);
|
|
|
|
if (MatchString(cmp, delim))
|
|
{
|
|
String piece = Zi;
|
|
piece.text = &str.text[piece_start];
|
|
piece.len = i - piece_start;
|
|
*PushStructNoZero(arena, String) = piece;
|
|
++pieces.count;
|
|
i += delim.len;
|
|
piece_start = i;
|
|
}
|
|
else
|
|
{
|
|
i += 1;
|
|
}
|
|
}
|
|
if (piece_start < (i64)str.len)
|
|
{
|
|
String piece = Zi;
|
|
piece.text = &str.text[piece_start];
|
|
piece.len = str.len - piece_start;
|
|
*PushStructNoZero(arena, String) = piece;
|
|
++pieces.count;
|
|
}
|
|
return pieces;
|
|
}
|
|
|
|
String ReplaceString(Arena *arena, String str, String old_pattern, String new_pattern)
|
|
{
|
|
String result = Zi;
|
|
result.text = ArenaNext(arena, u8);
|
|
i64 piece_start = 0;
|
|
for (i64 i = 0; i < (i64)str.len - (i64)old_pattern.len;)
|
|
{
|
|
String cmp = Zi;
|
|
cmp.text = &str.text[i];
|
|
cmp.len = MinI64(str.len - i, old_pattern.len);
|
|
if (MatchString(cmp, old_pattern))
|
|
{
|
|
String piece = Zi;
|
|
piece.text = &str.text[piece_start];
|
|
piece.len = i - piece_start;
|
|
if (piece.len > 0)
|
|
{
|
|
result.len += PushString(arena, piece).len;
|
|
}
|
|
result.len += PushString(arena, new_pattern).len;
|
|
i += old_pattern.len;
|
|
piece_start = i;
|
|
}
|
|
else
|
|
{
|
|
i += 1;
|
|
}
|
|
}
|
|
if (piece_start < (i64)str.len)
|
|
{
|
|
String piece = Zi;
|
|
piece.text = &str.text[piece_start];
|
|
piece.len = str.len - piece_start;
|
|
result.len += PushString(arena, piece).len;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// NOTE: Really slow
|
|
String IndentString(Arena *arena, String str, u32 indent)
|
|
{
|
|
TempArena scratch = BeginScratch(arena);
|
|
|
|
u64 final_len = 0;
|
|
u8 *final_text = ArenaNext(arena, u8);
|
|
|
|
StringArray split = SplitString(scratch.arena, str, Lit("\n"));
|
|
for (u64 i = 0; i < split.count; ++i)
|
|
{
|
|
String piece = split.strings[i];
|
|
for (u32 j = 0; j < indent; ++j)
|
|
{
|
|
StringFromChar(arena, ' ');
|
|
++final_len;
|
|
}
|
|
PushString(arena, piece);
|
|
final_len += piece.len;
|
|
if (i < split.count - 1)
|
|
{
|
|
StringFromChar(arena, '\n');
|
|
++final_len;
|
|
}
|
|
}
|
|
|
|
EndScratch(scratch);
|
|
|
|
return (String)
|
|
{
|
|
.len = final_len,
|
|
.text = final_text
|
|
};
|
|
}
|
|
|
|
String LowerString(Arena *arena, String str)
|
|
{
|
|
String result = Zi;
|
|
result.text = PushStructsNoZero(arena, u8, str.len);
|
|
result.len = str.len;
|
|
|
|
for (u64 i = 0; i < str.len; ++i)
|
|
{
|
|
u8 c = str.text[i];
|
|
if (65 <= c && c <= 90)
|
|
{
|
|
c += 32;
|
|
}
|
|
result.text[i] = c;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
b32 MatchString(String str1, String str2)
|
|
{
|
|
b32 eq = 1;
|
|
if (str1.len == str2.len)
|
|
{
|
|
for (u64 i = 0; i < str1.len; ++i)
|
|
{
|
|
if (str1.text[i] != str2.text[i])
|
|
{
|
|
eq = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eq = 0;
|
|
}
|
|
return eq;
|
|
}
|
|
|
|
b32 StringContains(String str, String substring)
|
|
{
|
|
if (substring.len > str.len)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
for (u64 i = 0; i <= str.len - substring.len; ++i)
|
|
{
|
|
b32 match = 1;
|
|
for (u64 j = 0; j < substring.len; ++j)
|
|
{
|
|
if (str.text[i + j] != substring.text[j])
|
|
{
|
|
match = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (match)
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
b32 StringBeginsWith(String str, String substring)
|
|
{
|
|
if (str.len >= substring.len)
|
|
{
|
|
for (u64 i = 0; i < substring.len; ++i)
|
|
{
|
|
if (str.text[i] != substring.text[i])
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
b32 StringEndsWith(String str, String substring)
|
|
{
|
|
if (str.len >= substring.len)
|
|
{
|
|
u64 start = str.len - substring.len;
|
|
for (u64 i = 0; i < substring.len; ++i)
|
|
{
|
|
if (str.text[start + i] != substring.text[i])
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
String StringFromArray(Arena *arena, StringArray a)
|
|
{
|
|
String result = Zi;
|
|
result.text = ArenaNext(arena, u8);
|
|
for (u64 string_idx = 0; string_idx < a.count; ++string_idx)
|
|
{
|
|
result.len += PushString(arena, a.strings[string_idx]).len;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
//~ String list helpers
|
|
|
|
StringListNode *PushStringToList(Arena *arena, StringList *l, String s)
|
|
{
|
|
StringListNode *n = PushStruct(arena, StringListNode);
|
|
n->s = s;
|
|
n->prev = l->last;
|
|
if (l->last)
|
|
{
|
|
l->last->next = n;
|
|
}
|
|
else
|
|
{
|
|
l->first = n;
|
|
}
|
|
l->last = n;
|
|
++l->count;
|
|
return n;
|
|
}
|
|
|
|
String StringFromList(Arena *arena, StringList l, String separator)
|
|
{
|
|
String result = Zi;
|
|
result.text = ArenaNext(arena, u8);
|
|
for (StringListNode *n = l.first; n; n = n->next)
|
|
{
|
|
String s = n->s;
|
|
PushString(arena, s);
|
|
result.len += s.len;
|
|
if (n->next)
|
|
{
|
|
PushString(arena, separator);
|
|
result.len += separator.len;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
//~ Trimming helpers
|
|
|
|
String TrimLeft(String s, String pattern)
|
|
{
|
|
String result = s;
|
|
while (StringBeginsWith(result, pattern))
|
|
{
|
|
result.text += pattern.len;
|
|
result.len -= pattern.len;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
String TrimRight(String s, String pattern)
|
|
{
|
|
String result = s;
|
|
while (StringEndsWith(result, pattern))
|
|
{
|
|
result.len -= pattern.len;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
String Trim(String s, String pattern)
|
|
{
|
|
return TrimLeft(TrimRight(s, pattern), pattern);
|
|
}
|
|
|
|
String TrimWhitespace(String s)
|
|
{
|
|
b32 stop = 0;
|
|
while (!stop)
|
|
{
|
|
if (StringBeginsWith(s, Lit("\n")) || StringBeginsWith(s, Lit("\r")) || StringBeginsWith(s, Lit(" ")))
|
|
{
|
|
s.text += 1;
|
|
s.len -= 1;
|
|
}
|
|
else if (StringEndsWith(s, Lit("\n")) || StringEndsWith(s, Lit("\r")) || StringEndsWith(s, Lit(" ")))
|
|
{
|
|
s.len -= 1;
|
|
}
|
|
else
|
|
{
|
|
stop = 1;
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
//~ Formatting
|
|
|
|
//
|
|
// String formatting only has one format specifier: "%F". All specifier info is
|
|
// included in the arguments (instead of w/ the specifier like in printf).
|
|
//
|
|
// Example:
|
|
// FormatString(arena, Lit("Hello there %F"), FmtString(Lit("George")))
|
|
//
|
|
// NOTE: FmtEnd must be passed as the last arg in the va_list
|
|
//
|
|
// Format arguments:
|
|
// FmtChar: Format a single u8 character
|
|
// FmtString: Format a `string` struct
|
|
// FmtUint: Format a u64
|
|
// FmtSint: Format an i64
|
|
// FmtFloat: Format an f64 with DefaultFmtPrecision
|
|
// FmtHex: Format a u64 in hexadecimal notation
|
|
// FmtPtr: Format a pointer in hexadecimal notation prefixed by "0x"
|
|
//
|
|
// FmtEnd (internal): Denote the end of the va_list
|
|
//
|
|
|
|
String FormatString(Arena *arena, String fmt, FmtArgArray args)
|
|
{
|
|
String result = Zi;
|
|
result.text = ArenaNext(arena, u8);
|
|
|
|
u8 *end = fmt.text + fmt.len;
|
|
b32 no_more_valid_args = 0;
|
|
u64 arg_idx = 0;
|
|
for (u8 *c = fmt.text; c < end; ++c)
|
|
{
|
|
u8 *next = ((c + 1) < end) ? (c + 1) : (u8 *)"\0";
|
|
|
|
// Escape '%%'
|
|
b32 escape = !no_more_valid_args && *c == '%' && *next == '%';
|
|
if (escape)
|
|
{
|
|
// Skip the escaped '%' char from parsing
|
|
++c;
|
|
}
|
|
|
|
if (!no_more_valid_args && !escape && *c == '%' && *next == 'F')
|
|
{
|
|
String parsed_arg = Zi;
|
|
|
|
FmtArg arg = Zi;
|
|
if (arg_idx < args.count)
|
|
{
|
|
arg = args.args[arg_idx];
|
|
++arg_idx;
|
|
}
|
|
else
|
|
{
|
|
no_more_valid_args = 1;
|
|
}
|
|
|
|
switch (arg.kind)
|
|
{
|
|
default:
|
|
{
|
|
// Unknown format type
|
|
Assert(0);
|
|
parsed_arg = PushString(arena, Lit("<?>"));
|
|
no_more_valid_args = 1;
|
|
} break;
|
|
|
|
case FmtArgKind_Char:
|
|
{
|
|
parsed_arg = StringFromChar(arena, arg.value.c);
|
|
} break;
|
|
|
|
case FmtArgKind_String:
|
|
{
|
|
parsed_arg = PushString(arena, arg.value.string);
|
|
} break;
|
|
|
|
case FmtArgKind_Uint:
|
|
{
|
|
parsed_arg = StringFromUint(arena, arg.value.uints.x, 10, arg.z);
|
|
} break;
|
|
|
|
case FmtArgKind_Uint2:
|
|
{
|
|
parsed_arg = StringFromUints(arena, 2, &arg.value.uints.x, 10, arg.z);
|
|
} break;
|
|
|
|
case FmtArgKind_Uint3:
|
|
{
|
|
parsed_arg = StringFromUints(arena, 3, &arg.value.uints.x, 10, arg.z);
|
|
} break;
|
|
|
|
case FmtArgKind_Uint4:
|
|
{
|
|
parsed_arg = StringFromUints(arena, 4, &arg.value.uints.x, 10, arg.z);
|
|
} break;
|
|
|
|
case FmtArgKind_Sint:
|
|
{
|
|
parsed_arg = StringFromSint(arena, arg.value.sints.x, 10, arg.z);
|
|
} break;
|
|
|
|
case FmtArgKind_Sint2:
|
|
{
|
|
parsed_arg = StringFromSints(arena, 2, &arg.value.sints.x, 10, arg.z);
|
|
} break;
|
|
|
|
case FmtArgKind_Sint3:
|
|
{
|
|
parsed_arg = StringFromSints(arena, 3, &arg.value.sints.x, 10, arg.z);
|
|
} break;
|
|
|
|
case FmtArgKind_Sint4:
|
|
{
|
|
parsed_arg = StringFromSints(arena, 4, &arg.value.sints.x, 10, arg.z);
|
|
} break;
|
|
|
|
case FmtArgKind_Float:
|
|
{
|
|
parsed_arg = StringFromFloat(arena, arg.value.floats.x, arg.p);
|
|
} break;
|
|
|
|
case FmtArgKind_Float2:
|
|
{
|
|
parsed_arg = StringFromFloats(arena, 2, &arg.value.floats.x, arg.p);
|
|
} break;
|
|
|
|
case FmtArgKind_Float3:
|
|
{
|
|
parsed_arg = StringFromFloats(arena, 3, &arg.value.floats.x, arg.p);
|
|
} break;
|
|
|
|
case FmtArgKind_Float4:
|
|
{
|
|
parsed_arg = StringFromFloats(arena, 4, &arg.value.floats.x, arg.p);
|
|
} break;
|
|
|
|
case FmtArgKind_Hex:
|
|
{
|
|
parsed_arg = StringFromUint(arena, arg.value.uints.x, 16, arg.z);
|
|
} break;
|
|
|
|
case FmtArgKind_Ptr:
|
|
{
|
|
parsed_arg = StringFromPtr(arena, arg.value.ptr);
|
|
} break;
|
|
|
|
case FmtArgKind_Handle:
|
|
{
|
|
parsed_arg = StringFromhandle(arena, arg.value.handle.h64[0], arg.value.handle.h64[1]);
|
|
} break;
|
|
|
|
case FmtArgKind_Uid:
|
|
{
|
|
parsed_arg = StringFromUid(arena, arg.value.uid);
|
|
} break;
|
|
|
|
case FmtArgKind_End:
|
|
{
|
|
// Unexpected end. Not enough FMT args passed to function.
|
|
Assert(0);
|
|
parsed_arg = PushString(arena, Lit("<?>"));
|
|
no_more_valid_args = 1;
|
|
} break;
|
|
}
|
|
|
|
// Update final string len / start
|
|
result.len += parsed_arg.len;
|
|
|
|
// Skip 'F' from parsing
|
|
++c;
|
|
}
|
|
else
|
|
{
|
|
// Parse character normally
|
|
StringFromChar(arena, *c);
|
|
++result.len;
|
|
}
|
|
}
|
|
|
|
if (IsRtcEnabled)
|
|
{
|
|
if (!no_more_valid_args)
|
|
{
|
|
FmtArg last_arg = Zi;
|
|
if (arg_idx < args.count)
|
|
{
|
|
last_arg = args.args[arg_idx];
|
|
// End arg not reached. Too many args supplied.
|
|
Assert(last_arg.kind == FmtArgKind_End);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
String StringF_(Arena *arena, String fmt, ...)
|
|
{
|
|
String result = Zi;
|
|
TempArena scratch = BeginScratch(arena);
|
|
{
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
result = FormatString(arena, fmt, FmtArgsFromVaList(scratch.arena, args));
|
|
va_end(args);
|
|
}
|
|
EndScratch(scratch);
|
|
return result;
|
|
}
|
|
|
|
FmtArgArray FmtArgsFromVaList(Arena *arena, va_list args)
|
|
{
|
|
FmtArgArray result = Zi;
|
|
result.args = ArenaNext(arena, FmtArg);
|
|
{
|
|
b32 done = 0;
|
|
while (!done)
|
|
{
|
|
FmtArg arg = va_arg(args, FmtArg);
|
|
*PushStructNoZero(arena, FmtArg) = arg;
|
|
++result.count;
|
|
switch (arg.kind)
|
|
{
|
|
default:
|
|
{
|
|
// End/Invalid arg reached
|
|
done = 1;
|
|
} break;
|
|
|
|
case FmtArgKind_Char:
|
|
case FmtArgKind_String:
|
|
case FmtArgKind_Uint:
|
|
case FmtArgKind_Uint2:
|
|
case FmtArgKind_Uint3:
|
|
case FmtArgKind_Uint4:
|
|
case FmtArgKind_Sint:
|
|
case FmtArgKind_Sint2:
|
|
case FmtArgKind_Sint3:
|
|
case FmtArgKind_Sint4:
|
|
case FmtArgKind_Float:
|
|
case FmtArgKind_Float2:
|
|
case FmtArgKind_Float3:
|
|
case FmtArgKind_Float4:
|
|
case FmtArgKind_Hex:
|
|
case FmtArgKind_Ptr:
|
|
case FmtArgKind_Uid:
|
|
case FmtArgKind_Handle:
|
|
{
|
|
// Continue
|
|
} break;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
//~ Unicode
|
|
|
|
CodepointIter InitCodepointIter(String str)
|
|
{
|
|
return (CodepointIter)
|
|
{
|
|
.src = str
|
|
};
|
|
}
|
|
|
|
// Returns 0 if done iterating
|
|
b32 NextCodepoint(CodepointIter *iter)
|
|
{
|
|
if (iter->pos < iter->src.len)
|
|
{
|
|
String str_remaining = { .len = (iter->src.len - iter->pos), .text = iter->src.text + iter->pos };
|
|
Utf8DecodeResult decoded = DecodeUtf8(str_remaining);
|
|
iter->pos += decoded.advance8;
|
|
iter->codepoint = decoded.codepoint;
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// utf8 <- utf16
|
|
String StringFromString16(Arena *arena, String16 str16)
|
|
{
|
|
String result = {
|
|
.len = 0,
|
|
.text = ArenaNext(arena, u8)
|
|
};
|
|
|
|
u64 pos16 = 0;
|
|
while (pos16 < str16.len)
|
|
{
|
|
String16 str16_remaining = { .len = (str16.len - pos16), .text = str16.text + pos16 };
|
|
Utf16DecodeResult decoded = DecodeUtf16(str16_remaining);
|
|
Utf8EncodeResult encoded = EncodeUtf8(decoded.codepoint);
|
|
|
|
u8 *dst = PushStructsNoZero(arena, u8, encoded.count8);
|
|
CopyBytes(dst, encoded.chars8, encoded.count8);
|
|
|
|
pos16 += decoded.advance16;
|
|
result.len += encoded.count8;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// utf8 <- utf32
|
|
String StringFromString32(Arena *arena, String32 str32)
|
|
{
|
|
String result = {
|
|
.len = 0,
|
|
.text = ArenaNext(arena, u8)
|
|
};
|
|
|
|
u64 pos32 = 0;
|
|
while (pos32 < str32.len)
|
|
{
|
|
String32 str32_remaining = { .len = (str32.len - pos32), .text = str32.text + pos32 };
|
|
Utf32DecodeResult decoded = DecodeUtf32(str32_remaining);
|
|
Utf8EncodeResult encoded = EncodeUtf8(decoded.codepoint);
|
|
|
|
u8 *dst = PushStructsNoZero(arena, u8, encoded.count8);
|
|
CopyBytes(dst, &encoded.chars8, encoded.count8);
|
|
|
|
pos32 += 1;
|
|
result.len += encoded.count8;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// utf16 <- utf8
|
|
String16 String16FromString(Arena *arena, String str8)
|
|
{
|
|
String16 result = {
|
|
.len = 0,
|
|
.text = ArenaNext(arena, u16)
|
|
};
|
|
|
|
u64 pos8 = 0;
|
|
while (pos8 < str8.len)
|
|
{
|
|
String str8_remaining = { .len = (str8.len - pos8), .text = str8.text + pos8 };
|
|
Utf8DecodeResult decoded = DecodeUtf8(str8_remaining);
|
|
Utf16EncodeResult encoded = EncodeUtf16(decoded.codepoint);
|
|
|
|
u16 *dst = PushStructsNoZero(arena, u16, encoded.count16);
|
|
CopyBytes(dst, encoded.chars16, (encoded.count16 << 1));
|
|
|
|
pos8 += decoded.advance8;
|
|
result.len += encoded.count16;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// utf32 <- utf8
|
|
String32 String32FromString(Arena *arena, String str8)
|
|
{
|
|
String32 result = {
|
|
.len = 0,
|
|
.text = ArenaNext(arena, u32)
|
|
};
|
|
|
|
u64 pos8 = 0;
|
|
while (pos8 < str8.len)
|
|
{
|
|
String str8_remaining = { .len = (str8.len - pos8), .text = str8.text + pos8 };
|
|
Utf8DecodeResult decoded = DecodeUtf8(str8_remaining);
|
|
Utf32EncodeResult encoded = EncodeUtf32(decoded.codepoint);
|
|
|
|
u32 *dst = PushStructNoZero(arena, u32);
|
|
*dst = encoded.chars32;
|
|
|
|
pos8 += decoded.advance8;
|
|
result.len += 1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
//~ Null-terminated strings
|
|
|
|
u64 CstrLenNoLimit(char *cstr)
|
|
{
|
|
char *end = cstr;
|
|
if (cstr)
|
|
{
|
|
while (*end)
|
|
{
|
|
++end;
|
|
}
|
|
}
|
|
return end - cstr;
|
|
}
|
|
|
|
u64 CstrLen(char *cstr, u64 limit)
|
|
{
|
|
char *end = cstr;
|
|
if (cstr)
|
|
{
|
|
for (u64 i = 0; i < limit; ++i)
|
|
{
|
|
if (*end)
|
|
{
|
|
++end;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return end - cstr;
|
|
}
|
|
|
|
char *CstrFromString(Arena *arena, String src)
|
|
{
|
|
u8 *text = PushStructsNoZero(arena, u8, src.len + 1);
|
|
CopyBytes(text, src.text, src.len);
|
|
text[src.len] = 0;
|
|
return (char *)text;
|
|
}
|
|
|
|
char *CstrFromStringToBuff(String dst_buff, String src)
|
|
{
|
|
if (dst_buff.len > 0)
|
|
{
|
|
u64 len = MinU64(src.len, dst_buff.len - 1);
|
|
CopyBytes(dst_buff.text, src.text, len);
|
|
dst_buff.text[len] = 0;
|
|
}
|
|
return (char *)dst_buff.text;
|
|
}
|
|
|
|
String StringFromCstrNoLimit(char *cstr)
|
|
{
|
|
u64 len = CstrLenNoLimit(cstr);
|
|
return (String)
|
|
{
|
|
.len = len,
|
|
.text = (u8 *)cstr
|
|
};
|
|
}
|
|
|
|
String StringFromCstr(char *cstr, u64 limit)
|
|
{
|
|
u64 len = CstrLen(cstr, limit);
|
|
return (String)
|
|
{
|
|
.text = (u8 *)cstr,
|
|
.len = len
|
|
};
|
|
}
|
|
|
|
u64 WstrLenNoLimit(wchar_t *wstr)
|
|
{
|
|
wchar_t *end = wstr;
|
|
if (end)
|
|
{
|
|
while (*end)
|
|
{
|
|
++end;
|
|
}
|
|
}
|
|
return end - wstr;
|
|
}
|
|
|
|
u64 WstrLen(wchar_t *wstr, u64 limit)
|
|
{
|
|
wchar_t *end = wstr;
|
|
if (wstr)
|
|
{
|
|
for (u64 i = 0; i < limit; ++i)
|
|
{
|
|
if (*end)
|
|
{
|
|
++end;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return end - wstr;
|
|
}
|
|
|
|
wchar_t *WstrFromString(Arena *arena, String src)
|
|
{
|
|
String16 str16 = String16FromString(arena, src);
|
|
*PushStructNoZero(arena, u16) = 0;
|
|
return (wchar_t *)str16.text;
|
|
}
|
|
|
|
wchar_t *WstrFromString16(Arena *arena, String16 src)
|
|
{
|
|
u16 *text = PushStructsNoZero(arena, u16, src.len + 1);
|
|
text[src.len] = 0;
|
|
return (wchar_t *)text;
|
|
}
|
|
|
|
String StringFromWstrNoLimit(Arena *arena, wchar_t *wstr)
|
|
{
|
|
String16 str16 = String16FromWstrNoLimit(wstr);
|
|
return StringFromString16(arena, str16);
|
|
}
|
|
|
|
String StringFromWstr(Arena *arena, wchar_t *wstr, u64 limit)
|
|
{
|
|
String16 str16 = String16FromWstr(wstr, limit);
|
|
return StringFromString16(arena, str16);
|
|
}
|
|
|
|
String16 String16FromWstrNoLimit(wchar_t *wstr)
|
|
{
|
|
u64 len = WstrLenNoLimit(wstr);
|
|
return (String16)
|
|
{
|
|
.len = len,
|
|
.text = (u16 *)wstr
|
|
};
|
|
}
|
|
|
|
String16 String16FromWstr(wchar_t *wstr, u64 limit)
|
|
{
|
|
u64 len = WstrLen(wstr, limit);
|
|
return (String16)
|
|
{
|
|
.len = len,
|
|
.text = (u16 *)wstr
|
|
};
|
|
}
|