From 42da7b1d05952eb5951994d96f8a7e82fd4c609b Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Mon, 31 Mar 2025 15:08:29 +0200
Subject: [PATCH 01/15] Move err_allocation_failed into error.c and make it
 available to everyone.

---
 src/error.c | 3 +++
 src/error.h | 3 +++
 src/lexer.c | 3 ---
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/error.c b/src/error.c
index 008c588..9ede6cb 100644
--- a/src/error.c
+++ b/src/error.c
@@ -10,6 +10,9 @@ error_t *const err_errorf_length = &(error_t){
     .message =
         "Formatting of another error failed to determine the error length"};
 
+error_t *err_allocation_failed =
+    &(error_t){.message = "Memory allocation failed"};
+
 error_t *errorf(const char *fmt, ...) {
     error_t *err = calloc(1, sizeof(error_t));
     if (err == nullptr)
diff --git a/src/error.h b/src/error.h
index 5a6f143..96374e0 100644
--- a/src/error.h
+++ b/src/error.h
@@ -18,4 +18,7 @@ static inline void error_free(error_t *err) {
     free(err);
 }
 
+/* Some global errors */
+extern error_t *err_allocation_failed;
+
 #endif // INCLUDE_SRC_ERROR_H_
diff --git a/src/lexer.c b/src/lexer.c
index be808cc..08a96bd 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -20,9 +20,6 @@ error_t *err_eof =
 
 error_t *err_unknown_read = &(error_t){.message = "Unknown read error"};
 
-error_t *err_allocation_failed =
-    &(error_t){.message = "Memory allocation failed"};
-
 typedef bool (*char_predicate_t)(char);
 
 const char *lexer_token_id_to_cstr(lexer_token_id_t id) {
-- 
2.47.2


From bd37ddaeea3c4e2e3deadfbd465436c1e2804378 Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Mon, 31 Mar 2025 18:38:46 +0200
Subject: [PATCH 02/15] Add tokenlist, a linked list of lexer tokens

The linked list is doubly linked so the parser can look forward into it
and error reporting can look backward.

This commmit also reworks main to use the tokenlist instead of dealing
with the lexer manually.
---
 src/main.c      | 40 +++++++++++++++---------
 src/tokenlist.c | 83 +++++++++++++++++++++++++++++++++++++++++++++++++
 src/tokenlist.h | 30 ++++++++++++++++++
 3 files changed, 138 insertions(+), 15 deletions(-)
 create mode 100644 src/tokenlist.c
 create mode 100644 src/tokenlist.h

diff --git a/src/main.c b/src/main.c
index 94af906..d74d710 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,5 +1,6 @@
 #include "error.h"
 #include "lexer.h"
+#include "tokenlist.h"
 
 #include <limits.h>
 #include <stdio.h>
@@ -39,24 +40,33 @@ int main(int argc, char *argv[]) {
         print_fn = print_value;
     }
 
-    lexer_t lex = {0};
-    lexer_token_t token;
-    error_t *err = lexer_open(&lex, filename);
-    if (err) {
-        puts(err->message);
-        error_free(err);
-        return 1;
-    }
+    lexer_t *lex = &(lexer_t){};
+    error_t *err = lexer_open(lex, filename);
+    if (err)
+        goto cleanup_error;
 
-    bool keep_going = true;
-    while (keep_going && (err = lexer_next(&lex, &token)) == nullptr) {
-        keep_going = print_fn(&token);
-        free(token.value);
-    }
+    tokenlist_t *list;
+    err = tokenlist_alloc(&list);
+    if (err)
+        goto cleanup_lexer;
 
-    if (err && err != err_eof) {
-        puts(err->message);
+    err = tokenlist_fill(list, lex);
+    if (err)
+        goto cleanup_tokens;
+
+    for (auto entry = list->head; entry; entry = entry->next) {
+        print_fn(&entry->token);
     }
+    tokenlist_free(list);
     error_free(err);
     return 0;
+
+cleanup_tokens:
+    tokenlist_free(list);
+cleanup_lexer:
+    lexer_close(lex);
+cleanup_error:
+    puts(err->message);
+    error_free(err);
+    return 1;
 }
diff --git a/src/tokenlist.c b/src/tokenlist.c
new file mode 100644
index 0000000..0a102b1
--- /dev/null
+++ b/src/tokenlist.c
@@ -0,0 +1,83 @@
+#include "tokenlist.h"
+#include "error.h"
+#include "lexer.h"
+#include <stdlib.h>
+
+error_t *tokenlist_alloc(tokenlist_t **output) {
+    *output = nullptr;
+
+    tokenlist_t *list = calloc(1, sizeof(tokenlist_t));
+    if (list == nullptr)
+        return err_allocation_failed;
+
+    list->head = nullptr;
+    list->tail = nullptr;
+
+    *output = list;
+    return nullptr;
+}
+
+error_t *tokenlist_entry_alloc(tokenlist_entry_t **output) {
+    *output = nullptr;
+
+    tokenlist_entry_t *entry = calloc(1, sizeof(tokenlist_entry_t));
+    if (entry == nullptr)
+        return err_allocation_failed;
+
+    entry->next = nullptr;
+    entry->prev = nullptr;
+
+    *output = entry;
+    return nullptr;
+}
+
+void tokenlist_append(tokenlist_t *list, tokenlist_entry_t *entry) {
+    if (list->head == nullptr) {
+        list->head = entry;
+        list->tail = entry;
+        entry->next = nullptr;
+        entry->prev = nullptr;
+    } else {
+        entry->prev = list->tail;
+        entry->next = nullptr;
+        list->tail->next = entry;
+        list->tail = entry;
+    }
+}
+
+void tokenlist_entry_free(tokenlist_entry_t *entry) {
+    lexer_token_cleanup(&entry->token);
+    free(entry);
+}
+
+void tokenlist_free(tokenlist_t *list) {
+    if (list == nullptr)
+        return;
+
+    tokenlist_entry_t *current = list->head;
+    while (current) {
+        tokenlist_entry_t *next = current->next;
+        tokenlist_entry_free(current);
+        current = next;
+    }
+
+    free(list);
+}
+
+error_t *tokenlist_fill(tokenlist_t *list, lexer_t *lex) {
+    error_t *err = nullptr;
+    lexer_token_t token = {};
+    while ((err = lexer_next(lex, &token)) == nullptr) {
+        tokenlist_entry_t *entry;
+        err = tokenlist_entry_alloc(&entry);
+        if (err) {
+            lexer_token_cleanup(&token);
+            return err;
+        }
+        entry->token = token;
+        tokenlist_append(list, entry);
+    }
+    if (err != err_eof)
+        return err;
+    return nullptr;
+}
diff --git a/src/tokenlist.h b/src/tokenlist.h
new file mode 100644
index 0000000..25d75e3
--- /dev/null
+++ b/src/tokenlist.h
@@ -0,0 +1,30 @@
+#ifndef INCLUDE_SRC_TOKENLIST_H_
+#define INCLUDE_SRC_TOKENLIST_H_
+#include "lexer.h"
+
+typedef struct tokenlist_entry tokenlist_entry_t;
+
+struct tokenlist_entry {
+    lexer_token_t token;
+    tokenlist_entry_t *next;
+    tokenlist_entry_t *prev;
+};
+
+typedef struct tokenlist {
+    tokenlist_entry_t *head;
+    tokenlist_entry_t *tail;
+} tokenlist_t;
+
+/**
+ * @brief Allocate a new doubly linked list of lexer tokens
+ */
+error_t *tokenlist_alloc(tokenlist_t **list);
+
+/**
+ * Consume all tokens from the lexer and add them to the list
+ */
+error_t *tokenlist_fill(tokenlist_t *list, lexer_t *lex);
+
+void tokenlist_free(tokenlist_t *list);
+
+#endif // INCLUDE_SRC_TOKENLIST_H_
-- 
2.47.2


From 34ace3692023409aca270bd2b8e44c9ad70b6f04 Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Mon, 31 Mar 2025 14:47:58 +0200
Subject: [PATCH 03/15] Add a parser grammar

---
 doc/parser_grammar.txt | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 doc/parser_grammar.txt

diff --git a/doc/parser_grammar.txt b/doc/parser_grammar.txt
new file mode 100644
index 0000000..e7e9315
--- /dev/null
+++ b/doc/parser_grammar.txt
@@ -0,0 +1,39 @@
+<program>   ::= <statement>*
+<statement> ::= <label> | <directive> | <instruction>
+
+<label> ::= <identifier> <colon>
+
+<directive> ::= <dot> <section_directive>
+
+<section_directive> ::= "section" <identifier>
+
+<instruction> ::= <identifier> <operands>
+
+<operands> ::= <operand> ( <comma> <operand> )*
+
+<operand>  ::= <register> | <immediate> | <memory>
+
+<immediate> ::= <number> | <label_reference>
+
+<number> ::= <octal> | <binary> | <decimal> | <hexadecimal>
+
+<label_reference> ::= <identifier>
+
+<memory> ::= <lbracket> <memory_expression> <rbracket>
+
+<memory_expression> ::= <label_reference> | <register_expression>
+
+<register_expression> ::= <register> <register_index>? <register_offset>?
+
+<register_index> ::= <plus> <register> <asterisk> <number>
+
+<register_offset> ::= <plus_or_minus> <number>
+
+<plus_or_minus> ::= <plus> | <minus>
+
+
+/* These are lexer identifiers with the correct string value */
+<section> ::= "section"
+
+<register> ::= "rax" | "rbx" | "rcx" | "rdx" | "rsi" | "rdi" | "rbp" | "rsp" |
+"r8" | "r9" | "r10" | "r11" | "r12" | "r13" | "r14" | "r15"
-- 
2.47.2


From 935da30257bf55aa4dc32815acce04867f191681 Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Mon, 31 Mar 2025 16:31:42 +0200
Subject: [PATCH 04/15] Add basic AST functionality

---
 src/ast.c |  85 ++++++++++++++++++++++++++++++++++++++++++
 src/ast.h | 109 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 194 insertions(+)
 create mode 100644 src/ast.c
 create mode 100644 src/ast.h

diff --git a/src/ast.c b/src/ast.c
new file mode 100644
index 0000000..65ac611
--- /dev/null
+++ b/src/ast.c
@@ -0,0 +1,85 @@
+#include "ast.h"
+#include "error.h"
+#include <string.h>
+
+error_t *err_node_children_cap = &(error_t){
+    .message = "Failed to increase ast node children, max capacity reached"};
+
+error_t *ast_node_alloc(ast_node_t **output) {
+    *output = nullptr;
+
+    ast_node_t *node = calloc(1, sizeof(ast_node_t));
+    if (node == nullptr)
+        return err_allocation_failed;
+
+    *output = node;
+    return nullptr;
+}
+
+void ast_node_free_value(ast_node_t *node) {
+    // TODO: decide how value ownership will work and clean it up here
+}
+
+void ast_node_free(ast_node_t *node) {
+    if (node == nullptr)
+        return;
+    if (node->children) {
+        for (size_t i = 0; i < node->len; ++i)
+            ast_node_free(node->children[i]);
+        free(node->children);
+    }
+
+    ast_node_free_value(node);
+
+    memset(node, 0, sizeof(ast_node_t));
+    free(node);
+}
+
+/**
+ * @pre node->children must be nullptr
+ */
+error_t *ast_node_alloc_children(ast_node_t *node) {
+    node->children = calloc(node_default_children_cap, sizeof(ast_node_t *));
+    if (node->children == nullptr)
+        return err_allocation_failed;
+
+    node->cap = node_default_children_cap;
+    return nullptr;
+}
+
+error_t *ast_node_grow_cap(ast_node_t *node) {
+    if (node->cap >= node_max_children_cap) {
+        return err_node_children_cap;
+    }
+
+    size_t new_cap = node->cap * 2;
+    if (new_cap > node_max_children_cap) {
+        new_cap = node_max_children_cap;
+    }
+
+    ast_node_t **new_children =
+        realloc(node->children, new_cap * sizeof(ast_node_t *));
+    if (new_children == nullptr) {
+        return err_allocation_failed;
+    }
+
+    node->children = new_children;
+    node->cap = new_cap;
+
+    return nullptr;
+}
+
+error_t *ast_node_add_child(ast_node_t *node, ast_node_t *child) {
+    error_t *err = nullptr;
+    if (node->children == nullptr)
+        err = ast_node_alloc_children(node);
+    else if (node->len >= node->cap)
+        err = ast_node_grow_cap(node);
+    if (err)
+        return err;
+
+    node->children[node->len] = child;
+    node->len += 1;
+
+    return nullptr;
+}
diff --git a/src/ast.h b/src/ast.h
new file mode 100644
index 0000000..2097910
--- /dev/null
+++ b/src/ast.h
@@ -0,0 +1,109 @@
+#ifndef INCLUDE_SRC_AST_H_
+#define INCLUDE_SRC_AST_H_
+
+#include "error.h"
+#include "lexer.h"
+#include "tokenlist.h"
+#include <stddef.h>
+#include <stdint.h>
+
+typedef enum node_id {
+    NODE_INVALID,
+
+    NODE_PROGRAM,
+    NODE_STATEMENT,
+    NODE_LABEL,
+    NODE_DIRECTIVE,
+    NODE_INSTRUCTION,
+    NODE_OPERANDS,
+    NODE_OPERAND,
+    NODE_IMMEDIATE,
+    NODE_MEMORY,
+    NODE_NUMBER,
+    NODE_LABEL_REFERENCE,
+    NODE_MEMORY_EXPRESSION,
+    NODE_REGISTER_EXPRESSION,
+    NODE_REGISTER_INDEX,
+    NODE_REGISTER_OFFSET,
+    NODE_PLUS_OR_MINUS,
+    NODE_SECTION_DIRECTIVE,
+
+    // Validated primitives
+    NODE_REGISTER,
+    NODE_SECTION,
+
+    // Primitive nodes
+    NODE_IDENTIFIER,
+    NODE_DECIMAL,
+    NODE_HEXADECIMAL,
+    NODE_OCTAL,
+    NODE_BINARY,
+    NODE_CHAR,
+    NODE_STRING,
+    NODE_COLON,
+    NODE_COMMA,
+    NODE_LBRACKET,
+    NODE_RBRACKET,
+    NODE_PLUS,
+    NODE_MINUS,
+    NODE_ASTERISK,
+    NODE_DOT,
+} node_id_t;
+
+typedef struct ast_node ast_node_t;
+
+constexpr size_t node_default_children_cap = 8;
+/* 65K ought to be enough for anybody */
+constexpr size_t node_max_children_cap = 1 << 16;
+
+struct ast_node {
+    node_id_t id;
+    tokenlist_entry_t *token_entry;
+    size_t len;
+    size_t cap;
+    ast_node_t **children;
+
+    union {
+        struct {
+            uint64_t value;
+            int size;
+        } integer;
+        char *name;
+    } value;
+};
+
+/**
+ * @brief Allocates a new AST node
+ *
+ * Creates and initializes a new AST node with default (zero) values.
+ *
+ * @param[out] output Pointer to store the allocated node
+ * @return error_t* nullptr on success, allocation error on failure
+ */
+error_t *ast_node_alloc(ast_node_t **node);
+
+/**
+ * @brief Frees an AST node and all its children recursively
+ *
+ * Recursively frees all children of the node, then frees the node itself.
+ * If node is nullptr, the function returns without doing anything.
+ *
+ * @param node The node to free
+ */
+void ast_node_free(ast_node_t *node);
+
+/**
+ * @brief Adds a child node to a parent node
+ *
+ * Adds the specified child node to the parent's children array.
+ * If this is the first child, the function allocates the children array.
+ * If the children array is full, the function increases its capacity.
+ *
+ * @param node The parent node to add the child to
+ * @param child The child node to add
+ * @return error_t* nullptr on success, allocation error on failure,
+ *                  or err_node_children_cap if maximum capacity is reached
+ */
+error_t *ast_node_add_child(ast_node_t *node, ast_node_t *child);
+
+#endif // INCLUDE_SRC_AST_H_
-- 
2.47.2


From bbdcad024f3ab8817b150a4f0c55034a816e6b18 Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Tue, 1 Apr 2025 23:54:31 +0200
Subject: [PATCH 05/15] Add function to print the AST

---
 src/ast.c | 102 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/ast.h |  11 ++++++
 2 files changed, 113 insertions(+)

diff --git a/src/ast.c b/src/ast.c
index 65ac611..769d3b7 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -1,5 +1,6 @@
 #include "ast.h"
 #include "error.h"
+#include <assert.h>
 #include <string.h>
 
 error_t *err_node_children_cap = &(error_t){
@@ -83,3 +84,104 @@ error_t *ast_node_add_child(ast_node_t *node, ast_node_t *child) {
 
     return nullptr;
 }
+
+const char *ast_node_id_to_cstr(node_id_t id) {
+    switch (id) {
+    case NODE_INVALID:
+        return "NODE_INVALID";
+    case NODE_PROGRAM:
+        return "NODE_PROGRAM";
+    case NODE_STATEMENT:
+        return "NODE_STATEMENT";
+    case NODE_LABEL:
+        return "NODE_LABEL";
+    case NODE_DIRECTIVE:
+        return "NODE_DIRECTIVE";
+    case NODE_INSTRUCTION:
+        return "NODE_INSTRUCTION";
+    case NODE_OPERANDS:
+        return "NODE_OPERANDS";
+    case NODE_OPERAND:
+        return "NODE_OPERAND";
+    case NODE_IMMEDIATE:
+        return "NODE_IMMEDIATE";
+    case NODE_MEMORY:
+        return "NODE_MEMORY";
+    case NODE_NUMBER:
+        return "NODE_NUMBER";
+    case NODE_LABEL_REFERENCE:
+        return "NODE_LABEL_REFERENCE";
+    case NODE_MEMORY_EXPRESSION:
+        return "NODE_MEMORY_EXPRESSION";
+    case NODE_REGISTER_EXPRESSION:
+        return "NODE_REGISTER_EXPRESSION";
+    case NODE_REGISTER_INDEX:
+        return "NODE_REGISTER_INDEX";
+    case NODE_REGISTER_OFFSET:
+        return "NODE_REGISTER_OFFSET";
+    case NODE_PLUS_OR_MINUS:
+        return "NODE_PLUS_OR_MINUS";
+    case NODE_SECTION_DIRECTIVE:
+        return "NODE_SECTION_DIRECTIVE";
+    case NODE_REGISTER:
+        return "NODE_REGISTER";
+    case NODE_SECTION:
+        return "NODE_SECTION";
+    case NODE_IDENTIFIER:
+        return "NODE_IDENTIFIER";
+    case NODE_DECIMAL:
+        return "NODE_DECIMAL";
+    case NODE_HEXADECIMAL:
+        return "NODE_HEXADECIMAL";
+    case NODE_OCTAL:
+        return "NODE_OCTAL";
+    case NODE_BINARY:
+        return "NODE_BINARY";
+    case NODE_CHAR:
+        return "NODE_CHAR";
+    case NODE_STRING:
+        return "NODE_STRING";
+    case NODE_COLON:
+        return "NODE_COLON";
+    case NODE_COMMA:
+        return "NODE_COMMA";
+    case NODE_LBRACKET:
+        return "NODE_LBRACKET";
+    case NODE_RBRACKET:
+        return "NODE_RBRACKET";
+    case NODE_PLUS:
+        return "NODE_PLUS";
+    case NODE_MINUS:
+        return "NODE_MINUS";
+    case NODE_ASTERISK:
+        return "NODE_ASTERISK";
+    case NODE_DOT:
+        return "NODE_DOT";
+    }
+    assert(!"Unreachable, weird node id" && id);
+    __builtin_unreachable();
+}
+
+static void ast_node_print_internal(ast_node_t *node, int indent) {
+    if (node == NULL) {
+        return;
+    }
+
+    for (int i = 0; i < indent; i++) {
+        printf("  ");
+    }
+    printf("%s", ast_node_id_to_cstr(node->id));
+
+    if (node->token_entry && node->token_entry->token.value) {
+        printf(" \"%s\"", node->token_entry->token.value);
+    }
+    printf("\n");
+
+    for (size_t i = 0; i < node->len; i++) {
+        ast_node_print_internal(node->children[i], indent + 1);
+    }
+}
+
+void ast_node_print(ast_node_t *node) {
+    ast_node_print_internal(node, 0);
+}
diff --git a/src/ast.h b/src/ast.h
index 2097910..448c274 100644
--- a/src/ast.h
+++ b/src/ast.h
@@ -106,4 +106,15 @@ void ast_node_free(ast_node_t *node);
  */
 error_t *ast_node_add_child(ast_node_t *node, ast_node_t *child);
 
+/**
+ * @brief Prints an AST starting from the given node
+ *
+ * Prints a representation of the AST with indentation to show structure.
+ * Each node's type is shown, and if a node has an associated token value,
+ * that value is printed in quotes.
+ *
+ * @param node The root node of the AST to print
+ */
+void ast_node_print(ast_node_t *node);
+
 #endif // INCLUDE_SRC_AST_H_
-- 
2.47.2


From 5fb6ebef2832669dbe38cd4f014a3c348be76640 Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Tue, 1 Apr 2025 19:55:00 +0200
Subject: [PATCH 06/15] Add functions to skip over trivia in a tokenlist

---
 src/tokenlist.c | 23 +++++++++++++++++++++++
 src/tokenlist.h | 10 ++++++++++
 2 files changed, 33 insertions(+)

diff --git a/src/tokenlist.c b/src/tokenlist.c
index 0a102b1..84c2c39 100644
--- a/src/tokenlist.c
+++ b/src/tokenlist.c
@@ -81,3 +81,26 @@ error_t *tokenlist_fill(tokenlist_t *list, lexer_t *lex) {
         return err;
     return nullptr;
 }
+
+bool is_trivia(tokenlist_entry_t *trivia) {
+    switch (trivia->token.id) {
+    case TOKEN_WHITESPACE:
+    case TOKEN_COMMENT:
+    case TOKEN_NEWLINE:
+        return true;
+    default:
+        return false;
+    }
+}
+
+tokenlist_entry_t *tokenlist_skip_trivia(tokenlist_entry_t *current) {
+    while (current && is_trivia(current))
+        current = current->next;
+    return current;
+}
+
+tokenlist_entry_t *tokenlist_next(tokenlist_entry_t *current) {
+    if (!current)
+        return nullptr;
+    return tokenlist_skip_trivia(current->next);
+}
diff --git a/src/tokenlist.h b/src/tokenlist.h
index 25d75e3..22ac5ca 100644
--- a/src/tokenlist.h
+++ b/src/tokenlist.h
@@ -27,4 +27,14 @@ error_t *tokenlist_fill(tokenlist_t *list, lexer_t *lex);
 
 void tokenlist_free(tokenlist_t *list);
 
+/**
+ * Return the first token entry that isn't whitespace, newline or comment
+ */
+tokenlist_entry_t *tokenlist_skip_trivia(tokenlist_entry_t *current);
+
+/**
+ * Return the next token entry that isn't whitespace, newline or comment
+ */
+tokenlist_entry_t *tokenlist_next(tokenlist_entry_t *current);
+
 #endif // INCLUDE_SRC_TOKENLIST_H_
-- 
2.47.2


From c48adb1306d7a2d69c45e841733ebbce0925191f Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Tue, 1 Apr 2025 20:03:28 +0200
Subject: [PATCH 07/15] Add basic parser utilities

---
 src/parser/util.c | 35 +++++++++++++++++++++++++++++++++++
 src/parser/util.h | 25 +++++++++++++++++++++++++
 2 files changed, 60 insertions(+)
 create mode 100644 src/parser/util.c
 create mode 100644 src/parser/util.h

diff --git a/src/parser/util.c b/src/parser/util.c
new file mode 100644
index 0000000..9b3cd18
--- /dev/null
+++ b/src/parser/util.c
@@ -0,0 +1,35 @@
+#include "util.h"
+#include "../tokenlist.h"
+
+error_t *err_parse_no_match =
+    &(error_t){.message = "parsing failed to find the correct token sequence"};
+
+parse_result_t parse_error(error_t *err) {
+    return (parse_result_t){.err = err};
+}
+
+parse_result_t parse_no_match() {
+    return parse_error(err_parse_no_match);
+}
+
+parse_result_t parse_success(ast_node_t *ast, tokenlist_entry_t *next) {
+    next = tokenlist_skip_trivia(next);
+    return (parse_result_t){.node = ast, .next = next};
+}
+
+parse_result_t parse_token(tokenlist_entry_t *current,
+                           lexer_token_id_t token_id, node_id_t ast_id,
+                           token_validator_t is_valid) {
+    if (current->token.id != token_id ||
+        (is_valid && !is_valid(&current->token)))
+        return parse_no_match();
+
+    ast_node_t *node;
+    error_t *err = ast_node_alloc(&node);
+    if (err)
+        return parse_error(err);
+    node->id = ast_id;
+    node->token_entry = current;
+
+    return parse_success(node, current->next);
+}
diff --git a/src/parser/util.h b/src/parser/util.h
new file mode 100644
index 0000000..ee5a315
--- /dev/null
+++ b/src/parser/util.h
@@ -0,0 +1,25 @@
+#ifndef INCLUDE_PARSER_UTIL_H_
+#define INCLUDE_PARSER_UTIL_H_
+
+#include "../ast.h"
+#include "../error.h"
+#include "../tokenlist.h"
+
+typedef struct parse_result {
+    error_t *err;
+    tokenlist_entry_t *next;
+    ast_node_t *node;
+} parse_result_t;
+
+typedef bool (*token_validator_t)(lexer_token_t *);
+
+parse_result_t parse_error(error_t *err);
+parse_result_t parse_no_match();
+parse_result_t parse_success(ast_node_t *ast, tokenlist_entry_t *next);
+parse_result_t parse_token(tokenlist_entry_t *current,
+                           lexer_token_id_t token_id, node_id_t ast_id,
+                           token_validator_t is_valid);
+
+extern error_t *err_parse_no_match;
+
+#endif // INCLUDE_PARSER_UTIL_H_
-- 
2.47.2


From 44fa66c2b7c6e4c3b5a9d8832a6ecebf88217ec6 Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Tue, 1 Apr 2025 20:03:53 +0200
Subject: [PATCH 08/15] Add "primitive" parsers for all the non-trivia tokens
 in the lexer grammar

---
 src/parser/primitives.c | 100 ++++++++++++++++++++++++++++++++++++++++
 src/parser/primitives.h |  30 ++++++++++++
 2 files changed, 130 insertions(+)
 create mode 100644 src/parser/primitives.c
 create mode 100644 src/parser/primitives.h

diff --git a/src/parser/primitives.c b/src/parser/primitives.c
new file mode 100644
index 0000000..4c6ee79
--- /dev/null
+++ b/src/parser/primitives.c
@@ -0,0 +1,100 @@
+#include "primitives.h"
+#include "../ast.h"
+#include <string.h>
+
+parse_result_t parse_identifier(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_IDENTIFIER, NODE_IDENTIFIER, nullptr);
+}
+
+parse_result_t parse_decimal(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_DECIMAL, NODE_DECIMAL, nullptr);
+}
+
+parse_result_t parse_hexadecimal(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_HEXADECIMAL, NODE_HEXADECIMAL, nullptr);
+}
+
+parse_result_t parse_binary(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_BINARY, NODE_BINARY, nullptr);
+}
+
+parse_result_t parse_octal(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_OCTAL, NODE_OCTAL, nullptr);
+}
+
+parse_result_t parse_string(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_STRING, NODE_STRING, nullptr);
+}
+
+parse_result_t parse_char(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_CHAR, NODE_CHAR, nullptr);
+}
+
+parse_result_t parse_colon(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_COLON, NODE_COLON, nullptr);
+}
+
+parse_result_t parse_comma(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_COMMA, NODE_COMMA, nullptr);
+}
+
+parse_result_t parse_lbracket(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_LBRACKET, NODE_LBRACKET, nullptr);
+}
+
+parse_result_t parse_rbracket(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_RBRACKET, NODE_RBRACKET, nullptr);
+}
+
+parse_result_t parse_plus(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_PLUS, NODE_PLUS, nullptr);
+}
+
+parse_result_t parse_minus(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_MINUS, NODE_MINUS, nullptr);
+}
+
+parse_result_t parse_asterisk(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_ASTERISK, NODE_ASTERISK, nullptr);
+}
+
+parse_result_t parse_dot(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_DOT, NODE_DOT, nullptr);
+}
+
+parse_result_t parse_label_reference(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_IDENTIFIER, NODE_LABEL_REFERENCE,
+                       nullptr);
+}
+
+const char *registers[] = {
+    // 64-bit registers
+    "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", "r8", "r9", "r10",
+    "r11", "r12", "r13", "r14", "r15",
+    // 32-bit registers
+    "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", "r8d", "r9d",
+    "r10d", "r11d", "r12d", "r13d", "r14d", "r15d",
+    // 16-bit registers
+    "ax", "cx", "dx", "bx", "sp", "bp", "si", "di", "r8w", "r9w", "r10w",
+    "r11w", "r12w", "r13w", "r14w", "r15w",
+    // 8-bit low registers
+    "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil", "r8b", "r9b", "r10b",
+    "r11b", "r12b", "r13b", "r14b", "r15b", nullptr};
+
+bool is_register_token(lexer_token_t *token) {
+    for (size_t i = 0; registers[i] != nullptr; ++i)
+        if (strcmp(token->value, registers[i]) == 0)
+            return true;
+    return false;
+}
+
+parse_result_t parse_register(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_IDENTIFIER, NODE_REGISTER,
+                       is_register_token);
+}
+
+bool is_section_token(lexer_token_t *token) {
+    return strcmp(token->value, "section") == 0;
+}
+
+parse_result_t parse_section(tokenlist_entry_t *current) {}
diff --git a/src/parser/primitives.h b/src/parser/primitives.h
new file mode 100644
index 0000000..e6df83f
--- /dev/null
+++ b/src/parser/primitives.h
@@ -0,0 +1,30 @@
+#ifndef INCLUDE_PARSER_PRIMITIVES_H_
+#define INCLUDE_PARSER_PRIMITIVES_H_
+
+#include "util.h"
+
+parse_result_t parse_identifier(tokenlist_entry_t *current);
+parse_result_t parse_decimal(tokenlist_entry_t *current);
+parse_result_t parse_hexadecimal(tokenlist_entry_t *current);
+parse_result_t parse_binary(tokenlist_entry_t *current);
+parse_result_t parse_octal(tokenlist_entry_t *current);
+parse_result_t parse_string(tokenlist_entry_t *current);
+parse_result_t parse_char(tokenlist_entry_t *current);
+parse_result_t parse_colon(tokenlist_entry_t *current);
+parse_result_t parse_comma(tokenlist_entry_t *current);
+parse_result_t parse_lbracket(tokenlist_entry_t *current);
+parse_result_t parse_rbracket(tokenlist_entry_t *current);
+parse_result_t parse_plus(tokenlist_entry_t *current);
+parse_result_t parse_minus(tokenlist_entry_t *current);
+parse_result_t parse_asterisk(tokenlist_entry_t *current);
+parse_result_t parse_dot(tokenlist_entry_t *current);
+parse_result_t parse_label_reference(tokenlist_entry_t *current);
+
+/* These are "primitives" with a different name and some extra validation on top
+ * for example, register is just an identifier but it only matches a limited set
+ * of values
+ */
+parse_result_t parse_register(tokenlist_entry_t *current);
+parse_result_t parse_section(tokenlist_entry_t *current);
+
+#endif // INCLUDE_PARSER_PRIMITIVES_H_
-- 
2.47.2


