Extract str_from_* functions from the logger

1 files changed, 120 insertions, 92 deletions

diff --git a/src/badlib.h b/src/badlib.h
index 496f106..6207ecf 100644
--- a/src/badlib.h
+++ b/src/badlib.h
@@ -4,6 +4,7 @@
 // TODO:
 // - Add string operations.
 //     - sub
+//     - delete
 // - Add math operations for vectors and matrices.
 // - Can we remove the PlatformAPI function pointers and just use extern
 //   references?
@@ -11,7 +12,6 @@
 // - Sort arrays / linked lists with custom functions?
 // - Implement binary search for searching into an array:
 //       SearchResult find_array(Array haystack, Array needle).
-// - Move logger functions to str_from_int, str_from_float etc.
 // - Logger functions for hash map, arrays and growable arrays (print the entire
 //   thing or at least a small range).
 //
@@ -450,6 +450,116 @@ str_insert(Str orig, Str value, sz position, Arena *a) {
 //     };
 // }
 
+Str
+str_from_int(sz num, Arena *a) {
+    u8 tmp[64];
+    u8 *end = tmp + sizeof(tmp);
+    u8 *beg = end;
+    sz t = num > 0 ? num : -num;
+    do {
+        *--beg = '0' + t % 10;
+    } while (t /= 10);
+    if (num < 0) {
+        *--beg = '-';
+    }
+    sz num_size = end - beg;
+    Str parsed = {
+        .mem = arena_malloc(num_size, a),
+        .size = num_size,
+    };
+    memcpy(parsed.mem, beg, num_size);
+    return parsed;
+}
+
+Str
+str_from_hex(sz num, sz zeroes, Arena *a) {
+    char char_map[] = "0123456789abcdef";
+    u8 tmp[64];
+    zeroes = MIN((sz)sizeof(ptrsize) * 2, zeroes);
+    u8 *end = tmp + sizeof(tmp);
+    u8 *beg = end;
+    sz t = num > 0 ? num : -num;
+    do {
+        *--beg = char_map[t % 16];
+    } while (t /= 16);
+    zeroes -= end - beg;
+    while (zeroes-- > 0) {
+        *--beg = '0';
+    }
+    sz num_size = end - beg;
+    Str parsed = {
+        .mem = arena_malloc(num_size, a),
+        .size = num_size,
+    };
+    memcpy(parsed.mem, beg, num_size);
+    return parsed;
+}
+
+Str
+str_from_bin(sz num, sz zeroes, Arena *a) {
+    char char_map[] = "01";
+    u8 tmp[64];
+    zeroes = MIN((sz)sizeof(ptrsize) * 2, zeroes);
+    u8 *end = tmp + sizeof(tmp);
+    u8 *beg = end;
+    sz t = num > 0 ? num : -num;
+    do {
+        *--beg = char_map[t % 2];
+    } while (t /= 2);
+    zeroes -= end - beg;
+    while (zeroes-- > 0) {
+        *--beg = '0';
+    }
+    sz num_size = end - beg;
+    Str parsed = {
+        .mem = arena_malloc(num_size, a),
+        .size = num_size,
+    };
+    memcpy(parsed.mem, beg, num_size);
+    return parsed;
+}
+
+Str
+str_from_float(f64 num, sz precision, Arena *a) {
+    if (num == 0x7ff0000000000000L) {
+        return cstr("inf");
+    }
+    if (num == 0xfff0000000000000L) {
+        return cstr("-inf");
+    }
+    if (num == 0x7ff8000000000000L) {
+        return cstr("nan");
+    }
+    if (precision == 0) {
+        num += 0.5;
+        sz integral = num;
+        return str_from_int(integral, a);
+    }
+    Str parsed = {0};
+    sz prec = 1;
+    while (precision > 0) {
+        prec *= 10;
+        precision--;
+    }
+    if (num < 0) {
+        parsed = str_concat(parsed, cstr("-"), a);
+        num = -num;
+    }
+    num += 0.5 / prec;
+    sz integral = num;
+    sz fractional = (num - integral) * prec;
+
+    parsed = str_concat(parsed, str_from_int(integral, a), a);
+    parsed = str_concat(parsed, cstr("."), a);
+    for (sz i = prec / 10; i > 1; i /= 10) {
+        if (i > fractional) {
+            parsed = str_concat(parsed, cstr("0"), a);
+        }
+    }
+    parsed = str_concat(parsed, str_from_int(fractional, a), a);
+    return parsed;
+}
+
 char
 str_next(Str *s) {
     assert(s->mem);
@@ -1001,116 +1111,34 @@ log_byte(Logger *l, u8 b) {
     }
     buf_insert(&l->buf, &b, 1, &l->storage);
 }
-
 void
 log_int(Logger *l, sz num) {
     assert(l);
-    u8 tmp[64];
-    u8 *end = tmp + sizeof(tmp);
-    u8 *beg = end;
-    sz t = num > 0 ? num : -num;
-    do {
-        *--beg = '0' + t % 10;
-    } while (t /= 10);
-    if (num < 0) {
-        *--beg = '-';
-    }
-    Str parsed = {
-        .mem = beg,
-        .size = end - beg,
-    };
-    log_str(l, parsed);
+    Arena scratch = l->storage;
+    log_str(l, str_from_int(num, &scratch));
 }
 
 void
 log_hex(Logger *l, sz num, sz zeroes) {
     assert(l);
-    char char_map[] = "0123456789abcdef";
     log_str(l, cstr("0x"));
-    u8 tmp[64];
-    zeroes = MIN((sz)sizeof(ptrsize) * 2, zeroes);
-    u8 *end = tmp + sizeof(tmp);
-    u8 *beg = end;
-    sz t = num > 0 ? num : -num;
-    do {
-        *--beg = char_map[t % 16];
-    } while (t /= 16);
-    zeroes -= end - beg;
-    while (zeroes-- > 0) {
-        *--beg = '0';
-    }
-    Str parsed = {
-        .mem = beg,
-        .size = end - beg,
-    };
-    log_str(l, parsed);
+    Arena scratch = l->storage;
+    log_str(l, str_from_hex(num, zeroes, &scratch));
 }
 
 void
 log_bin(Logger *l, sz num, sz zeroes) {
     assert(l);
-    char char_map[] = "01";
     log_str(l, cstr("0b"));
-    u8 tmp[64];
-    zeroes = MIN((sz)sizeof(ptrsize) * 2, zeroes);
-    u8 *end = tmp + sizeof(tmp);
-    u8 *beg = end;
-    sz t = num > 0 ? num : -num;
-    do {
-        *--beg = char_map[t % 2];
-    } while (t /= 2);
-    zeroes -= end - beg;
-    while (zeroes-- > 0) {
-        *--beg = '0';
-    }
-    Str parsed = {
-        .mem = beg,
-        .size = end - beg,
-    };
-    log_str(l, parsed);
+    Arena scratch = l->storage;
+    log_str(l, str_from_bin(num, zeroes, &scratch));
 }
 
 void
 log_float(Logger *l, f64 num, sz precision) {
     assert(l);
-    if (num == 0x7ff0000000000000L) {
-        log_str(l, cstr("inf"));
-        return;
-    }
-    if (num == 0xfff0000000000000L) {
-        log_str(l, cstr("-inf"));
-        return;
-    }
-    if (num == 0x7ff8000000000000L) {
-        log_str(l, cstr("nan"));
-        return;
-    }
-    if (precision == 0) {
-        num += 0.5;
-        sz integral = num;
-        log_int(l, integral);
-        return;
-    }
-    sz prec = 1;
-    while (precision > 0) {
-        prec *= 10;
-        precision--;
-    }
-    if (num < 0) {
-        log_byte(l, '-');
-        num = -num;
-    }
-    num += 0.5 / prec;
-    sz integral = num;
-    sz fractional = (num - integral) * prec;
-    log_int(l, integral);
-    log_byte(l, '.');
-    for (sz i = prec / 10; i > 1; i /= 10) {
-        if (i > fractional) {
-            log_byte(l, '0');
-        }
-    }
-    log_int(l, fractional);
+    Arena scratch = l->storage;
+    log_str(l, str_from_float(num, precision, &scratch));
 }
 
 void
@@ -1257,7 +1285,7 @@ void
 log_func_array(Logger *l, void *in) {
     assert(l);
     Array *val = in;
-    log_str(l, cstr("Buf{ size: "));
+    log_str(l, cstr("Array{ size: "));
     log_int(l, val->size);
     log_str(l, cstr(" mem: "));
     log_hex(l, (ptrsize)val->mem, 16);