improve parser

.gitignore

···
 .temp
 program
 manifesto
+crone/lang/design

crone/core/core.c

···
 
+#include <string.h>
 #include <stdint.h>
 #include <stddef.h>
 
 #include <core.h>
 
 #include "ptr_list.h"
+#include "list.h"
 

crone/core/list.h

···
+
+list list_allocate(size_t initial_capacity, size_t element_size) {
+    list list = {
+        .count = 0,
+        .capacity = initial_capacity,
+        .element_size = element_size,
+        .data = malloc(element_size * initial_capacity)
+    };
+    if (list.data == NULL) { CRASH("failed malloc: list"); }
+    return list;
+}
+
+void list_append(list *list, void *item) {
+    list->count += 1;
+    if (list->count > list->capacity) {
+        /*========* Next power of two *========*/
+        list->capacity = list->count;
+        list->capacity |= list->capacity >> 1;
+        list->capacity |= list->capacity >> 2;
+        list->capacity |= list->capacity >> 4;
+        list->capacity |= list->capacity >> 8;
+        list->capacity |= list->capacity >> 16;
+        if (sizeof(void*) > sizeof(uint32_t)) {
+            list->capacity |= list->capacity >> 32;
+        }
+        ++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);
+}
+
+void *list_element(list list, size_t index) {
+    return list.data + index * list.element_size;
+}
+
+void list_cleanup(list list) {
+    free(list.data);
+}
+

crone/core/ptr_list.h

···
 