From c66489dd9011ac3c24b940bc5cf40d4fb8485d23 Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Tue, 1 Apr 2025 20:05:35 +0200
Subject: [PATCH 09/15] Add basic parser combinators

---
 src/parser/combinators.c | 77 ++++++++++++++++++++++++++++++++++++++++
 src/parser/combinators.h | 21 +++++++++++
 2 files changed, 98 insertions(+)
 create mode 100644 src/parser/combinators.c
 create mode 100644 src/parser/combinators.h

diff --git a/src/parser/combinators.c b/src/parser/combinators.c
new file mode 100644
index 0000000..94c628a
--- /dev/null
+++ b/src/parser/combinators.c
@@ -0,0 +1,77 @@
+#include "combinators.h"
+
+parse_result_t parse_any(tokenlist_entry_t *current, parser_t parsers[]) {
+    parser_t parser;
+    while ((parser = *parsers++)) {
+        parse_result_t result = parser(current);
+        if (result.err == nullptr)
+            return result;
+    }
+    return parse_no_match();
+}
+
+// parse as many of the giver parsers objects in a row as possible, potentially
+// allowing none wraps the found objects in a new ast node with the given note
+// id
+parse_result_t parse_many(tokenlist_entry_t *current, node_id_t id,
+                          bool allow_none, parser_t parser) {
+    ast_node_t *many;
+    error_t *err = ast_node_alloc(&many);
+    parse_result_t result;
+    if (err)
+        return parse_error(err);
+    many->id = id;
+
+    while (current) {
+        result = parser(current);
+        if (result.err == err_parse_no_match)
+            break;
+        if (result.err) {
+            ast_node_free(many);
+            return result;
+        }
+        err = ast_node_add_child(many, result.node);
+        if (err) {
+            ast_node_free(many);
+            ast_node_free(result.node);
+            return parse_error(err);
+        }
+        current = result.next;
+    }
+
+    if (!allow_none && many->len == 0) {
+        ast_node_free(many);
+        return parse_no_match();
+    }
+    return parse_success(many, current);
+}
+
+// Parse all tries to parse all parsers consecutively and if it succeeds it
+// wraps the parsed nodes in a new parent node.
+parse_result_t parse_consecutive(tokenlist_entry_t *current, node_id_t id,
+                                 parser_t parsers[]) {
+    ast_node_t *all;
+    error_t *err = ast_node_alloc(&all);
+    parse_result_t result;
+    if (err)
+        return parse_error(err);
+
+    all->id = id;
+
+    parser_t parser;
+    while ((parser = *parsers++) && current) {
+        result = parser(current);
+        if (result.err) {
+            ast_node_free(all);
+            return result;
+        }
+        err = ast_node_add_child(all, result.node);
+        if (err) {
+            ast_node_free(result.node);
+            ast_node_free(all);
+            return parse_error(err);
+        }
+        current = result.next;
+    }
+    return parse_success(all, current);
+}
diff --git a/src/parser/combinators.h b/src/parser/combinators.h
new file mode 100644
index 0000000..ae40c7a
--- /dev/null
+++ b/src/parser/combinators.h
@@ -0,0 +1,21 @@
+#ifndef INCLUDE_PARSER_COMBINATORS_H_
+#define INCLUDE_PARSER_COMBINATORS_H_
+
+#include "util.h"
+
+typedef parse_result_t (*parser_t)(tokenlist_entry_t *);
+
+parse_result_t parse_any(tokenlist_entry_t *current, parser_t parsers[]);
+
+// parse as many of the giver parsers objects in a row as possible, potentially
+// allowing none wraps the found objects in a new ast node with the given note
+// id
+parse_result_t parse_many(tokenlist_entry_t *current, node_id_t id,
+                          bool allow_none, parser_t parser);
+
+// Parse all tries to parse all parsers consecutively and if it succeeds it
+// wraps the parsed nodes in a new parent node.
+parse_result_t parse_consecutive(tokenlist_entry_t *current, node_id_t id,
+                                 parser_t parsers[]);
+
+#endif // INCLUDE_PARSER_COMBINATORS_H_
-- 
2.47.2


