diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/ast.c | 1 | ||||
| -rw-r--r-- | src/parser.c | 211 |
2 files changed, 122 insertions, 90 deletions
@@ -48,4 +48,5 @@ void binop_init(Binop *self) { self->lhs = ast_none(); self->rhs = ast_none(); self->type = BINOP_ADD; + self->grouped = bool_false; }
\ No newline at end of file diff --git a/src/parser.c b/src/parser.c index 52c5bfe..52c2916 100644 --- a/src/parser.c +++ b/src/parser.c @@ -6,13 +6,30 @@ #include "../include/std/mem.h" #include "../include/std/log.h" #include "../include/std/alloc.h" + #include <stdio.h> #include <stdlib.h> #include <assert.h> -static CHECK_RESULT int parser_parse_rhs_start(Parser *self, Ast *rhs_expr); -static CHECK_RESULT int parser_parse_body(Parser *self, Ast *ast); -static CHECK_RESULT int parser_queue_file(Parser *self, BufferView path); +#define THROWABLE CHECK_RESULT int +#define try(result) \ +do { \ + int return_if_result; \ + return_if_result = (result); \ + (void)return_if_result; \ +} while(0) +#define throw(result) do { longjmp(self->parse_env, (result)); } while(0) +#define throw_if_error(result) \ +do { \ + int return_if_result; \ + return_if_result = (result); \ + if((return_if_result) != 0) \ + throw(return_if_result); \ +} while(0) + +static THROWABLE parser_parse_rhs_start(Parser *self, Ast *rhs_expr); +static THROWABLE parser_parse_body(Parser *self, Ast *ast); +static THROWABLE parser_queue_file(Parser *self, BufferView path); int parser_thread_data_init(ParserThreadData *self) { am_memset(&self->allocator, 0, sizeof(self->allocator)); @@ -45,26 +62,23 @@ int parser_init(Parser *self, amal_compiler *compiler, ScopedAllocator *allocato self->started = bool_false; self->error.index = 0; self->error.str = NULL; + self->error_context = ERROR_CONTEXT_NONE; return buffer_init(&self->ast_objects, self->allocator); } -static bool parser_got_overwritable_error(Parser *self) { - return self->error.str != NULL; -} - /* BODY_LOOP = BODY* @end_token */ -static CHECK_RESULT int parser_parse_body_loop(Parser *self, Buffer *body_list, Token end_token) { +static THROWABLE parser_parse_body_loop(Parser *self, Buffer *body_list, Token end_token) { for(;;) { Ast body_obj; bool is_end_token; - return_if_error(tokenizer_consume_if(&self->tokenizer, end_token, &is_end_token)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, end_token, &is_end_token)); if(is_end_token) break; - return_if_error(parser_parse_body(self, &body_obj)); - return_if_error(buffer_append(body_list, &body_obj, sizeof(body_obj))); + try(parser_parse_body(self, &body_obj)); + throw_if_error(buffer_append(body_list, &body_obj, sizeof(body_obj))); } return PARSER_OK; } @@ -72,47 +86,47 @@ static CHECK_RESULT int parser_parse_body_loop(Parser *self, Buffer *body_list, /* LHS = 'const'|'var' TOK_IDENTIFIER */ -static CHECK_RESULT int parser_parse_lhs(Parser *self, LhsExpr **result, bool *assignment) { +static THROWABLE parser_parse_lhs(Parser *self, LhsExpr **result, bool *assignment) { bool isConst; bool match; BufferView var_name; *result = NULL; - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_CONST, &isConst)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_CONST, &isConst)); if(!isConst) { bool isVar; - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_VAR, &isVar)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_VAR, &isVar)); if(!isVar) return PARSER_OK; } - return_if_error(tokenizer_accept(&self->tokenizer, TOK_IDENTIFIER)); + throw_if_error(tokenizer_accept(&self->tokenizer, TOK_IDENTIFIER)); var_name = self->tokenizer.value.identifier; amal_log_debug("var name: %.*s", (int)var_name.size, var_name.data); - return_if_error(scoped_allocator_alloc(self->allocator, sizeof(LhsExpr), (void**)result)); + throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(LhsExpr), (void**)result)); lhsexpr_init(*result, isConst, var_name); - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_COLON, &match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_COLON, &match)); if(match) { - return_if_error(tokenizer_accept(&self->tokenizer, TOK_IDENTIFIER)); + throw_if_error(tokenizer_accept(&self->tokenizer, TOK_IDENTIFIER)); (*result)->type_name = self->tokenizer.value.identifier; } - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_EQUALS, &match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_EQUALS, &match)); if(match) { *assignment = bool_true; return PARSER_OK; } *assignment = bool_false; - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_SEMICOLON, &match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_SEMICOLON, &match)); if(match && isConst) { self->error = tokenizer_create_error(&self->tokenizer, "const variable declaration requires assignment (expected '=', got ';')"); - return PARSER_UNEXPECTED_TOKEN; + throw(PARSER_UNEXPECTED_TOKEN); } if(!match) { self->error = tokenizer_create_error(&self->tokenizer, "Expected '=' or ';'"); - return PARSER_UNEXPECTED_TOKEN; + throw(PARSER_UNEXPECTED_TOKEN); } return PARSER_OK; } @@ -120,33 +134,34 @@ static CHECK_RESULT int parser_parse_lhs(Parser *self, LhsExpr **result, bool *a /* CLOSURE = 'fn' ('(' PARAM* ')')? '{' BODY_LOOP '}' */ -static CHECK_RESULT int parser_parse_function_decl(Parser *self, FunctionDecl **func_decl) { +static THROWABLE parser_parse_function_decl(Parser *self, FunctionDecl **func_decl) { bool match; *func_decl = NULL; - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_FN, &match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_FN, &match)); if(!match) return PARSER_OK; - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_OPEN_BRACE, &match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_OPEN_BRACE, &match)); if(!match) { - return_if_error(tokenizer_accept(&self->tokenizer, TOK_OPEN_PAREN)); + throw_if_error(tokenizer_accept(&self->tokenizer, TOK_OPEN_PAREN)); /* TODO: Parse parameters */ - return_if_error(tokenizer_accept(&self->tokenizer, TOK_CLOSING_PAREN)); + throw_if_error(tokenizer_accept(&self->tokenizer, TOK_CLOSING_PAREN)); /* TODO: Parse return types */ - return_if_error(tokenizer_accept(&self->tokenizer, TOK_OPEN_BRACE)); + throw_if_error(tokenizer_accept(&self->tokenizer, TOK_OPEN_BRACE)); } - return_if_error(scoped_allocator_alloc(self->allocator, sizeof(FunctionDecl), (void**)func_decl)); - return_if_error(funcdecl_init(*func_decl, self->allocator)); + throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(FunctionDecl), (void**)func_decl)); + throw_if_error(funcdecl_init(*func_decl, self->allocator)); - return parser_parse_body_loop(self, &(*func_decl)->body, TOK_CLOSING_BRACE); + try(parser_parse_body_loop(self, &(*func_decl)->body, TOK_CLOSING_BRACE)); + return PARSER_OK; } /* FUNC_ARGS = (RHS_START)? (',' RHS_START)* ')' */ -static CHECK_RESULT int parser_parse_function_args(Parser *self, FunctionCall *func_call) { +static THROWABLE parser_parse_function_args(Parser *self, FunctionCall *func_call) { bool first_arg; first_arg = bool_true; @@ -155,16 +170,16 @@ static CHECK_RESULT int parser_parse_function_args(Parser *self, FunctionCall *f bool is_end_token; arg_expr = ast_none(); - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_CLOSING_PAREN, &is_end_token)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_CLOSING_PAREN, &is_end_token)); if(is_end_token) break; if(!first_arg) - return_if_error(tokenizer_accept(&self->tokenizer, TOK_COMMA)); + throw_if_error(tokenizer_accept(&self->tokenizer, TOK_COMMA)); first_arg = bool_false; - return_if_error(parser_parse_rhs_start(self, &arg_expr)); - return_if_error(buffer_append(&func_call->args, &arg_expr, sizeof(arg_expr))); + try(parser_parse_rhs_start(self, &arg_expr)); + throw_if_error(buffer_append(&func_call->args, &arg_expr, sizeof(arg_expr))); } return PARSER_OK; @@ -174,58 +189,59 @@ static CHECK_RESULT int parser_parse_function_args(Parser *self, FunctionCall *f VARIABLE = TOK_IDENTIFIER FUNC_CALL_OR_VARIABLE = VARIABLE '(' FUNC_ARGS ')' */ -static CHECK_RESULT int parser_parse_function_call_or_variable(Parser *self, Ast *expr) { +static THROWABLE parser_parse_function_call_or_variable(Parser *self, Ast *expr) { bool match; BufferView identifier; FunctionCall *func_call; - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_IDENTIFIER, &match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_IDENTIFIER, &match)); if(!match) return PARSER_OK; identifier = self->tokenizer.value.identifier; - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_OPEN_PAREN, &match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_OPEN_PAREN, &match)); if(!match) { Variable *variable; - return_if_error(scoped_allocator_alloc(self->allocator, sizeof(Variable), (void**)&variable)); + throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(Variable), (void**)&variable)); variable->name = identifier; expr->type = AST_VARIABLE; expr->value.variable = variable; return PARSER_OK; } - return_if_error(scoped_allocator_alloc(self->allocator, sizeof(FunctionCall), (void**)&func_call)); - return_if_error(funccall_init(func_call, self->tokenizer.value.identifier, self->allocator)); + throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(FunctionCall), (void**)&func_call)); + throw_if_error(funccall_init(func_call, self->tokenizer.value.identifier, self->allocator)); expr->type = AST_FUNCTION_CALL; expr->value.func_call = func_call; - return parser_parse_function_args(self, func_call); + try(parser_parse_function_args(self, func_call)); + return PARSER_OK; } /* IMPORT = IMPORT_SYMBOL */ -static CHECK_RESULT int parser_parse_import(Parser *self, Import **import) { +static THROWABLE parser_parse_import(Parser *self, Import **import) { bool match; *import = NULL; - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_IMPORT, &match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_IMPORT, &match)); if(!match) return PARSER_OK; - return_if_error(scoped_allocator_alloc(self->allocator, sizeof(Import), (void**)import)); + throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(Import), (void**)import)); import_init(*import, self->tokenizer.value.string); return PARSER_OK; } -static CHECK_RESULT int parser_parse_number(Parser *self, Ast *rhs_expr) { +static THROWABLE parser_parse_number(Parser *self, Ast *rhs_expr) { bool match; Number *number; - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_NUMBER, &match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_NUMBER, &match)); if(!match) return PARSER_OK; - return_if_error(scoped_allocator_alloc(self->allocator, sizeof(Number), (void**)&number)); + throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(Number), (void**)&number)); number_init(number, self->tokenizer.value.integer, self->tokenizer.number_is_integer); rhs_expr->type = AST_NUMBER; rhs_expr->value.number = number; @@ -235,61 +251,64 @@ static CHECK_RESULT int parser_parse_number(Parser *self, Ast *rhs_expr) { /* RHS_S = STRING | NUMBER | FUNC_CALL_OR_VARIABLE */ -static CHECK_RESULT int parser_parse_rhs_single_expr(Parser *self, Ast *rhs_expr) { +static THROWABLE parser_parse_rhs_single_expr(Parser *self, Ast *rhs_expr) { bool match; *rhs_expr = ast_none(); - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_STRING, &match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_STRING, &match)); if(match) { String *string; - return_if_error(scoped_allocator_alloc(self->allocator, sizeof(String), (void**)&string)); - return_if_error(string_init(string, self->tokenizer.value.string)); + throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(String), (void**)&string)); + throw_if_error(string_init(string, self->tokenizer.value.string)); rhs_expr->type = AST_STRING; rhs_expr->value.string = string; return PARSER_OK; } - return_if_error(parser_parse_number(self, rhs_expr)); + try(parser_parse_number(self, rhs_expr)); if(rhs_expr->type != AST_NONE) return PARSER_OK; - return_if_error(parser_parse_function_call_or_variable(self, rhs_expr)); + try(parser_parse_function_call_or_variable(self, rhs_expr)); if(rhs_expr->type != AST_NONE) return PARSER_OK; self->error = tokenizer_create_error(&self->tokenizer, "Expected string, variable or function call"); - return PARSER_UNEXPECTED_TOKEN; + throw(PARSER_UNEXPECTED_TOKEN); } -static CHECK_RESULT int parser_parse_rhs_binop(Parser *self, Ast *expr); +static THROWABLE parser_parse_rhs_binop(Parser *self, Ast *expr); /* RHS_BINOP_PAREN = '(' RHS_BINOP ')' (TOK_BINOP RHS_BINOP) */ -static CHECK_RESULT int parser_parse_rhs_binop_paren(Parser *self, bool *match, Ast *expr) { +static THROWABLE parser_parse_rhs_binop_paren(Parser *self, bool *match, Ast *expr) { bool binop_match; Ast lhs; Ast rhs; BinopType binop_type; - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_OPEN_PAREN, match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_OPEN_PAREN, match)); if(!*match) return PARSER_OK; - return_if_error(parser_parse_rhs_binop(self, &lhs)); - return_if_error(tokenizer_accept(&self->tokenizer, TOK_CLOSING_PAREN)); + try(parser_parse_rhs_binop(self, &lhs)); + throw_if_error(tokenizer_accept(&self->tokenizer, TOK_CLOSING_PAREN)); - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_BINOP, &binop_match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_BINOP, &binop_match)); if(!binop_match) { + if(lhs.type == AST_BINOP) + lhs.value.binop->grouped = bool_true; *expr = lhs; return PARSER_OK; } binop_type = self->tokenizer.value.binop_type; - return_if_error(parser_parse_rhs_binop(self, &rhs)); - return_if_error(scoped_allocator_alloc(self->allocator, sizeof(Binop), (void**)&expr->value.binop)); + try(parser_parse_rhs_binop(self, &rhs)); + throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(Binop), (void**)&expr->value.binop)); binop_init(expr->value.binop); expr->value.binop->type = binop_type; + expr->value.binop->grouped = bool_true; expr->value.binop->lhs = lhs; expr->value.binop->rhs = rhs; expr->type = AST_BINOP; @@ -299,22 +318,22 @@ static CHECK_RESULT int parser_parse_rhs_binop_paren(Parser *self, bool *match, /* RHS_BINOP_WO_PAREN = RHS_S | (RHS_S TOK_BINOP RHS_BINOP) */ -static CHECK_RESULT int parser_parse_rhs_binop_without_paren(Parser *self, Ast *expr) { +static THROWABLE parser_parse_rhs_binop_without_paren(Parser *self, Ast *expr) { bool match; Ast lhs; Ast rhs; BinopType binop_type; - return_if_error(parser_parse_rhs_single_expr(self, &lhs)); - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_BINOP, &match)); + try(parser_parse_rhs_single_expr(self, &lhs)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_BINOP, &match)); if(!match) { *expr = lhs; return PARSER_OK; } binop_type = self->tokenizer.value.binop_type; - return_if_error(parser_parse_rhs_binop(self, &rhs)); - return_if_error(scoped_allocator_alloc(self->allocator, sizeof(Binop), (void**)&expr->value.binop)); + try(parser_parse_rhs_binop(self, &rhs)); + throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(Binop), (void**)&expr->value.binop)); binop_init(expr->value.binop); expr->value.binop->type = binop_type; expr->value.binop->lhs = lhs; @@ -330,10 +349,11 @@ Note: Parantheses count has to match for the beginning paranthesis and the endin */ int parser_parse_rhs_binop(Parser *self, Ast *expr) { bool match; - return_if_error(parser_parse_rhs_binop_paren(self, &match, expr)); + try(parser_parse_rhs_binop_paren(self, &match, expr)); if(match) return PARSER_OK; - return parser_parse_rhs_binop_without_paren(self, expr); + try(parser_parse_rhs_binop_without_paren(self, expr)); + return PARSER_OK; } /* @@ -341,9 +361,9 @@ RHS = RHS_BINOP ';' Note: Parantheses count has to match for the beginning paranthesis and the ending parenthesis. */ -static CHECK_RESULT int parser_parse_rhs(Parser *self, Ast *rhs_expr) { +static THROWABLE parser_parse_rhs(Parser *self, Ast *rhs_expr) { /* TODO: If binop only contains one expression, then use that directly for @rhs_expr */ - return_if_error(parser_parse_rhs_binop(self, rhs_expr)); + try(parser_parse_rhs_binop(self, rhs_expr)); /* TODO: Implement this */ /*binop_reorder_by_precedence(binop);*/ @@ -356,27 +376,25 @@ RHS_START = CLOSURE | IMPORT | RHS int parser_parse_rhs_start(Parser *self, Ast *rhs_expr) { FunctionDecl *func_decl; Import *import; - int result; - return_if_error(parser_parse_function_decl(self, &func_decl)); + try(parser_parse_function_decl(self, &func_decl)); if(func_decl) { rhs_expr->type = AST_FUNCTION_DECL; rhs_expr->value.func_decl = func_decl; return PARSER_OK; } - return_if_error(parser_parse_import(self, &import)); + try(parser_parse_import(self, &import)); if(import) { rhs_expr->type = AST_IMPORT; rhs_expr->value.import = import; - return_if_error(parser_queue_file(self, import->path)); + try(parser_queue_file(self, import->path)); return PARSER_OK; } - result = parser_parse_rhs(self, rhs_expr); - if(result == PARSER_UNEXPECTED_TOKEN && parser_got_overwritable_error(self)) - self->error = tokenizer_create_error(&self->tokenizer, "Expected string, variable, closure, function call or import"); - return result; + self->error_context = ERROR_CONTEXT_RHS_START; + try(parser_parse_rhs(self, rhs_expr)); + return PARSER_OK; } /* @@ -392,14 +410,14 @@ int parser_parse_body(Parser *self, Ast *ast) { Ast rhs_expr; rhs_expr = ast_none(); - return_if_error(parser_parse_lhs(self, &lhs_expr, &assignment)); + try(parser_parse_lhs(self, &lhs_expr, &assignment)); if(!assignment) { ast->type = AST_LHS; ast->value.lhs_expr = lhs_expr; return PARSER_OK; } - return_if_error(parser_parse_rhs_start(self, &rhs_expr)); + try(parser_parse_rhs_start(self, &rhs_expr)); if(lhs_expr) { lhs_expr->rhs_expr = rhs_expr; ast->type = AST_LHS; @@ -410,7 +428,7 @@ int parser_parse_body(Parser *self, Ast *ast) { if(rhs_expr.type == AST_BINOP) { bool match; - return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_SEMICOLON, &match)); + throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_SEMICOLON, &match)); if(!match) { /* TODO: Specify all the binop characters instead of "binop" which doesn't make sense for the user */ self->error = tokenizer_create_error(&self->tokenizer, "Expected ';' or binop"); @@ -421,7 +439,7 @@ int parser_parse_body(Parser *self, Ast *ast) { /* TODO: Check for struct and tables */ if(rhs_expr.type != AST_FUNCTION_DECL) - return_if_error(tokenizer_accept(&self->tokenizer, TOK_SEMICOLON)); + throw_if_error(tokenizer_accept(&self->tokenizer, TOK_SEMICOLON)); return PARSER_OK; } @@ -431,10 +449,23 @@ ROOT = BODY_LOOP */ int parser_parse_buffer(Parser *self, BufferView code_buffer, BufferView buffer_name) { int result; - return_if_error(tokenizer_init(&self->tokenizer, code_buffer, buffer_name)); - result = parser_parse_body_loop(self, &self->ast_objects, TOK_END_OF_FILE); - if(self->error.str != NULL) - tokenizer_print_error_object(&self->tokenizer, &self->error); + throw_if_error(tokenizer_init(&self->tokenizer, code_buffer, buffer_name)); + result = setjmp(self->parse_env); + if(result == 0) + try(parser_parse_body_loop(self, &self->ast_objects, TOK_END_OF_FILE)); + else if(self->error.str != NULL) { + switch(self->error_context) { + case ERROR_CONTEXT_NONE: + tokenizer_print_error_object(&self->tokenizer, &self->error); + break; + case ERROR_CONTEXT_RHS_START: + tokenizer_print_error(&self->tokenizer, "Expected string, variable, closure, function call or import"); + break; + default: + assert(bool_false && "Error context handling not implemented"); + break; + } + } return result; } @@ -467,6 +498,6 @@ the path separator is a dot, otherwise the path separator is forward slash '/' int parser_queue_file(Parser *self, BufferView path) { /* TODO: Do not load same path twice or the compile will fail (and it can have recursive import) also for performance reasons */ /* TODO: Parse special path (to include library path with dots) */ - return_if_error(amal_compiler_load_file(self->compiler, path)); + throw_if_error(amal_compiler_load_file(self->compiler, path)); return PARSER_OK; } |