change over to a linked list system and start trying to fix bug which causes the parser to not output anything meaningful due to memory deallocation

src/lexer/lex.l

@@ -18,95 +18,318 @@ int yywrap(void *) {
 
 (\"(\\[a-z\"'`]|[^\\"])*\") {
     GET_STATE
-    add_token(TOKENS,TOKEN_STRING, yytext, LINE_NO, COLUMN_NO);
+    Token * token = create_token(
+        TOKEN_STRING,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    );
+    append(TOKENS, token);
     ADD_TO_COLUMN
 }
 
 ('((\\([a-z'\"`]))|[^'])*') {
     GET_STATE
-    add_token(TOKENS,TOKEN_STRING, yytext, LINE_NO, COLUMN_NO);
+    append(TOKENS, create_token(
+        TOKEN_STRING,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    ));
     ADD_TO_COLUMN
 }
 
 ((([0-9]+(\.[0-9]+)?)|(\.[0-9]+))(e((\-|\+)?([0-9]+(\.[0-9]+)?)))?) {
     GET_STATE
-    add_token(TOKENS,TOKEN_NUMBER, yytext, LINE_NO, COLUMN_NO);
+    append(TOKENS, create_token(
+        TOKEN_NUMBER,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    ));
     ADD_TO_COLUMN
 }
 
 ([0-9]+\/[0-9]+) {
     GET_STATE
-    add_token(TOKENS,TOKEN_FRACTION, yytext, LINE_NO, COLUMN_NO);
+    append(TOKENS, create_token(
+        TOKEN_FRACTION,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    ));
     ADD_TO_COLUMN
 }
 
