refactor parse errors

LytixDev · LytixDev · commit 831e7e0b4285 · 2024-06-07T12:56:33.000+02:00
diff --git a/include/interpreter/error.h b/include/interpreter/error.h
@@ -32,7 +32,8 @@ extern jmp_buf runtime_error_jmp;
 
 
 void report_lex_err(Lexer *lexer, bool print_offending, char *msg);
-void report_parse_err(Parser *parser, char *msg);
+void report_all_parse_errors(ParseError *head, char *full_input);
+void report_parse_err(ParseError *error, char *full_input);
 
 #ifdef DEBUG
 #define REPORT_RUNTIME_ERROR(...)                                                               \
diff --git a/include/interpreter/parser.h b/include/interpreter/parser.h
@@ -19,31 +19,41 @@
 
 #include <stdbool.h>
 
+#include "interpreter/lexer.h"
 #include "nicc/nicc.h"
 #include "sac/sac.h"
 
 
 /* types */
+typedef struct parse_error_t ParseError;
+struct parse_error_t {
+    char *msg;
+    Token *failed; // the token that caused the error
+    ParseError *next;
+};
+
 typedef struct {
     Arena *ast_arena; // memory arena to put where all AST nodes live on
     ArrayList *tokens; // stream of tokens from the lexer
     size_t token_pos; // index of current token being processed
     char *input; // handle to the source code
-    bool had_error;
-    size_t n_errors;
     int source_line;
+    size_t n_errors;
+    ParseError *perr_head; // linked list of parse errors
+    ParseError *perr_tail; // final parse error node
 } Parser;
 
 typedef struct {
-    bool had_error;
+    size_t n_errors;
+    ParseError *perr_head;
     ArrayList stmts;
-} StmtsOrErr;
+} ParseResult;
 
 /*
  * Parses a list of tokens into a list of statements: Arraylist<Stmt>
  * The Stmt objects in the list are the first nodes in an AST.
  */
-StmtsOrErr parse(Arena *ast_arena, ArrayList *tokens, char *input);
+ParseResult parse(Arena *ast_arena, ArrayList *tokens, char *input);
 
 
 #endif /* PARSER_H */
diff --git a/src/interpreter/error.c b/src/interpreter/error.c
@@ -119,20 +119,24 @@ void report_lex_err(Lexer *lexer, bool print_offending, char *msg)
     free(bf.alloced_buffer);
 }
 
-void report_parse_err(Parser *parser, char *msg)
+void report_all_parse_errors(ParseError *head, char *full_input)
 {
-    parser->had_error = true;
-    Token *failed = arraylist_get(parser->tokens, parser->token_pos);
-    REPORT_IMPL("%s[line %zu]%s: Error during parsing: %s\n", ANSI_BOLD_START, failed->line + 1,
-		ANSI_BOLD_END, msg);
+    for (ParseError *error = head; error != NULL; error = error->next)
+	report_parse_err(error, full_input);
+}
+
+void report_parse_err(ParseError *error, char *full_input)
+{
+    REPORT_IMPL("%s[line %zu]%s: Error during parsing: %s\n", ANSI_BOLD_START,
+		error->failed->line + 1, ANSI_BOLD_END, error->msg);
 
-    char *line = offending_line(parser->input, failed->line);
+    char *line = offending_line(full_input, error->failed->line);
     if (line == NULL) {
 	REPORT_IMPL("Internal error: could not find line where parse error occured");
 	return;
     }
 
-    ErrBuf bf = offending_line_from_offset(line, failed->start);
-    err_buf_print(bf, failed->end - failed->start);
+    ErrBuf bf = offending_line_from_offset(line, error->failed->start);
+    err_buf_print(bf, error->failed->end - error->failed->start);
     free(bf.alloced_buffer);
 }
diff --git a/src/interpreter/parser.c b/src/interpreter/parser.c
@@ -17,6 +17,7 @@
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "interpreter/ast.h"
 #include "interpreter/error.h"
@@ -77,6 +78,19 @@ static ArenaLL arguments(Parser *parser);
 
 static void handle_parse_err(Parser *parser, char *msg);
 
+static ParseError *new_parse_error(Arena *arena, char *msg, Token *failed)
+{
+    ParseError *error = m_arena_alloc_struct(arena, ParseError);
+    size_t msg_len = strlen(msg); // TODO: could we avoid strlen somehow?
+    char *msg_arena = m_arena_alloc(arena, msg_len + 1);
+    memcpy(msg_arena, msg, msg_len + 1);
+    error->msg = msg_arena;
+    error->failed = failed;
+    error->next = NULL;
+
+    return error;
+}
+
 /* util/helper functions */
 static Token *peek(Parser *parser)
 {
@@ -196,13 +210,24 @@ static bool match_either(Parser *parser, unsigned int n, ...)
 static void handle_parse_err(Parser *parser, char *msg)
 {
     parser->n_errors++;
+    Token *failed = arraylist_get(parser->tokens, parser->token_pos);
+    ParseError *error = new_parse_error(parser->ast_arena, msg, failed);
+    if (parser->perr_head == NULL) {
+	parser->perr_head = error;
+	parser->perr_tail = error;
+    } else {
+	parser->perr_tail->next = error;
+	parser->perr_tail = error;
+    }
+
+    // report_parse_err(parser, msg);
+
     if (parser->n_errors >= MAX_PARSE_ERRORS) {
-	report_parse_err(parser, msg);
 	REPORT_IMPL("TOO MANY PARSE ERRORS. Quitting now ...\n");
 	TODO_LOG("Gracfully quit after deciding to stop parsing.");
 	exit(1);
     }
-    report_parse_err(parser, msg);
+
     advance(parser);
 }
 
@@ -884,26 +909,31 @@ static ArenaLL arguments(Parser *parser)
 }
 
 
