Pretty draw app_events, s8->string

src/app/app_wasm.c

@@ -37,11 +37,10 @@ f64 s8_deserial_f64(s8_t string) {
     return wasm_parse_float((isize)string.str, (i32)string.len);
 }
 
-void clip(r2f64_t rect) {
+void set_clip(r2f64_t rect) {
     wasm_set_clip(wasm_dpr * rect.min.x, wasm_dpr * rect.min.y, wasm_dpr * (rect.max.x - rect.min.x), wasm_dpr * (rect.max.y - rect.min.y));
 }
 
-
 f64 get_font_height(void) {
     return wasm_get_font_height((isize) font_face, font_face_len, 20*wasm_dpr) / wasm_dpr;
 }

src/core/lexer.c

@@ -81,7 +81,7 @@ struct lex_t {
 
     union {
         struct {char *str; i64 len;};
-        s8_t s8;
+        s8_t string;
     };
 
     i32 line;
@@ -371,7 +371,7 @@ void lex_token_ex(lexer_t *lex, lex_t *token) {
     if (token->kind == lex_kind_integer) {
         token->integer = lex_deserial_u64(token->str, token->len, 10);
     } else if (token->kind == lex_kind_real) {
-        token->real = s8_deserial_f64(token->s8);
+        token->real = s8_deserial_f64(token->string);
     } else if (token->kind == lex_kind_string) {
         token->str += 1;
         token->len -= 2;
@@ -469,7 +469,7 @@ lex_t *parser_match(parser_t *par, lex_kind_t kind) {
 }
 
 lex_t *parser_matchi(parser_t *par, s8_t str) {
-    if (par->at->kind == lex_kind_ident && s8_equal(par->at->s8, str)) {
+    if (par->at->kind == lex_kind_ident && s8_equal(par->at->string, str)) {
         return parser_next(par);
     } else {
         return NULL;

src/core/string8.c

@@ -311,7 +311,7 @@ s8_t s8_fmt(ma_arena_t *ma, const char *str, ...) {
 //
 sb8_node_t *sb8_node(ma_arena_t *ma, s8_t str) {
     sb8_node_t *node = ma_push_type(ma, sb8_node_t);
-    node->s = str;
+    node->string = str;
     return node;
 }
 

src/core/type_info.c

@@ -315,15 +315,15 @@ void s8_deserial_data_ex(ma_arena_t *arena, parser_t *par, void *p, type_t *type
     if (type == &type__s8_t) {
         lex_t *token = parser_expect(par, lex_kind_string);
         s8_t *n = (s8_t *)p;
-        n[0] = s8_copy(arena, token->s8);
+        n[0] = s8_copy(arena, token->string);
         return;
     }
 
     if (type->kind == type_kind_enum) {
         lex_t *token = parser_expect(par, lex_kind_ident);
-        i64 value = ti_enum_name_to_value(type, token->s8);
+        i64 value = ti_enum_name_to_value(type, token->string);
         if (value == -1) {
-            panicf("invalid enum value: %S", token->s8);
+            panicf("invalid enum value: %S", token->string);
         }
         if (type->size == 1) {
             *(i8 *)p = (i8)value;
@@ -348,12 +348,12 @@ void s8_deserial_data_ex(ma_arena_t *arena, parser_t *par, void *p, type_t *type
             lex_t *ident = parser_expect(par, lex_kind_ident);
             parser_expect(par, lex_kind_colon);
 
-            type_member_t *mem = ti_get_member(type, ident->s8);
+            type_member_t *mem = ti_get_member(type, ident->string);
             if (mem) {
                 u8 *mem_p = p8 + mem->offset;
                 s8_deserial_data_ex(arena, par, mem_p, mem->type);
             } else {
-                debugf("deserial - skipping field: %S", ident->s8);
+                debugf("deserial - skipping field: %S", ident->string);
                 parser_eat_until(par, lex_kind_comma);
             }
 
@@ -368,7 +368,7 @@ void s8_deserial_data_ex(ma_arena_t *arena, parser_t *par, void *p, type_t *type
 
             lex_t *ident = parser_expect(par, lex_kind_ident);
             parser_expect(par, lex_kind_colon);
-            assert(s8_equal(ident->s8, mem->name));
+            assert(s8_equal(ident->string, mem->name));
 
             s8_deserial_data_ex(arena, par, mem_p, mem->type);
             parser_expect(par, lex_kind_comma);

src/core/types.h

@@ -287,7 +287,7 @@ struct sb8_node_t {
     sb8_node_t *next;
     union {
         struct { char *str; int64_t len; };
-        s8_t s;
+        s8_t string;
     };
 };
 

src/meta/parser.c

@@ -72,12 +72,12 @@ ast_t *parse_lit_expr(parser_t *par) {
     if (token->kind == lex_kind_integer) {
         ast_t *result = create_ast(par, token, set_bit(ast_flag_integer) | set_bit(ast_flag_string));
         result->integer = token->integer;
-        result->string = token->s8;
+        result->string = token->string;
         return result;
     } else if (token->kind == lex_kind_real) {
         ast_t *result = create_ast(par, token, set_bit(ast_flag_real) | set_bit(ast_flag_string));
         result->real = (double)token->real;
-        result->string = token->s8;
+        result->string = token->string;
         return result;
     } else if (token->kind == lex_kind_open_paren) {
         ast_t *result = parse_expr(par);
@@ -189,7 +189,7 @@ void run_parser_test() {
 ast_t *parse_struct_mem(parser_t *par, s8_t *name) {
     lex_t *type_name = parser_expect(par, lex_kind_ident);
     ast_t *type = create_ast(par, type_name, set_bit(ast_flag_type_name) | set_bit(ast_flag_string));
-    type->string = type_name->s8;
+    type->string = type_name->string;
 
     while (parser_match(par, lex_kind_multiply)) {
         ast_t *pointer = create_ast(par, par->at, set_bit(ast_flag_type_pointer) | set_bit(ast_flag_string));
@@ -198,7 +198,7 @@ ast_t *parse_struct_mem(parser_t *par, s8_t *name) {
         type = pointer;
     }
 
-    *name = parser_expect(par, lex_kind_ident)->s8;
+    *name = parser_expect(par, lex_kind_ident)->string;
 
     while (parser_match(par, lex_kind_open_bracket)) {
         ast_t *array = create_ast(par, par->at, set_bit(ast_flag_type_array) | set_bit(ast_flag_string));
@@ -233,7 +233,7 @@ ast_t *parse_decls(ma_arena_t *arena, char *file, char *code) {
             while (par->at->kind == lex_kind_ident) {
                 lex_t *val = parser_expect(par, lex_kind_ident);
                 ast_t *mem = create_ast(par, val, set_bit(ast_flag_enum_member) | set_bit(ast_flag_string));
-                mem->string = val->s8;
+                mem->string = val->string;
                 ast_append(n, mem);
 
                 // if (parser_match(par, lex_kind_assign)) {
@@ -243,12 +243,12 @@ ast_t *parse_decls(ma_arena_t *arena, char *file, char *code) {
                 if (!parser_match(par, lex_kind_comma)) break;
             }
             parser_expect(par, lex_kind_close_brace);
-            n->string = parser_expect(par, lex_kind_ident)->s8;
+            n->string = parser_expect(par, lex_kind_ident)->string;
             parser_expect(par, lex_kind_semicolon);
         } else if (parser_matchi(par, s8_lit("struct"))) {
             ast_t *n = create_ast(par, pos, set_bit(ast_flag_string) | set_bit(ast_flag_struct));
             ast_append(result, n);
-            n->string = parser_expect(par, lex_kind_ident)->s8;
+            n->string = parser_expect(par, lex_kind_ident)->string;
 
             parser_expect(par, lex_kind_open_brace);
             while (par->at->kind != lex_kind_close_brace) {
@@ -285,16 +285,16 @@ ast_t *parse_table(ma_arena_t *arena, char *file, char *code) {
             if (parser_match(par, lex_kind_ident) || parser_match(par, lex_kind_string)) {
                 ast_t *col = create_ast(par, par->at, set_bit(ast_flag_string));
                 ast_append(row, col);
-                col->string = token->s8;
+                col->string = token->string;
             } else if (parser_match(par, lex_kind_integer)) {
                 ast_t *col = create_ast(par, par->at, set_bit(ast_flag_string) | set_bit(ast_flag_integer));
                 ast_append(row, col);
-                col->string = token->s8;
+                col->string = token->string;
                 col->integer = token->integer;
             } else if (parser_match(par, lex_kind_real)) {
                 ast_t *col = create_ast(par, par->at, set_bit(ast_flag_string) | set_bit(ast_flag_real));
                 ast_append(row, col);
-                col->string = token->s8;
+                col->string = token->string;
                 col->real = token->real;
             } else if (parser_match(par, lex_kind_bit_or) || parser_match(par, lex_kind_eof)) {
                 break;

src/wasm_app/main.c

@@ -11,9 +11,19 @@ void app_update(ma_arena_t *perm_arena, app_event_t *events, i32 event_count) {
     if (frame_arena == NULL) {
         frame_arena = ma_push_arena(perm_arena, kib(32));
     }
+
+    f64 pos = 0.0;
+    f64 offset = get_font_height() + 8;
     for (i32 i = 0; i < event_count; i += 1) {
         s8_t string = s8_serial_data(frame_arena, events + i, &type__app_event_t);
-        draw_text((v2f64_t){0, (f64)i*20.0}, white_color_global, string);
+        sb8_t split = s8_split(frame_arena, string, s8_lit("\n"), s8_split_none);
+
+
+        for (sb8_node_t *it = split.first; it; it = it->next) {
+            draw_text((v2f64_t){0, pos}, white_color_global, it->string);
+
+            pos += offset;
+        }
     }
 
     ma_set0(frame_arena);