-extern inline ptr_list ptrs_allocate(size_t initial_capacity) {
+ptr_list ptrs_allocate(size_t initial_capacity) {
     ptr_list list = {
         .count = 0,
         .capacity = initial_capacity,
···
     list->data[list->count - 1] = item;
 }
 
-extern inline void ptrs_cleanup(ptr_list list) {
+void ptrs_cleanup(ptr_list list) {
     free(list.data);
 }
 

crone/interface/core.h

···
 
 #include "core/ptr_list.h"
+#include "core/list.h"
 #include "core/dev.h"
 
+typedef struct string {
+    char *data;
+    size_t length;
+} string;
+

crone/interface/core/list.h

···
+
+typedef struct list {
+    size_t count;
+    size_t capacity;
+    size_t element_size;
+    void* *data;
+} list;
+
+list list_allocate(size_t initial_capacity, size_t element_size);
+
+void list_append(list *list, void *item);
+
+void *list_element(list list, size_t index);
+
+void list_cleanup(list list);
+

crone/interface/lang.h

···
 
 #include <stdio.h>
+#include <core.h>
 
-void execute(char *crone_script, size_t length);
+void execute_crone(string crone_script);
 

crone/lang/interpreter.c

···
 
 #include <unistd.h>
 #include <ctype.h>
+#include <string.h>
 
 #include <lang.h>
 #include <core.h>
 
 #define STATES(OP) \
+    OP(INVALID) \
     OP(OUTER_SPACE) \
     OP(TERM) \
-    OP(PRELUDIC_SPACE) \
-    OP(PRELUDE) \
+    OP(INNER_SPACE) \
     OP(BLOCK) \
 
 #define COMMA_SEPARATED(VALUE) VALUE,
···
 };
 
 void print_substring(char *start, size_t length) {
-    fprintf(stderr, "%.*s", (int)length, start);
-}
-
-bool ends_prelude(char c) {
-    return c == ';' || c == '{';
-}
-
-bool starts_term(char c) {
-    return !isspace(c);
-}
-
-bool ends_term(char c) {
-    return isspace(c);
-}
-
-bool ends_block(char c) {
-
-    return c == '}';
+    for (size_t i = 0; i < length; ++i) {
+        if (start[i] == '\n') {
+            fputc('\\', stderr);
+            fputc('n', stderr);
+        } else {
+            fputc(start[i], stderr);
+        }
+    }
 }
 
 typedef struct parse {
     char *start;
     size_t length;
     parser_state parsed_as;
-    void *subparse;
+    list subparses;
 } parse;
 
-void print_parse(parse p) {
+const char *spaces = "                                ";
+
+void print_parse(parse p, size_t indent) {
+    size_t space_count = 4 * indent;
+    if (space_count > strlen(spaces)) {
+        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");
 }
 
-void execute(char *crone_script, size_t length) {
+inline 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;
+    p->parsed_as = next_state;
+}
 
-    parser_state state = OUTER_SPACE;
+// TODO UNICODE
 
-    ptr_list substrings = ptrs_allocate(512);
+list/*subparses*/ parse_crone(string crone_script, size_t *p_position) {
+    list parses = list_allocate(512, sizeof(parse));
+
+    parse current_parse;
+
+    current_parse.start = crone_script.data + (*p_position);
+    current_parse.parsed_as = OUTER_SPACE;
 
-    char *start = crone_script;
+    #define NEXT(state) transition(&parses, &current_parse, crone_script.data + (*p_position), state)
 
-    size_t sublength = 0;
+    // optimize w/ computed goto?
 
-    for (size_t index = 0; index < length; ++index) {
-        // TODO: actual unicode parsing lol
-        char _char = crone_script[index];
-        switch (state) {
-            // TODO: simplify entire state machine to be less repetitive
+    for (; (*p_position) < crone_script.length; ++(*p_position)) {
+        char _char = crone_script.data[*p_position];
+        switch (current_parse.parsed_as) {
             case OUTER_SPACE:
-                if (starts_term(_char)) {
-                    parse *p = malloc(sizeof(parse));
-                    p->start = start;
-                    p->length = sublength;
-                    p->parsed_as = state;
-                    ptrs_append(&substrings, p);
-                    start = (void*)(crone_script + index);
-                    sublength = 0;
-                    state = TERM;
-                } else {
-                    ++sublength;
+                if (_char == '}') {
+                    NEXT(INVALID);
+                } else if (!isspace(_char)) {
+                    NEXT(TERM);
                 }
             break;
-            case PRELUDIC_SPACE:
-                ++sublength;
-                if (starts_term(_char)) {
-                    parse *p = malloc(sizeof(parse));
-                    p->start = start;
-                    p->length = sublength;
-                    p->parsed_as = state;
-                    ptrs_append(&substrings, p);
-                    start = (void*)(crone_script + index);
-                    sublength = 0;
-                    state = PRELUDE;
+            case INNER_SPACE:
+                if (_char == '{') {
+                    NEXT(BLOCK);
+                } else if (_char == ';') {
+                    ++(*p_position);
+                    NEXT(OUTER_SPACE);
+                } else if (_char == '}') {
+                    NEXT(INVALID);
+                } else if (!isspace(_char)) {
+                    NEXT(TERM);
                 }
             break;
             case TERM:
-                ++sublength;
-                if (ends_term(_char)) {
-                    parse *p = malloc(sizeof(parse));
-                    p->start = start;
-                    p->length = sublength;
-                    p->parsed_as = state;
-                    ptrs_append(&substrings, p);
-                    start = (void*)(crone_script + index);
-                    sublength = 0;
-                    state = PRELUDIC_SPACE;
-                }
-            break;
-            case PRELUDE:
-                ++sublength;
-                if (ends_prelude(_char)) {
-                    parse *p = malloc(sizeof(parse));
-                    p->start = start;
-                    p->length = sublength;
-                    p->parsed_as = state;
-                    ptrs_append(&substrings, p);
-                    start = (void*)(crone_script + index);
-                    sublength = 0;
-                    state = BLOCK;
+                if (isspace(_char)) {
+                    NEXT(INNER_SPACE);
+                } else if (_char == '}') {
+                    NEXT(INVALID);
+                } else if (_char == '{') {
+                    NEXT(BLOCK);
+                } else if (_char == ';') {
+                    NEXT(OUTER_SPACE);
+                    ++(*p_position);
                 }
             break;
             case BLOCK:
                 // TODO parsing for block dependent on term and prelude
-                ++sublength;
-                if (ends_block(_char)) {
-                    parse *p = malloc(sizeof(parse));
-                    p->start = start;
-                    p->length = sublength;
-                    p->parsed_as = state;
-                    ptrs_append(&substrings, p);
-                    start = (void*)(crone_script + index);
-                    sublength = 0;
-                    state = OUTER_SPACE;
-                }
+                current_parse.subparses = parse_crone(crone_script, p_position);
+                NEXT(OUTER_SPACE);
             break;
+            case INVALID:
+                return parses;
+                break;
         }
     }
 
-    parse *p = malloc(sizeof(parse));
-    p->start = start;
-    p->length = sublength;
-    p->parsed_as = state;
-    ptrs_append(&substrings, p);
+    #undef NEXT
 
+    list_append(&parses, &current_parse);
 
-    for (int i = 0; i < substrings.count; ++i) {
-        print_parse(*(parse *)substrings.data[i]);
-    }
+    return parses;
+}
 
-    for (int i = 0; i < substrings.count; ++i) {
-        free(substrings.data[i]);
+void print_parses(list parses, int indent) {
+    for (int i = 0; i < parses.count; ++i) {
+        parse p = *(parse*)list_element(parses, i);
+        //if (p.parsed_as != OUTER_SPACE && p.parsed_as != INNER_SPACE) {
+            print_parse(p, indent);
+            if (p.parsed_as == BLOCK) {
+                print_parses(p.subparses, indent + 1);
+            }
+        //}
     }
+}
 
-    ptrs_cleanup(substrings);
+void execute_crone(string crone_script) {
+    size_t position = 0;
+    list parses = parse_crone(crone_script, &position);
 
+    print_parses(parses, 0);
 }
 
 /*

crone/lang/parseme.cr

···
+
+term0 term1 term2 term3 {
+    block block
+
+    block {
+        blooooooock!!!!
+        block!!!;
+
+        block! !!! {
+            INNERMOST BLOCK;
+        }
+    }
+
+    block
+}
+
+term4 term5;
+
+term6 { block2 }
+

program.c

···
 #include <crone.h>
 
 int main() {
-    int fileDesc = open("./crone/core/core.cr", O_RDONLY, 0);
+    //int fileDesc = open("./crone/core/core.cr", O_RDONLY, 0);
+    int fileDesc = open("./crone/lang/parseme.cr", O_RDONLY, 0);
 
     if (fileDesc == -1) {
         CRASH("bad file");
···
         CRASH("bad mmap");
     }
 
-    execute(file, fileStat.st_size);
+    string script = {
+        .data = file,
+        .length = fileStat.st_size
+    };
+
+    execute_crone(script);
 
     result = munmap(file, fileStat.st_size);