fix list pointer arithmetic

crone/core/list.h

···
         }
         ++list->capacity;
         /*=====================================*/
-
         list->data = realloc(list->data, list->element_size * list->capacity);
         if (list->data == NULL) { CRASH("failed realloc: list"); }
     }
 
-    memcpy(list->data + (list->count - 1) * list->element_size, item, list->element_size);
+    memcpy((uint8_t*)list->data + (list->count - 1) * list->element_size, item, list->element_size);
 }
 
 void *list_element(list list, size_t index) {
-    return list.data + index * list.element_size;
+    return (uint8_t*)list.data + index * list.element_size;
 }
 
 void list_cleanup(list list) {

crone/lang/interpreter.c

···
     OP(OUTER_SPACE) \
     OP(TERM) \
     OP(INNER_SPACE) \
+    OP(PUNCTUATION) \
     OP(BLOCK) \
 
 #define COMMA_SEPARATED(VALUE) VALUE,
···
     list subparses;
 } parse;
 
-const char *spaces = "                                ";
+const char *spaces = "                                            ";
 
 void print_parse(parse p, size_t indent) {
     size_t space_count = 4 * indent;
···
         space_count = strlen(spaces);
     }
     fwrite(spaces, 1, space_count, stderr);
-    fprintf(stderr, "parsed as %s: \"", state_names[p.parsed_as]);
-    print_substring(p.start, p.length);
-    fprintf(stderr, "\"\n");
+    fprintf(stderr, "%s[", state_names[p.parsed_as]);
+    if (p.parsed_as != BLOCK) {
+        print_substring(p.start, p.length);
+    } else {
+        fprintf(stderr, "%lu", p.subparses.count);
+    }
+    fprintf(stderr, "]\n");
 }
 
-inline void transition(list *l, parse *p, char *end_position, parser_state next_state) {
+void transition(list *l, parse *p, char *end_position, parser_state next_state) {
     p->length = (size_t)end_position - (size_t)(p->start);
     list_append(l,p);
     p->start = end_position;
···
 // TODO UNICODE
 
 list/*subparses*/ parse_crone(string crone_script, size_t *p_position) {
-    list parses = list_allocate(512, sizeof(parse));
+    list parses = list_allocate(128, sizeof(parse));
 
     parse current_parse;
 
···
 
     for (; (*p_position) < crone_script.length; ++(*p_position)) {
         char _char = crone_script.data[*p_position];
+
         switch (current_parse.parsed_as) {
             case OUTER_SPACE:
                 if (_char == '}') {
                     NEXT(INVALID);
+                } else if (_char == '{') {
+                    NEXT(BLOCK);
+                } else if (_char == ';') {
+                    NEXT(PUNCTUATION);
                 } else if (!isspace(_char)) {
                     NEXT(TERM);
                 }
···
                 if (_char == '{') {
                     NEXT(BLOCK);
                 } else if (_char == ';') {
-                    ++(*p_position);
-                    NEXT(OUTER_SPACE);
+                    NEXT(PUNCTUATION);
                 } else if (_char == '}') {
                     NEXT(INVALID);
                 } else if (!isspace(_char)) {
···
                 } else if (_char == '{') {
                     NEXT(BLOCK);
                 } else if (_char == ';') {
-                    NEXT(OUTER_SPACE);
-                    ++(*p_position);
+                    NEXT(PUNCTUATION);
                 }
             break;
             case BLOCK:
···
                 current_parse.subparses = parse_crone(crone_script, p_position);
                 NEXT(OUTER_SPACE);
             break;
+            case PUNCTUATION:
+                if (isspace(_char)) {
+                    NEXT(OUTER_SPACE);
+                } else if (_char == '}') {
+                    NEXT(INVALID);
+                } else if (_char == '{') {
+                    NEXT(BLOCK);
+                } else if (_char != ';') {
+                    NEXT(TERM);
+                }
+            break;
             case INVALID:
                 return parses;
-                break;
+            break;
         }
     }
 
···
     }
 }
 
+void cleanup_parses(list parses) {
+    for (int i = 0; i < parses.count; ++i) {
+        parse p = *(parse*)list_element(parses, i);
+        if (p.parsed_as == BLOCK) {
+            cleanup_parses(p.subparses);
+        }
+    }
+    list_cleanup(parses);
+}
+
 void execute_crone(string crone_script) {
     size_t position = 0;
     list parses = parse_crone(crone_script, &position);
 
     print_parses(parses, 0);
+
+    if (position < crone_script.length) {
+        fprintf(stderr, "warning: early exit @ %lu / %lu\n", position, crone_script.length);
+    }
+
+    cleanup_parses(parses);
 }
 
 /*

crone/lang/parseme.cr

···
 
 term4 term5;
 
-term6 { block2 }
+v{verbatim syntax?}
+
+verbatim{alternate option}
+
+trimmed v{ lets you put some spaces on the edges, for readability }
+
+hex FF0000;
+
+no reason you {can't} keep writing after {a block};
+
+extraneous punctuation;;;
+
+sob ;_;
+
+
+here are some more terms { and a block }
+
+and some more terms with no block;
+
+some terms
+    with whitespace;
+
+
+deep nesting {
+    deeep nesting {
+        deeeep nesting {
+            asdf {
+                asdff {
+                    asdfff {
+                        foo {
+                            bar {
+                                baz {
+                                    qwertyuiopasdfghjklzxcvbnm {
+                                        ;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                asdfasdf {
+                    asdfasdfasdf asdf {
+
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+let's do some blocks {
+    waow;
+
+    this is a block {
+        inside a block {
+            another block;
+
+            with content;
+
+            including { this block }
+        }
+
+
+        !!!;;;
+
+        !!
+
+
+        !;
+    }
+}
 

makefile

···
 LINKS = -lX11 -lvulkan
 HEADERS = -I $(PROJECT_NAME)/interface
 ERRORS = -Wfatal-errors -Wall -Werror=use-after-free -Wno-unused-variable -Wpedantic
-%_dev: VERSION_FLAGS = -Og -DDO_VALIDATION
+%_dev: VERSION_FLAGS = -Og -DDO_VALIDATION -fsanitize=address,undefined
 %_release: VERSION_FLAGS = -O3
 FLAGS = -std=c23 $(ERRORS) $(VERSION_FLAGS) $(HEADERS) -DUSE_X11