Streamline the creation of default loggers and custom log_fn

2 files changed, 117 insertions, 137 deletions

diff --git a/src/badlib.h b/src/badlib.h
index bc3312f..837d377 100644
--- a/src/badlib.h
+++ b/src/badlib.h
@@ -921,6 +921,13 @@ platform_free(void *ptr, void *ctx) {
     free(ptr);
 }
 
+Allocator os_allocator = {
+    .malloc = platform_malloc,
+    .calloc = platform_calloc,
+    .realloc = platform_realloc,
+    .free = platform_free,
+};
+
 #include <time.h>
 #include <unistd.h>
 
@@ -940,20 +947,23 @@ platform_time(void) {
 // Custom logger.
 //
 
-#define LOG_BUF_SIZE KB(4)
+// Our custom logging functions for structs and other entities.
+typedef struct Logger Logger;
+typedef void(LogFunc)(Logger *l, void *in);
+
+typedef struct LogFuncMap {
+    Str name;
+    LogFunc *func;
+} LogFuncMap;
 
 typedef struct Logger {
     Buf buf;
     FILE *dest;
-    Arena *storage;
+    LogFuncMap *func_map;
+    Arena storage;
 } Logger;
 
 void
-log_init(Logger *l) {
-    buf_reserve(&l->buf, LOG_BUF_SIZE, l->storage);
-}
-
-void
 log_flush(Logger *l) {
     if (l->buf.size) {
         fprintf(l->dest, "%.*s", (int)l->buf.size, l->buf.mem);
@@ -965,7 +975,7 @@ void
 log_str(Logger *l, Str str) {
     assert(l);
     Buf *buf = &l->buf;
-    if (buf->size == 0) log_init(l);
+    assert(buf->mem);
     while (str.size > 0) {
         sz avail = buf->cap - buf->size;
         if (avail == 0) {
@@ -974,11 +984,11 @@ log_str(Logger *l, Str str) {
             assert(avail > 0);
         }
         if (str.size < avail) {
-            buf_insert(&l->buf, str.mem, str.size, l->storage);
+            buf_insert(&l->buf, str.mem, str.size, &l->storage);
             str.size = 0;
             return;
         }
-        buf_insert(&l->buf, str.mem, avail, l->storage);
+        buf_insert(&l->buf, str.mem, avail, &l->storage);
         str.mem += avail;
         str.size -= avail;
     }
@@ -988,14 +998,14 @@ void
 log_byte(Logger *l, u8 b) {
     assert(l);
     Buf *buf = &l->buf;
-    if (buf->size == 0) log_init(l);
+    assert(buf->mem);
     sz avail = buf->cap - buf->size;
     if (avail == 0) {
         log_flush(l);
         avail = buf->cap - buf->size;
         assert(avail > 0);
     }
-    buf_insert(&l->buf, &b, 1, l->storage);
+    buf_insert(&l->buf, &b, 1, &l->storage);
 }
 
 void
@@ -1111,73 +1121,10 @@ log_float(Logger *l, f64 num, sz precision) {
 
 #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, ...) {
+    assert(l);
+    assert(l->buf.mem);
     va_list argp;
     va_start(argp, format);
     va_start(argp, format);
@@ -1271,9 +1218,9 @@ log_print(Logger *l, Str format, ...) {
                         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);
+                        for (sz i = 0; i < array_size(l->func_map); i++) {
+                            if (str_eq(arg, l->func_map[i].name)) {
+                                l->func_map[i].func(l, val);
                                 break;
                             }
                         }
@@ -1288,4 +1235,90 @@ log_print(Logger *l, Str format, ...) {
     va_end(argp);
 }
 
+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(" }"));
+}
+
+#define LOG_BUF_SIZE KB(1)
+#define LOG_MEM_SIZE KB(2)
+
+Logger
+log_init(sz memsize, FILE *dest, Arena arena) {
+    Logger logger = {
+        .dest = dest,
+        .storage = arena,
+    };
+    buf_reserve(&logger.buf, memsize, &logger.storage);
+    return logger;
+}
+
+// Default loggers and convenience macros for printing.
+Logger logger_inf, logger_err;
+#define print(format, ...) \
+    log_print(&logger_inf, (Str){(u8 *)(format), LEN(format) - 1}, __VA_ARGS__)
+#define println(format, ...) print(format "\n", __VA_ARGS__)
+#define printerr(format, ...) \
+    log_print(&logger_err, (Str){(u8 *)(format), LEN(format) - 1}, __VA_ARGS__)
+#define printerrln(format, ...) printerr(format "\n", __VA_ARGS__)
+
+void
+log_func_register(Logger *l, LogFuncMap map) {
+    array_push(l->func_map, map, &l->storage);
+}
+
+void
+log_init_default(void) {
+    // Allocate and initialize loggers.
+    Arena arena_inf = arena_create(LOG_MEM_SIZE, os_allocator);
+    Arena arena_err = arena_create(LOG_MEM_SIZE, os_allocator);
+    logger_inf = log_init(LOG_BUF_SIZE, stdout, arena_inf);
+    logger_err = log_init(LOG_BUF_SIZE, stderr, arena_err);
+
+    // Register default log_funcs into loggers.
+    array_init(logger_inf.func_map, 16, &logger_inf.storage);
+    array_init(logger_err.func_map, 16, &logger_err.storage);
+    LogFuncMap log_funcs[] = {
+        {cstr("Arena"), log_func_arena},
+        {cstr("Buf"), log_func_buf},
+        {cstr("Array"), log_func_array},
+    };
+    for (sz i = 0; i < LEN(log_funcs); i++) {
+        log_func_register(&logger_inf, log_funcs[i]);
+        log_func_register(&logger_err, log_funcs[i]);
+    }
+}
+
 #endif  // BADLIB_H
diff --git a/src/main.c b/src/main.c
index f5f2065..82d7e8b 100644
--- a/src/main.c
+++ b/src/main.c
@@ -15,18 +15,11 @@ typedef enum ExecMode {
 static ExecMode mode = RUN_NORMAL;
 
 #define LEXER_MEM GB(2)
-#define LOGGER_MEM MB(1)
 
 void
 process_file(Str path) {
     printf("processing: ");
     printstrln(&path);
-    Allocator os_allocator = {
-        .malloc = platform_malloc,
-        .calloc = platform_calloc,
-        .realloc = platform_realloc,
-        .free = platform_free,
-    };
     printf("initialing memory...\n");
     Arena lexer_arena = arena_create(LEXER_MEM, os_allocator);
     printf("reading file...\n");
@@ -43,56 +36,10 @@ process_file(Str path) {
     //     printstrln(&line);
     // }
 
-    // Testing custom logger functions.
-    Arena logger_arena = arena_create(LOGGER_MEM, os_allocator);
-    Logger logger_info = {
-        .dest = stdout,
-        .storage = &logger_arena,
-    };
-    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,
-    //     .storage = &logger_arena,
-    // };
-    // log_str(&logger_err, path);
-    // log_str(&logger_err, cstr(":1:1:"));
-    // log_str(&logger_err, cstr("error: testing string logger\n"));
-    // log_flush(&logger_err);
-
-    // TODO: add numeric logging
-    // TODO: add custom struct logging
-    // TODO: add a vaargs function with a little dsl
+    log_init_default();
+    println("<<< %x{4} %b{4} %f{2} %s %{Arena} >>>", 123, 3, 1.345,
+            cstr("BOOM!"), &logger_inf.storage);
+    printerrln("%s:%d:%d: %s", path, 1, 1, cstr("error: testing string logger"));
 
     // TODO: run lexer.
 }