Fixed CHECK_RESULT macro, use scoped allocator

Scoped allocator gives us better performance and cleanup code for error
cases is much cleaner

1 files changed, 13 insertions, 43 deletions

diff --git a/src/parser.c b/src/parser.c
index a8fa207..875c0bc 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -8,6 +8,7 @@ static CHECK_RESULT int parser_parse_body(Parser *self, Ast *ast);
 
 int parser_init(Parser *self) {
     buffer_init(&self->ast_objects);
+    return_if_error(scoped_allocator_init(&self->allocator));
     return PARSER_OK;
 }
 
@@ -17,6 +18,7 @@ void parser_deinit(Parser *self) {
         ast_deinit((Ast*)&self->ast_objects.data[i]);
     }
     buffer_deinit(&self->ast_objects);
+    scoped_allocator_deinit(&self->allocator);
 }
 
 /*
@@ -38,7 +40,7 @@ static CHECK_RESULT int parser_parse_lhs(Parser *self, LhsExpr **result) {
     return_if_error(tokenizer_accept(&self->tokenizer, TOK_IDENTIFIER));
     var_name = self->tokenizer.value.identifier;
     fprintf(stderr, "var name: %.*s\n", (int)var_name.size, var_name.data);
-    return_if_error(am_malloc(sizeof(LhsExpr), (void**)result));
+    return_if_error(scoped_allocator_alloc(&self->allocator, sizeof(LhsExpr), (void**)result));
     lhsexpr_init(*result, isConst, var_name);
     return PARSER_OK;
 }
@@ -59,7 +61,7 @@ static CHECK_RESULT int parser_parse_function_decl(Parser *self, FunctionDecl **
     /* TODO: Parse return types */
     return_if_error(tokenizer_accept(&self->tokenizer, TOK_OPEN_BRACE));
 
-    return_if_error(am_malloc(sizeof(FunctionDecl), (void**)func_decl));
+    return_if_error(scoped_allocator_alloc(&self->allocator, sizeof(FunctionDecl), (void**)func_decl));
     funcdecl_init(*func_decl);
 
     for(;;) {
@@ -74,11 +76,7 @@ static CHECK_RESULT int parser_parse_function_decl(Parser *self, FunctionDecl **
     return PARSER_OK;
 
     cleanup:
-    if(*func_decl) {
-        funcdecl_deinit(*func_decl);
-        am_free(*func_decl);
-        *func_decl = NULL;
-    }
+    *func_decl = NULL;
     return PARSER_ERR;
 }
 
@@ -99,7 +97,7 @@ static CHECK_RESULT int parser_parse_function_call(Parser *self, FunctionCall **
     /* TODO: Parse arguments */
     return_if_error(tokenizer_accept(&self->tokenizer, TOK_CLOSING_PAREN));
 
-    return_if_error(am_malloc(sizeof(FunctionCall), (void**)func_call));
+    return_if_error(scoped_allocator_alloc(&self->allocator, sizeof(FunctionCall), (void**)func_call));
     funccall_init(*func_call, func_name);
     return PARSER_OK;
 }
@@ -114,14 +112,14 @@ static CHECK_RESULT int parser_parse_rhs(Parser *self, Ast *rhs_expr) {
     func_decl = NULL;
     func_call = NULL;
 
-    cleanup_if_error(parser_parse_function_decl(self, &func_decl));
+    return_if_error(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;
     }
 
-    cleanup_if_error(parser_parse_function_call(self, &func_call));
+    return_if_error(parser_parse_function_call(self, &func_call));
     if(func_call) {
         rhs_expr->type = AST_FUNCTION_CALL;
         rhs_expr->value.func_call = func_call;
@@ -132,17 +130,6 @@ static CHECK_RESULT int parser_parse_rhs(Parser *self, Ast *rhs_expr) {
     /* TODO: Convert token to string */
     tokenizer_print_error(&self->tokenizer, "Expected function declaration or function call, got token: %d");
     return PARSER_UNEXPECTED_TOKEN;
-
-    cleanup:
-    if(func_decl) {
-        funcdecl_deinit(func_decl);
-        am_free(func_decl);
-    }
-    if(func_call) {
-        /*funccall_deinit(func_call);*/
-        am_free(func_call);
-    }
-    return PARSER_ERR;
 }
 
 /*
@@ -157,7 +144,7 @@ int parser_parse_body(Parser *self, Ast *ast) {
     if(lhs_expr)
         return_if_error(tokenizer_accept(&self->tokenizer, TOK_EQUALS));
     
-    cleanup_if_error(parser_parse_rhs(self, &rhs_expr));
+    return_if_error(parser_parse_rhs(self, &rhs_expr));
     if(lhs_expr) {
         lhs_expr->rhs_expr = rhs_expr;
         ast->type = AST_LHS;
@@ -166,13 +153,6 @@ int parser_parse_body(Parser *self, Ast *ast) {
         *ast = rhs_expr;
     }
     return PARSER_OK;
-
-    cleanup:
-    if(lhs_expr) {
-        lhsexpr_deinit(lhs_expr);
-        am_free(lhs_expr);
-    }
-    return PARSER_ERR;
 }
 
 /*
@@ -180,27 +160,17 @@ ROOT = BODY*
 */
 int parser_parse_buffer(Parser *self, BufferView code_buffer) {
     Ast ast;
-    ast = ast_none();
     return_if_error(tokenizer_init(&self->tokenizer, code_buffer));
 
     for(;;) {
         bool isEof;
-        cleanup_if_error(tokenizer_consume_if(&self->tokenizer, TOK_END_OF_FILE, &isEof));
+        return_if_error(tokenizer_consume_if(&self->tokenizer, TOK_END_OF_FILE, &isEof));
         if(isEof)
-            goto cleanup_noerr;
+            break;
         
-        cleanup_if_error(parser_parse_body(self, &ast));
-        cleanup_if_error(buffer_append(&self->ast_objects, &ast, sizeof(ast)));
-        /* For cleanup, we only want to cleanup the last created ast after parser_parse_body */
-        ast = ast_none();
+        return_if_error(parser_parse_body(self, &ast));
+        return_if_error(buffer_append(&self->ast_objects, &ast, sizeof(ast)));
     }
 
-    cleanup_noerr:
-    tokenizer_deinit(&self->tokenizer);
     return PARSER_OK;
-
-    cleanup:
-    tokenizer_deinit(&self->tokenizer);
-    ast_deinit(&ast);
-    return PARSER_ERR;
 }