Add a custom logging dsl

2 files changed, 268 insertions, 27 deletions

diff --git a/src/badlib.h b/src/badlib.h
index 8ce4634..bc3312f 100644
--- a/src/badlib.h
+++ b/src/badlib.h
@@ -11,6 +11,9 @@
 // - 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).
 //
 
 #include <stdbool.h>
@@ -453,6 +456,59 @@ str_insert(Str orig, Str value, sz position, Arena *a) {
 //     };
 // }
 
+char
+str_next(Str *s) {
+    assert(s->mem);
+    if (s->size == 0) {
+        return EOF;
+    }
+    char c = *s->mem++;
+    s->size--;
+    return c;
+}
+
+char
+str_peek(Str s) {
+    assert(s.mem);
+    return *s.mem;
+}
+
+sz
+str_to_int(Str s) {
+    sz num = 0;
+    if (str_has_prefix(s, cstr("0b"))) {
+        // Binary number.
+        s = str_remove_prefix(s, cstr("0b"));
+        while (s.size) {
+            char c = str_next(&s);
+            assert(c == '0' || c == '1');
+            num = num * 2 + (c - '0');
+        }
+    } else if (str_has_prefix(s, cstr("0x"))) {
+        // Hex number.
+        s = str_remove_prefix(s, cstr("0x"));
+        while (s.size) {
+            char c = str_next(&s);
+            assert((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'));
+            if (c >= '0' && c <= '9') {
+                num = num * 16 + (c - '0');
+            } else if (c >= 'a' && c <= 'f') {
+                num = num * 16 + (c - 'a' + 10);
+            } else if (c >= 'A' && c <= 'F') {
+                num = num * 16 + (c - 'A' + 10);
+            }
+        }
+    } else {
+        // Decimal number.
+        while (s.size) {
+            char c = str_next(&s);
+            assert(c >= '0' && c <= '9');
+            num = num * 10 + (c - '0');
+        }
+    }
+    return num;
+}
+
 //
 // Queue.
 //
@@ -901,6 +957,7 @@ void
 log_flush(Logger *l) {
     if (l->buf.size) {
         fprintf(l->dest, "%.*s", (int)l->buf.size, l->buf.mem);
+        l->buf.size = 0;
     }
 }
 
@@ -931,6 +988,7 @@ void
 log_byte(Logger *l, u8 b) {
     assert(l);
     Buf *buf = &l->buf;
+    if (buf->size == 0) log_init(l);
     sz avail = buf->cap - buf->size;
     if (avail == 0) {
         log_flush(l);
@@ -1051,4 +1109,183 @@ log_float(Logger *l, f64 num, sz precision) {
     log_int(l, fractional);
 }
 
+#include <stdarg.h>
+
+typedef struct Vec2 {
+    sz x, y;
+} Vec2;
+
+typedef void(LogFunc)(Logger *l, void *in);
+
+void
+log_vec2(Logger *l, void *v) {
+    assert(l);
+    Vec2 *vec = v;
+    log_str(l, cstr("Vec2 { x: "));
+    log_int(l, vec->x);
+    log_str(l, cstr(", y: "));
+    log_int(l, vec->y);
+    log_str(l, cstr(" }"));
+}
+
+void
+log_func_arena(Logger *l, void *in) {
+    assert(l);
+    Arena *val = in;
+    log_str(l, cstr("Arena{ size: "));
+    log_int(l, val->size);
+    log_str(l, cstr(" cap: "));
+    log_int(l, val->cap);
+    log_str(l, cstr(" mem: "));
+    log_hex(l, (ptrsize)val->beg, 16);
+    log_str(l, cstr(" }"));
+}
+
+void
+log_func_buf(Logger *l, void *in) {
+    assert(l);
+    Buf *val = in;
+    log_str(l, cstr("Buf{ size: "));
+    log_int(l, val->size);
+    log_str(l, cstr(" cap: "));
+    log_int(l, val->cap);
+    log_str(l, cstr(" mem: "));
+    log_hex(l, (ptrsize)val->mem, 16);
+    log_str(l, cstr(" }"));
+}
+
+void
+log_func_array(Logger *l, void *in) {
+    assert(l);
+    Array *val = in;
+    log_str(l, cstr("Buf{ size: "));
+    log_int(l, val->size);
+    log_str(l, cstr(" mem: "));
+    log_hex(l, (ptrsize)val->mem, 16);
+    log_str(l, cstr(" }"));
+}
+
+typedef struct LogFuncMap {
+    Str name;
+    LogFunc *func;
+} LogFuncMap;
+
+LogFuncMap log_funcs[] = {
+    {cstr("Arena"), log_func_arena},
+    {cstr("Buf"), log_func_buf},
+    {cstr("Array"), log_func_array},
+};
+
+void
+log_print(Logger *l, Str format, ...) {
+    va_list argp;
+    va_start(argp, format);
+    va_start(argp, format);
+    while (format.size) {
+        char c = str_next(&format);
+        if (c == '%') {
+            c = str_next(&format);
+            switch (c) {
+                case '%': {
+                    log_byte(l, '%');
+                } break;
+                case 'd': {
+                    // Integer decimal formatting.
+                    sz num = va_arg(argp, sz);
+                    log_int(l, num);
+                } break;
+                case 'x': {
+                    // Hex number formatting.
+                    sz num = va_arg(argp, sz);
+                    char n = str_peek(format);
+                    sz zeroes = 0;
+                    if (n == '{') {
+                        str_next(&format);
+                        SearchResult res = array_find_next(format, cstr("}"));
+                        if (res.found) {
+                            Str arg = format;
+                            arg.size = res.pos;
+                            sz inc = res.pos + res.matched;
+                            format.mem += inc;
+                            format.size -= inc;
+                            zeroes = str_to_int(arg);
+                        } else {
+                            break;
+                        }
+                    }
+                    log_hex(l, num, zeroes);
+                } break;
+                case 'b': {
+                    // Binary number formatting.
+                    sz num = va_arg(argp, sz);
+                    char n = str_peek(format);
+                    sz zeroes = 0;
+                    if (n == '{') {
+                        str_next(&format);
+                        SearchResult res = array_find_next(format, cstr("}"));
+                        if (res.found) {
+                            Str arg = format;
+                            arg.size = res.pos;
+                            sz inc = res.pos + res.matched;
+                            format.mem += inc;
+                            format.size -= inc;
+                            zeroes = str_to_int(arg);
+                        } else {
+                            break;
+                        }
+                    }
+                    log_bin(l, num, zeroes);
+                } break;
+                case 'f': {
+                    // Floating point formatting.
+                    f64 num = va_arg(argp, f64);
+                    char n = str_peek(format);
+                    sz precision = 4;
+                    if (n == '{') {
+                        str_next(&format);
+                        SearchResult res = array_find_next(format, cstr("}"));
+                        if (res.found) {
+                            Str arg = format;
+                            arg.size = res.pos;
+                            sz inc = res.pos + res.matched;
+                            format.mem += inc;
+                            format.size -= inc;
+                            precision = str_to_int(arg);
+                        } else {
+                            break;
+                        }
+                    }
+                    log_float(l, num, precision);
+                } break;
+                case 's': {
+                    // String formatting.
+                    Str val = va_arg(argp, Str);
+                    log_str(l, val);
+                } break;
+                case '{': {
+                    SearchResult res = array_find_next(format, cstr("}"));
+                    if (res.found) {
+                        Str arg = format;
+                        arg.size = res.pos;
+                        sz inc = res.pos + res.matched;
+                        format.mem += inc;
+                        format.size -= inc;
+                        void *val = va_arg(argp, void *);
+                        for (sz i = 0; i < LEN(log_funcs); i++) {
+                            if (str_eq(arg, log_funcs[i].name)) {
+                                log_funcs[i].func(l, val);
+                                break;
+                            }
+                        }
+                    }
+                } break;
+            }
+            continue;
+        }
+        log_byte(l, c);
+    }
+    log_flush(l);
+    va_end(argp);
+}
+
 #endif  // BADLIB_H
diff --git a/src/main.c b/src/main.c
index b6a0da4..f5f2065 100644
--- a/src/main.c
+++ b/src/main.c
@@ -49,33 +49,37 @@ process_file(Str path) {
         .dest = stdout,
         .storage = &logger_arena,
     };
-    log_str(&logger_info, cstr("<<< "));
-    log_int(&logger_info, -1234);
-    log_str(&logger_info, cstr(" | "));
-    log_hex(&logger_info, (sz)&logger_info, 16);
-    log_str(&logger_info, cstr(" | "));
-    log_hex(&logger_info, 15, 8);
-    log_str(&logger_info, cstr(" | "));
-    log_hex(&logger_info, 16, 8);
-    log_str(&logger_info, cstr(" | "));
-    log_bin(&logger_info, 15, 8);
-    log_str(&logger_info, cstr(" | "));
-    log_bin(&logger_info, 16, 8);
-    log_str(&logger_info, cstr(" | "));
-    log_float(&logger_info, 3.1234, 0);
-    log_str(&logger_info, cstr(" | "));
-    log_float(&logger_info, 3.14, 4);
-    log_str(&logger_info, cstr(" | "));
-    log_float(&logger_info, -0.01415, 8);
-    log_str(&logger_info, cstr(" | "));
-    log_float(&logger_info, (f64)0x7ff0000000000000L, 0);
-    log_str(&logger_info, cstr(" | "));
-    log_float(&logger_info, (f64)0xfff0000000000000L, 0);
-    log_str(&logger_info, cstr(" | "));
-    log_float(&logger_info, (f64)0x7ff8000000000000L, 0);
-    log_str(&logger_info, cstr(" >>>"));
-    log_str(&logger_info, cstr("\n"));
-    log_flush(&logger_info);
+    log_print(&logger_info, cstr("<<< %x{4} %b{4} %f{2} %s %{Vec2} %{Vec2} %{Arena} >>>\n"), 
+              123, 3, 1.345, cstr("BOOM!"), &(Vec2){100, 255}, &(Vec2){10, 15}, &logger_arena);
+    // log_print(&logger_info, cstr("<<< %x{4} >>>\n"), 
+    //           123);
+    // log_str(&logger_info, cstr("<<< "));
+    // log_int(&logger_info, -1234);
+    // log_str(&logger_info, cstr(" | "));
+    // log_hex(&logger_info, (sz)&logger_info, 16);
+    // log_str(&logger_info, cstr(" | "));
+    // log_hex(&logger_info, 15, 8);
+    // log_str(&logger_info, cstr(" | "));
+    // log_hex(&logger_info, 16, 8);
+    // log_str(&logger_info, cstr(" | "));
+    // log_bin(&logger_info, 15, 8);
+    // log_str(&logger_info, cstr(" | "));
+    // log_bin(&logger_info, 16, 8);
+    // log_str(&logger_info, cstr(" | "));
+    // log_float(&logger_info, 3.1234, 0);
+    // log_str(&logger_info, cstr(" | "));
+    // log_float(&logger_info, 3.14, 4);
+    // log_str(&logger_info, cstr(" | "));
+    // log_float(&logger_info, -0.01415, 8);
+    // log_str(&logger_info, cstr(" | "));
+    // log_float(&logger_info, (f64)0x7ff0000000000000L, 0);
+    // log_str(&logger_info, cstr(" | "));
+    // log_float(&logger_info, (f64)0xfff0000000000000L, 0);
+    // log_str(&logger_info, cstr(" | "));
+    // log_float(&logger_info, (f64)0x7ff8000000000000L, 0);
+    // log_str(&logger_info, cstr(" >>>"));
+    // log_str(&logger_info, cstr("\n"));
+    // log_flush(&logger_info);
 
     // Logger logger_err = {
     //     .dest = stderr,