From d424c0f886a52cfd2b393aefb5473c657840b2de Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Tue, 1 Apr 2025 23:39:48 +0200
Subject: [PATCH 10/15] Add a parser combinator to parse a delimited list

---
 src/parser/combinators.c | 55 +++++++++++++++++++++++++++++++++++++---
 src/parser/combinators.h |  4 +++
 2 files changed, 56 insertions(+), 3 deletions(-)

diff --git a/src/parser/combinators.c b/src/parser/combinators.c
index 94c628a..1c6cba7 100644
--- a/src/parser/combinators.c
+++ b/src/parser/combinators.c
@@ -1,5 +1,54 @@
 #include "combinators.h"
 
+// Parse a list of the given parser delimited by the given token id. Does not
+// store the delimiters in the parent node
+parse_result_t parse_list(tokenlist_entry_t *current, node_id_t id,
+                          bool allow_none, lexer_token_id_t delimiter_id,
+                          parser_t parser) {
+    ast_node_t *many;
+    error_t *err = ast_node_alloc(&many);
+    parse_result_t result;
+    if (err)
+        return parse_error(err);
+    many->id = id;
+
+    while (current) {
+        // Skip beyond the delimiter on all but the first iteration
+        if (many->len > 0) {
+            if (current->token.id != delimiter_id)
+                break;
+            current = tokenlist_next(current);
+            if (current == nullptr) {
+                // FIXME: this isn't quite right, we can't consume the delimiter
+                // if the next element will fail to parse but it's late and I
+                // must think this through tomorrow
+                break;
+            }
+        }
+
+        result = parser(current);
+        if (result.err == err_parse_no_match)
+            break;
+        if (result.err) {
+            ast_node_free(many);
+            return result;
+        }
+        err = ast_node_add_child(many, result.node);
+        if (err) {
+            ast_node_free(many);
+            ast_node_free(result.node);
+            return parse_error(err);
+        }
+        current = result.next;
+    }
+
+    if (!allow_none && many->len == 0) {
+        ast_node_free(many);
+        return parse_no_match();
+    }
+    return parse_success(many, current);
+}
+
 parse_result_t parse_any(tokenlist_entry_t *current, parser_t parsers[]) {
     parser_t parser;
     while ((parser = *parsers++)) {
@@ -10,9 +59,9 @@ parse_result_t parse_any(tokenlist_entry_t *current, parser_t parsers[]) {
     return parse_no_match();
 }
 
-// parse as many of the giver parsers objects in a row as possible, potentially
-// allowing none wraps the found objects in a new ast node with the given note
-// id
+// parse as many of the giver parsers objects in a row as possible,
+// potentially allowing none wraps the found objects in a new ast node with
+// the given note id
 parse_result_t parse_many(tokenlist_entry_t *current, node_id_t id,
                           bool allow_none, parser_t parser) {
     ast_node_t *many;
diff --git a/src/parser/combinators.h b/src/parser/combinators.h
index ae40c7a..1dd8855 100644
--- a/src/parser/combinators.h
+++ b/src/parser/combinators.h
@@ -13,6 +13,10 @@ parse_result_t parse_any(tokenlist_entry_t *current, parser_t parsers[]);
 parse_result_t parse_many(tokenlist_entry_t *current, node_id_t id,
                           bool allow_none, parser_t parser);
 
+parse_result_t parse_list(tokenlist_entry_t *current, node_id_t id,
+                          bool allow_none, lexer_token_id_t delimiter_id,
+                          parser_t parser);
+
 // Parse all tries to parse all parsers consecutively and if it succeeds it
 // wraps the parsed nodes in a new parent node.
 parse_result_t parse_consecutive(tokenlist_entry_t *current, node_id_t id,
-- 
2.47.2


From 6ca7bb3661299c3d76af034f13b6a92d2bb9d7ad Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Tue, 1 Apr 2025 23:36:08 +0200
Subject: [PATCH 11/15] Fix incorrect size comparison in lexer_consume_n

The buffer length len and the requested number of tokens n are mixed up
in an invalid comparison. This causes all valid requests for n < len
tokens to be denied and all invalid requests for n > len tokens to be
accepted. This may cause a buffer overflow if the caller requests more
characters than they provide space for.
---
 src/lexer.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/lexer.c b/src/lexer.c
index 08a96bd..27aef0c 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -183,7 +183,7 @@ error_t *lexer_consume_n(lexer_t *lex, const size_t len,
                          char buffer[static len], const size_t n) {
     if (lex->buffer_count < n)
         return err_buffer_underrun;
-    if (len > n)
+    if (n > len)
         return err_consume_excessive_length;
 
     memcpy(buffer, lex->buffer, n);
-- 
2.47.2


From b70b6896bf25702bd1e9bd58e4cb63b5ff9db1fe Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Tue, 1 Apr 2025 17:16:21 +0200
Subject: [PATCH 12/15] Partial parser implementation

---
 src/parser/parser.c     | 138 ++++++++++++++++++++++++++++++++++++++++
 src/parser/parser.h     |   9 +++
 src/parser/primitives.c |   5 +-
 3 files changed, 151 insertions(+), 1 deletion(-)
 create mode 100644 src/parser/parser.c
 create mode 100644 src/parser/parser.h

diff --git a/src/parser/parser.c b/src/parser/parser.c
new file mode 100644
index 0000000..a92a2c3
--- /dev/null
+++ b/src/parser/parser.c
@@ -0,0 +1,138 @@
+#include "parser.h"
+#include "../ast.h"
+#include "../lexer.h"
+#include "../tokenlist.h"
+#include "combinators.h"
+#include "primitives.h"
+#include "util.h"
+
+parse_result_t parse_number(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_octal, parse_decimal, parse_hexadecimal,
+                          parse_binary, nullptr};
+    return parse_any(current, parsers);
+}
+
+parse_result_t parse_plus_or_minus(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_plus, parse_minus, nullptr};
+    return parse_any(current, parsers);
+}
+
+parse_result_t parse_register_index(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_plus, parse_register, parse_asterisk,
+                          parse_number, nullptr};
+    return parse_consecutive(current, NODE_REGISTER_INDEX, parsers);
+}
+
+parse_result_t parse_register_offset(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_plus_or_minus, parse_number, nullptr};
+    return parse_consecutive(current, NODE_REGISTER_OFFSET, parsers);
+}
+
+parse_result_t parse_register_expression(tokenlist_entry_t *current) {
+    parse_result_t result;
+
+    ast_node_t *expr;
+    error_t *err = ast_node_alloc(&expr);
+    if (err)
+        return parse_error(err);
+    expr->id = NODE_REGISTER_EXPRESSION;
+
+    // <register>
+    result = parse_register(current);
+    if (result.err) {
+        ast_node_free(expr);
+        return result;
+    }
+    err = ast_node_add_child(expr, result.node);
+    if (err) {
+        ast_node_free(result.node);
+        ast_node_free(expr);
+        return parse_error(err);
+    }
+    current = result.next;
+
+    // <register_index>?
+    result = parse_register_index(current);
+    if (result.err) {
+        error_free(result.err);
+    } else {
+        err = ast_node_add_child(expr, result.node);
+        if (err) {
+            ast_node_free(result.node);
+            ast_node_free(expr);
+            return parse_error(err);
+        }
+        current = result.next;
+    }
+
+    // <register_offset>?
+    result = parse_register_offset(current);
+    if (result.err) {
+        error_free(result.err);
+    } else {
+        err = ast_node_add_child(expr, result.node);
+        if (err) {
+            ast_node_free(result.node);
+            ast_node_free(expr);
+            return parse_error(err);
+        }
+        current = result.next;
+    }
+    return parse_success(expr, current);
+}
+
+parse_result_t parse_immediate(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_number, parse_identifier, nullptr};
+    return parse_any(current, parsers);
+}
+
+parse_result_t parse_memory_expression(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_register_expression, parse_identifier, nullptr};
+    return parse_any(current, parsers);
+}
+
+parse_result_t parse_memory(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_lbracket, parse_memory_expression,
+                          parse_rbracket, nullptr};
+    return parse_consecutive(current, NODE_MEMORY, parsers);
+}
+
+parse_result_t parse_operand(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_register, parse_memory, parse_immediate,
+                          nullptr};
+    return parse_any(current, parsers);
+}
+
+parse_result_t parse_operands(tokenlist_entry_t *current) {
+    return parse_list(current, NODE_OPERANDS, true, TOKEN_COMMA, parse_operand);
+}
+
+parse_result_t parse_label(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_identifier, parse_colon, nullptr};
+    return parse_consecutive(current, NODE_LABEL, parsers);
+}
+
+parse_result_t parse_section_directive(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_section, parse_identifier, nullptr};
+    return parse_consecutive(current, NODE_SECTION_DIRECTIVE, parsers);
+}
+
+parse_result_t parse_directive(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_dot, parse_section_directive, nullptr};
+    return parse_consecutive(current, NODE_DIRECTIVE, parsers);
+}
+
+parse_result_t parse_instruction(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_identifier, parse_operands, nullptr};
+    return parse_consecutive(current, NODE_INSTRUCTION, parsers);
+}
+
+parse_result_t parse_statement(tokenlist_entry_t *current) {
+    parser_t parsers[] = {parse_label, parse_directive, parse_instruction,
+                          nullptr};
+    return parse_any(current, parsers);
+}
+
+parse_result_t parse(tokenlist_entry_t *current) {
+    return parse_many(current, NODE_PROGRAM, true, parse_statement);
+}
diff --git a/src/parser/parser.h b/src/parser/parser.h
new file mode 100644
index 0000000..c59620c
--- /dev/null
+++ b/src/parser/parser.h
@@ -0,0 +1,9 @@
+#ifndef INCLUDE_PARSER_PARSER_H_
+#define INCLUDE_PARSER_PARSER_H_
+
+#include "../tokenlist.h"
+#include "util.h"
+
+parse_result_t parse(tokenlist_entry_t *current);
+
+#endif // INCLUDE_PARSER_PARSER_H_
diff --git a/src/parser/primitives.c b/src/parser/primitives.c
index 4c6ee79..7e89aa9 100644
--- a/src/parser/primitives.c
+++ b/src/parser/primitives.c
@@ -97,4 +97,7 @@ bool is_section_token(lexer_token_t *token) {
     return strcmp(token->value, "section") == 0;
 }
 