-"not"[ \t]+"in"     { GET_STATE; add_token(TOKENS,TOKEN_NOT_IN, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+"not"[ \t]+"in"     { GET_STATE; append(TOKENS, create_token(TOKEN_NOT_IN,
-"&&"                { GET_STATE; add_token(TOKENS,TOKEN_AND, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        LINE_NO,
-"||"                { GET_STATE; add_token(TOKENS,TOKEN_OR, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        COLUMN_NO,
-"<="                { GET_STATE; add_token(TOKENS,TOKEN_LE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        yytext
-">="                { GET_STATE; add_token(TOKENS,TOKEN_GE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+    ));
-"!="                { GET_STATE; add_token(TOKENS,TOKEN_NE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+    append(TOKENS, create_token(
-"=="                { GET_STATE; add_token(TOKENS,TOKEN_EQ, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        TOKEN_NOT_IN,
-"="                 { GET_STATE; add_token(TOKENS,TOKEN_ASSIGN, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        LINE_NO,
-"//"                { GET_STATE; add_token(TOKENS,TOKEN_FLOORDIV, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        COLUMN_NO,
-"<"                 { GET_STATE; add_token(TOKENS,TOKEN_LT, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        yytext
-">"                 { GET_STATE; add_token(TOKENS,TOKEN_GT, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+    )); ADD_TO_COLUMN; }
-"+"                 { GET_STATE; add_token(TOKENS,TOKEN_PLUS, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+"&&"                { GET_STATE; append(TOKENS, create_token(TOKEN_AND,
-"-"                 { GET_STATE; add_token(TOKENS,TOKEN_MINUS, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        LINE_NO,
-"%"                 { GET_STATE; add_token(TOKENS,TOKEN_MODULO, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        COLUMN_NO,
-"*"                 { GET_STATE; add_token(TOKENS,TOKEN_STAR, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        yytext
-"/"                 { GET_STATE; add_token(TOKENS,TOKEN_SLASH, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+    )); ADD_TO_COLUMN; }
-"^"                 { GET_STATE; add_token(TOKENS,TOKEN_CARET, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+"||"                { GET_STATE; append(TOKENS, create_token(TOKEN_OR,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"<="                { GET_STATE; append(TOKENS, create_token(TOKEN_LE,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+">="                { GET_STATE; append(TOKENS, create_token(TOKEN_GE,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"!="                { GET_STATE; append(TOKENS, create_token(TOKEN_NE,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"=="                { GET_STATE; append(TOKENS, create_token(TOKEN_EQ,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"="                 { GET_STATE; append(TOKENS, create_token(TOKEN_ASSIGN,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"//"                { GET_STATE; append(TOKENS, create_token(TOKEN_FLOORDIV,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"<"                 { GET_STATE; append(TOKENS, create_token(TOKEN_LT,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+">"                 { GET_STATE; append(TOKENS, create_token(TOKEN_GT,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"+"                 { GET_STATE; append(TOKENS, create_token(TOKEN_PLUS,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"-"                 { GET_STATE; append(TOKENS, create_token(TOKEN_MINUS,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"%"                 { GET_STATE; append(TOKENS, create_token(TOKEN_MODULO,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"*"                 { GET_STATE; append(TOKENS, create_token(TOKEN_STAR,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"/"                 { GET_STATE; append(TOKENS, create_token(TOKEN_SLASH,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"^"                 { GET_STATE; append(TOKENS, create_token(TOKEN_CARET,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
 
 
-"if"                { GET_STATE; add_token(TOKENS,TOKEN_IF, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+"if"                { GET_STATE; append(TOKENS, create_token(TOKEN_IF,
-"else"              { GET_STATE; add_token(TOKENS,TOKEN_ELSE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        LINE_NO,
-"while"             { GET_STATE; add_token(TOKENS,TOKEN_WHILE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        COLUMN_NO,
-"forever"           { GET_STATE; add_token(TOKENS,TOKEN_FOREVER, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        yytext
-"for"               { GET_STATE; add_token(TOKENS,TOKEN_FOR, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+    )); ADD_TO_COLUMN; }
-"break"             { GET_STATE; add_token(TOKENS,TOKEN_BREAK, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+"else"              { GET_STATE; append(TOKENS, create_token(TOKEN_ELSE,
-"continue"          { GET_STATE; add_token(TOKENS,TOKEN_CONTINUE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        LINE_NO,
-"return"            { GET_STATE; add_token(TOKENS,TOKEN_RETURN, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        COLUMN_NO,
-"let"               { GET_STATE; add_token(TOKENS,TOKEN_LET, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        yytext
-"import"            { GET_STATE; add_token(TOKENS,TOKEN_IMPORT, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+    )); ADD_TO_COLUMN; }
-"from"              { GET_STATE; add_token(TOKENS,TOKEN_FROM, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+"while"             { GET_STATE; append(TOKENS, create_token(TOKEN_WHILE,
-"do"                { GET_STATE; add_token(TOKENS,TOKEN_DO, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        LINE_NO,
-"true"              { GET_STATE; add_token(TOKENS,TOKEN_TRUE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        COLUMN_NO,
-"false"             { GET_STATE; add_token(TOKENS,TOKEN_FALSE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        yytext
-"null"              { GET_STATE; add_token(TOKENS,TOKEN_NULL, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+    )); ADD_TO_COLUMN; }
-"delete"            { GET_STATE; add_token(TOKENS,TOKEN_DELETE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+"forever"           { GET_STATE; append(TOKENS, create_token(TOKEN_FOREVER,
-"not"               { GET_STATE; add_token(TOKENS,TOKEN_NOT, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        LINE_NO,
-"in"                { GET_STATE; add_token(TOKENS,TOKEN_IN, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        COLUMN_NO,
-"try"               { GET_STATE; add_token(TOKENS,TOKEN_TRY, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        yytext
-"catch"             { GET_STATE; add_token(TOKENS,TOKEN_CATCH, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+    )); ADD_TO_COLUMN; }
+"for"               { GET_STATE; append(TOKENS, create_token(TOKEN_FOR,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"break"             { GET_STATE; append(TOKENS, create_token(TOKEN_BREAK,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"continue"          { GET_STATE; append(TOKENS, create_token(TOKEN_CONTINUE,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"return"            { GET_STATE; append(TOKENS, create_token(TOKEN_RETURN,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"let"               { GET_STATE; append(TOKENS, create_token(TOKEN_LET,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"import"            { GET_STATE; append(TOKENS, create_token(TOKEN_IMPORT,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"from"              { GET_STATE; append(TOKENS, create_token(TOKEN_FROM,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"do"                { GET_STATE; append(TOKENS, create_token(TOKEN_DO,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"true"              { GET_STATE; append(TOKENS, create_token(TOKEN_TRUE,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"false"             { GET_STATE; append(TOKENS, create_token(TOKEN_FALSE,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"null"              { GET_STATE; append(TOKENS, create_token(TOKEN_NULL,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"delete"            { GET_STATE; append(TOKENS, create_token(TOKEN_DELETE,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"not"               { GET_STATE; append(TOKENS, create_token(TOKEN_NOT,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"in"                { GET_STATE; append(TOKENS, create_token(TOKEN_IN,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"try"               { GET_STATE; append(TOKENS, create_token(TOKEN_TRY,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"catch"             { GET_STATE; append(TOKENS, create_token(TOKEN_CATCH,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
 
-"("                 { GET_STATE; add_token(TOKENS,TOKEN_LPAREN, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+"("                 { GET_STATE; append(TOKENS, create_token(TOKEN_LPAREN,
-")"                 { GET_STATE; add_token(TOKENS,TOKEN_RPAREN, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        LINE_NO,
-"["                 { GET_STATE; add_token(TOKENS,TOKEN_LBRACKET, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        COLUMN_NO,
-"]"                 { GET_STATE; add_token(TOKENS,TOKEN_RBRACKET, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+        yytext
-"{"                 { GET_STATE; add_token(TOKENS,TOKEN_LBRACE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+    )); ADD_TO_COLUMN; }
-"}"                 { GET_STATE; add_token(TOKENS,TOKEN_RBRACE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
+")"                 { GET_STATE; append(TOKENS, create_token(TOKEN_RPAREN,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"["                 { GET_STATE; append(TOKENS, create_token(TOKEN_LBRACKET,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"]"                 { GET_STATE; append(TOKENS, create_token(TOKEN_RBRACKET,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"{"                 { GET_STATE; append(TOKENS, create_token(TOKEN_LBRACE,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
+"}"                 { GET_STATE; append(TOKENS, create_token(TOKEN_RBRACE,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    )); ADD_TO_COLUMN; }
 
 [a-zA-Z_][a-zA-Z0-9_]* {
     GET_STATE
-    add_token(TOKENS,TOKEN_IDENTIFIER, yytext, LINE_NO, COLUMN_NO);
+    append(TOKENS, create_token(TOKEN_IDENTIFIER,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    ));
     ADD_TO_COLUMN
 }
 
-"." {GET_STATE;add_token(TOKENS,TOKEN_DOT, yytext, LINE_NO, COLUMN_NO);ADD_TO_COLUMN}
+"." {GET_STATE;append(TOKENS, create_token(TOKEN_DOT,
-"," {GET_STATE;add_token(TOKENS,TOKEN_COMMA, yytext, LINE_NO, COLUMN_NO);ADD_TO_COLUMN}
+        LINE_NO,
-":" {GET_STATE;add_token(TOKENS,TOKEN_COLON, yytext, LINE_NO, COLUMN_NO);ADD_TO_COLUMN}
+        COLUMN_NO,
+        yytext
+    ));ADD_TO_COLUMN}
+"," {GET_STATE;append(TOKENS, create_token(TOKEN_COMMA,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    ));ADD_TO_COLUMN}
+":" {GET_STATE;append(TOKENS, create_token(TOKEN_COLON,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    ));ADD_TO_COLUMN}
 
 \n {
     GET_STATE
-    add_token(TOKENS,TOKEN_NEW_LINE, yytext, LINE_NO, COLUMN_NO);
+    append(TOKENS, create_token(TOKEN_NEW_LINE,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    ));
     COLUMN_NO = 1;
 }
 
 [ \t]+ {
     GET_STATE
     if (COLUMN_NO == 1){
-        add_token(TOKENS,TOKEN_INDENT, yytext, LINE_NO, COLUMN_NO);
+        append(TOKENS, create_token(TOKEN_INDENT,
+        LINE_NO,
+        COLUMN_NO,
+        yytext
+    ));
     }
     ADD_TO_COLUMN  // Advance column for whitespace
 }

src/lexer/lexer.h

@@ -1,10 +1,11 @@
 #include "token.h"
+#include "../list/list.h"
 
 typedef struct {
     const char *path;
     const char *content;
     int current_column;
-    TokenStruct* tokens;
+    LinkedList* tokens;
     // add more fields as needed
 } LexerState;
 

src/lexer/token.c

@@ -1,47 +1,13 @@
-#include <stdlib.h>
-#include <string.h>
 #include "token.h"
+#include <stdio.h>
+#include <stdlib.h>
 
-#define INITIAL_CAPACITY 64
+Token *create_token(TokenType type, int line, int column, char *value) {
-
+    Token * token = malloc(sizeof(Token));
-
+    printf("%s\n", value);
-TokenStruct* init_token() {
+    token->type = type;
-    TokenStruct *tokenStruct = malloc(sizeof(TokenStruct));
+    token->line=line;
-    if (tokenStruct == NULL) {
+    token->column=column;
-        // handle malloc failure
+    token->value=value;
-        return NULL;
+    return token;
-    }
-    tokenStruct->count = 0;
-    tokenStruct->capacity = INITIAL_CAPACITY;
-    tokenStruct->tokens = malloc(sizeof(Token) * INITIAL_CAPACITY);
-    if (tokenStruct->tokens == NULL) {
-        // handle malloc failure
-        free(tokenStruct);
-        return NULL;
-    }
-    return tokenStruct;
-}
-
-void add_token(TokenStruct* token,TokenType type, const char* value, int line, int column) {
-    if (token->count >= token->capacity) {
-        token->capacity *= 2;
-        token->tokens = realloc(token->tokens, sizeof(Token) * token->capacity);
-    }
-
-    token->tokens[token->count].type = type;
-    token->tokens[token->count].value = strdup(value);
-    token->tokens[token->count].line = line;
-    token->tokens[token->count].column = column;
-    token->count++;
-}
-
-void free_tokens(TokenStruct* token) {
-    for (int i = 0; i < token->count; ++i) {
-        free(token->tokens[i].value);
-    }
-    free(token->tokens);
-    token->tokens = NULL;
-    token->count = 0;
-    token->capacity = 0;
-    free(token);
 }

src/lexer/token.h

@@ -71,17 +71,5 @@ typedef struct {
   char *value;
 } Token;
 
-typedef struct {
+Token *create_token(TokenType type, int line, int column, char *value);
-  int count;
-  int capacity;
-  Token *tokens;
-} TokenStruct;
-
-TokenStruct *init_token();
-
-void add_token(TokenStruct *token, TokenType type, const char *value, int line,
-               int column);
-
-void free_tokens(TokenStruct *token);
-
 #endif

src/list/list.c

@@ -0,0 +1,94 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "list.h"
+
+LinkedList *create_list(size_t data_size) {
+    LinkedList *list = malloc(sizeof(LinkedList));
+    list->head = NULL;
+    list->data_size = data_size;
+    list->length = 0;
+    return list;
+}
+
+void append(LinkedList *list, void *element) {
+    Node *new_node = malloc(sizeof(Node));
+    new_node->data = malloc(list->data_size);
+    memcpy(new_node->data, element, list->data_size);
+    new_node->next = NULL;
+
+    if (!list->head) {
+        list->head = new_node;
+    } else {
+        Node *temp = list->head;
+        while (temp->next) temp = temp->next;
+        temp->next = new_node;
+    }
+    list->length++;
+}
+
+void *get_element_at(LinkedList *list, size_t index) {
+    if (index >= list->length) return NULL;
+
+    Node *current = list->head;
+    for (size_t i = 0; i < index; ++i)
+        current = current->next;
+
+    return current->data;
+}
+
+int set_element_at(LinkedList *list, size_t index, void *element) {
+    if (index >= list->length) return 0;
+
+    Node *current = list->head;
+    for (size_t i = 0; i < index; ++i)
+        current = current->next;
+
+    memcpy(current->data, element, list->data_size);
+    return 1;
+}
+
+int remove_at(LinkedList *list, size_t index) {
+    if (index >= list->length) return 0;
+
+    Node *temp = list->head;
+    Node *prev = NULL;
+
+    for (size_t i = 0; i < index; ++i) {
+        prev = temp;
+        temp = temp->next;
+    }
+
+    if (prev)
+        prev->next = temp->next;
+    else
+        list->head = temp->next;
+
+    free(temp->data);
+    free(temp);
+    list->length--;
+    return 1;
+}
+
+size_t list_length(LinkedList *list) {
+    return list->length;
+}
+
+void print_list(LinkedList *list, void (*print_func)(void *)) {
+    Node *current = list->head;
+    while (current) {
+        print_func(current->data);
+        current = current->next;
+    }
+}
+
+void free_list(LinkedList *list) {
+    Node *current = list->head;
+    while (current) {
+        Node *next = current->next;
+        free(current->data);
+        free(current);
+        current = next;
+    }
+    free(list);
+}

src/list/list.h

@@ -0,0 +1,42 @@
+#ifndef LINKEDLIST_H
+#define LINKEDLIST_H
+
+#include <stddef.h> // for size_t
+
+// Node structure (opaque to user)
+typedef struct Node {
+    void *data;
+    struct Node *next;
+} Node;
+
+typedef struct LinkedList {
+    Node *head;
+    size_t data_size;
+    size_t length;
+} LinkedList;
+
+// Create a new list for the given data type size
+LinkedList *create_list(size_t data_size);
+
+// Append an element to the list
+void append(LinkedList *list, void *element);
+
+// Get a pointer to the element at the given index
+void *get_element_at(LinkedList *list, size_t index);
+
+// Set the element at the given index
+int set_element_at(LinkedList *list, size_t index, void *element);
+
+// Remove the element at the given index
+int remove_at(LinkedList *list, size_t index);
+
+// Get the number of elements in the list
+size_t list_length(LinkedList *list);
+
+// Print the list using a provided print function
+void print_list(LinkedList *list, void (*print_func)(void *));
+
+// Free all memory used by the list
+void free_list(LinkedList *list);
+
+#endif // LINKEDLIST_H

src/main.c

@@ -1,4 +1,5 @@
 #include "lexer/lexer.h"
+#include "lexer/token.h"
 #include "parser/parser.h"
 
 #include <stdbool.h>
@@ -37,22 +38,28 @@ int main() {
     const char * path = "test.ar";
 
     char *content = read_file_as_text(path);
-    TokenStruct* tokenStruct = init_token();
+    LinkedList* tokens = create_list(sizeof(Token));
     if (!content) return 1;
 
     LexerState state = {
         path,
         content,
         1,
-        tokenStruct
+        tokens
     };
     lexer(state);
+
+    LinkedList * parsed = create_list(sizeof(TaggedValue));
+
+    parser(parsed, tokens, false);
+    free_list(tokens);
     free(content);
 
-    TaggedValueStruct taggedValueStruct = init_TaggedValueStruct();
+    Node *current = parsed->head;
+    while (current) {
+        printf("%s\n", (char*)current->data);
+        current = current->next;
+    }
 
-    parser(&taggedValueStruct, tokenStruct, false);
-
-    free_tokens(tokenStruct);
     return 0;
 }

src/parser/parser.c

@@ -1,20 +1,23 @@
 #include "parser.h"
+#include <stddef.h>
 
-TaggedValue parse_token(TokenStruct * tokenStruct, int *index) {
+TaggedValue parse_token(LinkedList * tokens, size_t *index) {
-  Token token = tokenStruct->tokens[*index];
+  Token * token = get_element_at(tokens, *index);
-  switch (token.type) {
+  switch (token->type) {
     case TOKEN_STRING:
-      index++;
+      (*index)++;
-      return parse_string(token);
+      return parse_string(*token);
     default:
       perror("unreachable");
       exit(0);
   }
 }
 
-void parser(TaggedValueStruct * taggedValueStruct, TokenStruct * tokenStruct, bool inline_flag) {
+void parser(LinkedList * parsed, LinkedList * tokens, bool inline_flag) {
-  int index = 0;
+  size_t index = 0;
-  while (index < tokenStruct->count) {
+  size_t length = list_length(tokens);
-    TaggedValueStruct_append(taggedValueStruct, parse_token(tokenStruct, &index));
+  while (index < length) {
+    TaggedValue parsed_code = parse_token(tokens, &index);
+    append(parsed,&parsed_code);
   }
 }

src/parser/parser.h

@@ -4,6 +4,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-void parser(TaggedValueStruct * TaggedValueStruct, TokenStruct * tokenStruct, bool inline_flag);
+void parser(LinkedList * parsed, LinkedList * tokens, bool inline_flag);
 
-TaggedValue parse_token(TokenStruct * tokenStruct, int *index);
+TaggedValue parse_token(LinkedList * tokens, size_t *index);

src/parser/string/string.c

@@ -1,12 +1,14 @@
 #include "string.h"
+#include "../../string/string.h"
 #include "../../lexer/token.h"
 
 #include <cjson/cJSON.h>
 #include <stddef.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-char *swap_quotes(const char *input) {
+char *swap_quotes(char *input) {
   size_t len = strlen(input);
   char *result = malloc(len + 1);
   if (!result)
@@ -24,7 +26,8 @@ char *swap_quotes(const char *input) {
   return result;
 }
 
-char *unquote(const char *str) {
+char *unquote(char *str) {
+  return str;
   if (*str == '\0')
     return NULL;
 
@@ -72,7 +75,7 @@ char *unquote(const char *str) {
 
 TaggedValue parse_string(Token token) {
   return (TaggedValue){
-    TYPE_STRING,
+    AST_STRING,
-    unquote(token.value)
+    cloneString(token.value),
   };
 }

src/parser/string/string.h

@@ -1,8 +1,8 @@
 #include "../../lexer/token.h"
 #include "../taggedValue.h"
 
-char *swap_quotes(const char *input);
+char *swap_quotes(char *input);
 
-char *unquote(const char *str);
+char *unquote(char *str);
 
 TaggedValue parse_string(Token token);

src/parser/taggedValue.c

@@ -1,26 +0,0 @@
-#include "taggedValue.h"
-#include <stdlib.h>
-
-TaggedValueStruct init_TaggedValueStruct() {
-    TaggedValueStruct taggedValueStruct = {
-        0,
-        INITIAL_CAPACITY,
-        malloc(sizeof(TaggedValue)*INITIAL_CAPACITY)
-    };
-    return taggedValueStruct;
-}
-
-void TaggedValueStruct_append(TaggedValueStruct *TaggedValueStruct,
-                              TaggedValue TaggedValue) {
-  if (TaggedValueStruct->count >= TaggedValueStruct->capacity) {
-    TaggedValueStruct->capacity *= 2;
-    TaggedValueStruct->TaggedValue =
-        realloc(TaggedValueStruct->TaggedValue,
-                sizeof(TaggedValue) * TaggedValueStruct->capacity);
-  }
-  TaggedValueStruct[TaggedValueStruct->count].TaggedValue->data =
-      TaggedValue.data;
-  TaggedValueStruct[TaggedValueStruct->count].TaggedValue->type =
-      TaggedValue.type;
-  TaggedValueStruct->count++;
-}

src/parser/taggedValue.h

@@ -1,5 +1,7 @@
+#include "../list/list.h"
+
 typedef enum {
-  TYPE_STRING,
+  AST_STRING,
 } ValueType;
 
 typedef struct {
@@ -7,17 +9,3 @@ typedef struct {
   void *data;
   
 } TaggedValue;
-
-
-#define INITIAL_CAPACITY 64
-
-
-typedef struct {
-  int count;
-  int capacity;
-  TaggedValue * TaggedValue;
-} TaggedValueStruct;
-
-TaggedValueStruct init_TaggedValueStruct();
-void TaggedValueStruct_append(TaggedValueStruct *TaggedValueStruct,
-                              TaggedValue TaggedValue);