-StmtsOrErr parse(Arena *ast_arena, ArrayList *tokens, char *input)
+ParseResult parse(Arena *ast_arena, ArrayList *tokens, char *input)
 {
     Parser parser = { .ast_arena = ast_arena,
 		      .tokens = tokens,
 		      .token_pos = 0,
 		      .input = input,
-		      .had_error = false,
-		      .n_errors = 0 };
+		      .n_errors = 0,
+		      .perr_head = NULL,
+		      .perr_tail = NULL };
     ArrayList statements;
     arraylist_init(&statements, sizeof(Stmt *));
 
     /* edge case: empty source file */
     ignore(&parser, t_newline);
     if (check(&parser, t_eof))
-	return (StmtsOrErr){ .had_error = parser.had_error, .stmts = statements };
+	return (ParseResult){ .n_errors = parser.n_errors,
+			      .perr_head = parser.perr_head,
+			      .stmts = statements };
 
     while (!check(&parser, t_eof)) {
 	Stmt *stmt = declaration(&parser);
 	arraylist_append(&statements, &stmt);
     }
 
-    return (StmtsOrErr){ .had_error = parser.had_error, .stmts = statements };
+    return (ParseResult){ .n_errors = parser.n_errors,
+			  .perr_head = parser.perr_head,
+			  .stmts = statements };
 }
diff --git a/src/main.c b/src/main.c
@@ -44,26 +44,23 @@ void interactive(int argc, char **argv)
     prompt_init(&prompt, "-> ");
 
     while (prompt_run(&prompt)) {
+	m_arena_clear(&ast_arena);
+
 	Lexer lex_result = lex(&ast_arena, prompt.buf, prompt.buf_len);
 	if (lex_result.had_error) {
-	    m_arena_clear(&ast_arena);
 	    arraylist_free(&lex_result.tokens);
 	    continue;
 	}
 
-	StmtsOrErr stmts = parse(&ast_arena, &lex_result.tokens, prompt.buf);
-	if (stmts.had_error) {
-	    m_arena_clear(&ast_arena);
-	    arraylist_free(&lex_result.tokens);
-	    arraylist_free(&stmts.stmts);
-	    continue;
-	}
-
-	interpreter_run(&interpreter, &stmts.stmts);
+	ParseResult parse_result = parse(&ast_arena, &lex_result.tokens, prompt.buf);
+	if (parse_result.n_errors == 0)
+	    interpreter_run(&interpreter, &parse_result.stmts);
+	else
+	    report_all_parse_errors(parse_result.perr_head, prompt.buf);
 
-	m_arena_clear(&ast_arena);
+	// TODO: these should maybe be reset (e.i. set size to 0), not freed
 	arraylist_free(&lex_result.tokens);
-	arraylist_free(&stmts.stmts);
+	arraylist_free(&parse_result.stmts);
     }
 
     ast_arena_release(&ast_arena);
@@ -150,8 +147,9 @@ int main(int argc, char **argv)
 #endif /* DEBUG_PERF */
 
     /* parse */
-    StmtsOrErr stmts = parse(&ast_arena, &lex_result.tokens, input);
-    if (stmts.had_error) {
+    ParseResult parse_result = parse(&ast_arena, &lex_result.tokens, input);
+    if (parse_result.n_errors != 0) {
+	report_all_parse_errors(parse_result.perr_head, input);
 	exit_code = 1;
 	goto defer_stms;
     }
@@ -161,7 +159,7 @@ int main(int argc, char **argv)
     parse_elapsed = (double)(end_time - start_time) / CLOCKS_PER_SEC;
 #endif /* DEBUG_PERF */
 #ifdef DEBUG
-    ast_print(&stmts.stmts);
+    ast_print(&parse_result.stmts);
 #endif /* DEBUG */
 
 #ifdef DEBUG
@@ -172,7 +170,7 @@ int main(int argc, char **argv)
 #endif /* DEBUG_PERF */
 
     /* interpret */
-    exit_code = interpret(&stmts.stmts, argc - 1, argv + 1);
+    exit_code = interpret(&parse_result.stmts, argc - 1, argv + 1);
 
 #ifdef DEBUG_PERF
     end_time = clock();
@@ -187,7 +185,7 @@ int main(int argc, char **argv)
 
     /* clean up */
 defer_stms:
-    arraylist_free(&stmts.stmts);
+    arraylist_free(&parse_result.stmts);
 defer_tokens:
     ast_arena_release(&ast_arena);
     arraylist_free(&lex_result.tokens);