-parse_result_t parse_section(tokenlist_entry_t *current) {}
+parse_result_t parse_section(tokenlist_entry_t *current) {
+    return parse_token(current, TOKEN_IDENTIFIER, NODE_SECTION,
+                       is_section_token);
+}
-- 
2.47.2


From b4757e008ca7ac640c2da23b55b9a1c376d9e2b9 Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Wed, 2 Apr 2025 20:33:36 +0200
Subject: [PATCH 13/15] Add parse_result_wrap to wrap a result with another
 parent node

Use the new wrap function to wrap numbers and immediate nodes
---
 src/parser/parser.c |  6 ++++--
 src/parser/util.c   | 21 +++++++++++++++++++++
 src/parser/util.h   |  1 +
 3 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/src/parser/parser.c b/src/parser/parser.c
index a92a2c3..0476666 100644
--- a/src/parser/parser.c
+++ b/src/parser/parser.c
@@ -9,7 +9,8 @@
 parse_result_t parse_number(tokenlist_entry_t *current) {
     parser_t parsers[] = {parse_octal, parse_decimal, parse_hexadecimal,
                           parse_binary, nullptr};
-    return parse_any(current, parsers);
+    parse_result_t result = parse_any(current, parsers);
+    return parse_result_wrap(NODE_NUMBER, result);
 }
 
 parse_result_t parse_plus_or_minus(tokenlist_entry_t *current) {
@@ -83,7 +84,8 @@ parse_result_t parse_register_expression(tokenlist_entry_t *current) {
 
 parse_result_t parse_immediate(tokenlist_entry_t *current) {
     parser_t parsers[] = {parse_number, parse_identifier, nullptr};
-    return parse_any(current, parsers);
+    parse_result_t result = parse_any(current, parsers);
+    return parse_result_wrap(NODE_IMMEDIATE, result);
 }
 
 parse_result_t parse_memory_expression(tokenlist_entry_t *current) {
diff --git a/src/parser/util.c b/src/parser/util.c
index 9b3cd18..09741b2 100644
--- a/src/parser/util.c
+++ b/src/parser/util.c
@@ -33,3 +33,24 @@ parse_result_t parse_token(tokenlist_entry_t *current,
 
     return parse_success(node, current->next);
 }
+
+parse_result_t parse_result_wrap(node_id_t id, parse_result_t result) {
+    if (result.err)
+        return result;
+
+    ast_node_t *node;
+    error_t *err = ast_node_alloc(&node);
+    if (err) {
+        ast_node_free(result.node);
+        return parse_error(err);
+    }
+    node->id = id;
+
+    err = ast_node_add_child(node, result.node);
+    if (err) {
+        ast_node_free(result.node);
+        return parse_error(err);
+    }
+
+    return parse_success(node, result.next);
+}
diff --git a/src/parser/util.h b/src/parser/util.h
index ee5a315..5c074b0 100644
--- a/src/parser/util.h
+++ b/src/parser/util.h
@@ -19,6 +19,7 @@ parse_result_t parse_success(ast_node_t *ast, tokenlist_entry_t *next);
 parse_result_t parse_token(tokenlist_entry_t *current,
                            lexer_token_id_t token_id, node_id_t ast_id,
                            token_validator_t is_valid);
+parse_result_t parse_result_wrap(node_id_t id, parse_result_t result);
 
 extern error_t *err_parse_no_match;
 
-- 
2.47.2


From 5ea942024fec917d0fbfe247d25e06abd4c3e1d3 Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Tue, 1 Apr 2025 15:03:36 +0200
Subject: [PATCH 14/15] add functionality to main to parse and print the ast

---
 Makefile    |  2 +-
 src/main.c  | 90 +++++++++++++++++++++++++++++++++++++----------------
 validate.sh |  2 +-
 3 files changed, 65 insertions(+), 29 deletions(-)

diff --git a/Makefile b/Makefile
index e567b37..d685209 100644
--- a/Makefile
+++ b/Makefile
@@ -10,7 +10,7 @@ OBJECTS = $(SOURCES:.c=.o)
 DEPENDENCIES = $(SOURCES:.c=.d)
 TARGET?=oas
 OUTPUTS=oas oas-asan oas-msan oas-afl
-RUNARGUMENTS?=-tokens tests/input/valid.asm
+RUNARGUMENTS?=ast tests/input/valid.asm
 
 all: $(TARGET)
 	
diff --git a/src/main.c b/src/main.c
index d74d710..7b09662 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,5 +1,6 @@
 #include "error.h"
 #include "lexer.h"
+#include "parser/parser.h"
 #include "tokenlist.h"
 
 #include <limits.h>
@@ -7,38 +8,64 @@
 #include <stdlib.h>
 #include <string.h>
 
-bool print_token(lexer_token_t *token) {
-    lexer_token_print(token);
-    return true;
+typedef enum mode { MODE_AST, MODE_TEXT, MODE_TOKENS } mode_t;
+
+void print_tokens(tokenlist_t *list) {
+    for (auto entry = list->head; entry; entry = entry->next) {
+        auto token = &entry->token;
+        lexer_token_print(token);
+    }
 }
 
-bool print_value(lexer_token_t *token) {
-    if (token->id == TOKEN_ERROR) {
-        printf("%s\n", token->value);
-        for (size_t i = 0; i < token->character_number; ++i)
-            printf(" ");
-        printf("^-- %s\n", token->explanation);
-    } else {
-        printf("%s", token->value);
+void print_text(tokenlist_t *list) {
+    for (auto entry = list->head; entry; entry = entry->next) {
+        auto token = &entry->token;
+        if (token->id == TOKEN_ERROR) {
+            printf("%s\n", token->value);
+            for (size_t i = 0; i < token->character_number; ++i)
+                printf(" ");
+            printf("^-- %s\n", token->explanation);
+            return;
+        } else {
+            printf("%s", token->value);
+        }
     }
-    return token->id != TOKEN_ERROR;
+}
+
+void print_ast(tokenlist_t *list) {
+    parse_result_t result = parse(list->head);
+    if (result.err) {
+        puts(result.err->message);
+        error_free(result.err);
+        return;
+    }
+    ast_node_print(result.node);
+
+    if (result.next != nullptr) {
+        puts("First unparsed token:");
+        lexer_token_print(&result.next->token);
+    }
+
+    ast_node_free(result.node);
+}
+
+int get_execution_mode(int argc, char *argv[]) {
+    if (argc != 3 || (strcmp(argv[1], "tokens") != 0 &&
+                      strcmp(argv[1], "text") != 0 && strcmp(argv[1], "ast"))) {
+        puts("Usage: oas [tokens|text|ast] <filename>");
+        exit(1);
+    }
+
+    if (strcmp(argv[1], "tokens") == 0)
+        return MODE_TOKENS;
+    if (strcmp(argv[1], "text") == 0)
+        return MODE_TEXT;
+    return MODE_AST;
 }
 
 int main(int argc, char *argv[]) {
-    if (argc != 3 ||
-        (strcmp(argv[1], "-tokens") != 0 && strcmp(argv[1], "-text") != 0)) {
-        puts("Usage: oas -tokens <filename>");
-        puts("Usage: oas -text <filename>");
-        return 1;
-    }
-
-    bool (*print_fn)(lexer_token_t *);
+    mode_t mode = get_execution_mode(argc, argv);
     char *filename = argv[2];
-    if (strcmp(argv[1], "-tokens") == 0) {
-        print_fn = print_token;
-    } else {
-        print_fn = print_value;
-    }
 
     lexer_t *lex = &(lexer_t){};
     error_t *err = lexer_open(lex, filename);
@@ -54,9 +81,18 @@ int main(int argc, char *argv[]) {
     if (err)
         goto cleanup_tokens;
 
-    for (auto entry = list->head; entry; entry = entry->next) {
-        print_fn(&entry->token);
+    switch (mode) {
+    case MODE_TOKENS:
+        print_tokens(list);
+        break;
+    case MODE_TEXT:
+        print_text(list);
+        break;
+    case MODE_AST:
+        print_ast(list);
+        break;
     }
+
     tokenlist_free(list);
     error_free(err);
     return 0;
diff --git a/validate.sh b/validate.sh
index 10c2142..33313da 100755
--- a/validate.sh
+++ b/validate.sh
@@ -10,7 +10,7 @@ scan-build -o reports/static-analysis/ -plist-html --status-bugs make all
 # Run the sanitizer builds and valgrind
 make clean sanitize all
 
-ARGUMENTS=("-tokens" "-text")
+ARGUMENTS=("tokens" "text" "ast")
 while IFS= read -r INPUT_FILE; do
     for ARGS in ${ARGUMENTS[@]}; do
         ./oas-asan $ARGS $INPUT_FILE > /dev/null
-- 
2.47.2


From 0d3881f680353e895681f6bebe65ea273140310c Mon Sep 17 00:00:00 2001
From: omicron <omicron.me@protonmail.com>
Date: Wed, 2 Apr 2025 11:19:35 +0200
Subject: [PATCH 15/15] Update the test input file to contain all AST nodes

---
 tests/input/valid.asm | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/tests/input/valid.asm b/tests/input/valid.asm
index de95bbe..274b656 100644
--- a/tests/input/valid.asm
+++ b/tests/input/valid.asm
@@ -1,5 +1,17 @@
+.section text
+
+; Small valid code snippet that should contain all different AST nodes
+
 _start:
-    mov eax, 555            ; move 555 into eax
+    mov eax, ebx
+    lea eax, [eax + ebx * 4 + 8]
+    lea eax, [eax + 8]
+    lea eax, [eax + ebx * 8]
+    lea eax, [esp - 24]
+    lea eax, [eax + ebx * 4 - 8]
+    lea eax, [_start]
+    mov eax, _start
+    mov eax, 555
     push 0o777
     xor eax, 0xDEADBEEF
     and ecx, 0o770
-- 
2.47.2