Open-Argon/Chloride
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
William Bell
2025-05-28 22:51:27 +01:00
parent 43bc7663fc
commit b82e351daf
13 changed files with 465 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files

329
src/lexer/lex.l
View File

@@ -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; }
"&&" { GET_STATE; add_token(TOKENS,TOKEN_AND, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"||" { GET_STATE; add_token(TOKENS,TOKEN_OR, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"<=" { GET_STATE; add_token(TOKENS,TOKEN_LE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
">=" { 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; }
"==" { GET_STATE; add_token(TOKENS,TOKEN_EQ, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"=" { GET_STATE; add_token(TOKENS,TOKEN_ASSIGN, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"//" { GET_STATE; add_token(TOKENS,TOKEN_FLOORDIV, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"<" { GET_STATE; add_token(TOKENS,TOKEN_LT, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
">" { GET_STATE; add_token(TOKENS,TOKEN_GT, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"+" { GET_STATE; add_token(TOKENS,TOKEN_PLUS, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"-" { GET_STATE; add_token(TOKENS,TOKEN_MINUS, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"%" { GET_STATE; add_token(TOKENS,TOKEN_MODULO, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"*" { GET_STATE; add_token(TOKENS,TOKEN_STAR, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"/" { GET_STATE; add_token(TOKENS,TOKEN_SLASH, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"^" { GET_STATE; add_token(TOKENS,TOKEN_CARET, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"not"[ \t]+"in" { GET_STATE; append(TOKENS, create_token(TOKEN_NOT_IN,
LINE_NO,
COLUMN_NO,
yytext
));
append(TOKENS, create_token(
TOKEN_NOT_IN,
LINE_NO,
COLUMN_NO,
yytext
)); ADD_TO_COLUMN; }
"&&" { GET_STATE; append(TOKENS, create_token(TOKEN_AND,
LINE_NO,
COLUMN_NO,
yytext
)); 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; }
"else" { GET_STATE; add_token(TOKENS,TOKEN_ELSE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"while" { GET_STATE; add_token(TOKENS,TOKEN_WHILE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"forever" { GET_STATE; add_token(TOKENS,TOKEN_FOREVER, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"for" { GET_STATE; add_token(TOKENS,TOKEN_FOR, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"break" { GET_STATE; add_token(TOKENS,TOKEN_BREAK, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"continue" { GET_STATE; add_token(TOKENS,TOKEN_CONTINUE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"return" { GET_STATE; add_token(TOKENS,TOKEN_RETURN, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"let" { GET_STATE; add_token(TOKENS,TOKEN_LET, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"import" { GET_STATE; add_token(TOKENS,TOKEN_IMPORT, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"from" { GET_STATE; add_token(TOKENS,TOKEN_FROM, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"do" { GET_STATE; add_token(TOKENS,TOKEN_DO, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"true" { GET_STATE; add_token(TOKENS,TOKEN_TRUE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"false" { GET_STATE; add_token(TOKENS,TOKEN_FALSE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"null" { GET_STATE; add_token(TOKENS,TOKEN_NULL, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"delete" { GET_STATE; add_token(TOKENS,TOKEN_DELETE, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"not" { GET_STATE; add_token(TOKENS,TOKEN_NOT, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"in" { GET_STATE; add_token(TOKENS,TOKEN_IN, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"try" { GET_STATE; add_token(TOKENS,TOKEN_TRY, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"catch" { GET_STATE; add_token(TOKENS,TOKEN_CATCH, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"if" { GET_STATE; append(TOKENS, create_token(TOKEN_IF,
LINE_NO,
COLUMN_NO,
yytext
)); ADD_TO_COLUMN; }
"else" { GET_STATE; append(TOKENS, create_token(TOKEN_ELSE,
LINE_NO,
COLUMN_NO,
yytext
)); ADD_TO_COLUMN; }
"while" { GET_STATE; append(TOKENS, create_token(TOKEN_WHILE,
LINE_NO,
COLUMN_NO,
yytext
)); ADD_TO_COLUMN; }
"forever" { GET_STATE; append(TOKENS, create_token(TOKEN_FOREVER,
LINE_NO,
COLUMN_NO,
yytext
)); 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; add_token(TOKENS,TOKEN_RPAREN, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"[" { GET_STATE; add_token(TOKENS,TOKEN_LBRACKET, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"]" { GET_STATE; add_token(TOKENS,TOKEN_RBRACKET, yytext, LINE_NO, COLUMN_NO); ADD_TO_COLUMN; }
"{" { GET_STATE; add_token(TOKENS,TOKEN_LBRACE, yytext, LINE_NO, COLUMN_NO); 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_LPAREN,
LINE_NO,
COLUMN_NO,
yytext
)); 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;add_token(TOKENS,TOKEN_COMMA, yytext, LINE_NO, COLUMN_NO);ADD_TO_COLUMN}
":" {GET_STATE;add_token(TOKENS,TOKEN_COLON, yytext, LINE_NO, COLUMN_NO);ADD_TO_COLUMN}
"." {GET_STATE;append(TOKENS, create_token(TOKEN_DOT,
LINE_NO,
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
}

3
src/lexer/lexer.h
View File

@@ -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;

54
src/lexer/token.c
View File

@@ -1,47 +1,13 @@
#include <stdlib.h>
#include <string.h>
#include "token.h"
#include <stdio.h>
#include <stdlib.h>
#define INITIAL_CAPACITY 64
TokenStruct* init_token() {
TokenStruct *tokenStruct = malloc(sizeof(TokenStruct));
if (tokenStruct == NULL) {
// handle malloc failure
return NULL;
}
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);
Token *create_token(TokenType type, int line, int column, char *value) {
Token * token = malloc(sizeof(Token));
printf("%s\n", value);
token->type = type;
token->line=line;
token->column=column;
token->value=value;
return token;
}

14
src/lexer/token.h
View File

@@ -71,17 +71,5 @@ typedef struct {
char *value;
} Token;
typedef struct {
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);
Token *create_token(TokenType type, int line, int column, char *value);
#endif

94
src/list/list.c Normal file
View File

@@ -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);
}

42
src/list/list.h Normal file
View File

@@ -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

19
src/main.c
View File

@@ -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;
}

21
src/parser/parser.c
View File

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

4
src/parser/parser.h
View File

@@ -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);

11
src/parser/string/string.c
View File

@@ -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,
unquote(token.value)
AST_STRING,
cloneString(token.value),
};
}

4
src/parser/string/string.h
View File

@@ -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);

26
src/parser/taggedValue.c
View File

@@ -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++;
}

20
src/parser/taggedValue.h
View File

@@ -1,23 +1,11 @@
#include "../list/list.h"
typedef enum {
TYPE_STRING,
AST_STRING,
} ValueType;
typedef struct {
ValueType type;
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);
} TaggedValue;