refactor: use variadic arguments in fatal_error()

5 files changed, 23 insertions, 50 deletions

diff --git a/codegen.c b/codegen.c
index c8d6e5b..2240b22 100644
--- a/codegen.c
+++ b/codegen.c
@@ -277,10 +277,10 @@ void codegen_lvar(CodeGen* g, AstNode* ast, GenMode gen_mode) {
 
 void codegen_gvar(CodeGen* g, AstNode* ast, GenMode gen_mode) {
     if (gen_mode == GenMode_lval) {
-        fatal_error("unimplemented");
+        unimplemented();
     }
     if (ast->ty->kind != TypeKind_ptr) {
-        fatal_error("unimplemented");
+        unimplemented();
     }
     printf("  mov rax, QWORD PTR %.*s[rip]\n", ast->name.len, ast->name.data);
     printf("  push rax\n");
diff --git a/common.c b/common.c
index 678065a..63a3feb 100644
--- a/common.c
+++ b/common.c
@@ -11,6 +11,10 @@ void unreachable() {
     fatal_error("unreachable");
 }
 
+void unimplemented() {
+    fatal_error("unimplemented");
+}
+
 char* read_all(FILE* in) {
     char* buf = calloc(1024 * 1024, sizeof(char));
     char* cur = buf;
diff --git a/parse.c b/parse.c
index b0f6892..9c635be 100644
--- a/parse.c
+++ b/parse.c
@@ -75,10 +75,7 @@ Token* expect(Parser* p, int expected) {
     if (t->kind == expected) {
         return t;
     }
-
-    char* buf = calloc(1024, sizeof(char));
-    sprintf(buf, "expected '%s', but got '%s'", token_kind_stringify(expected), token_stringify(t));
-    fatal_error(buf);
+    fatal_error("expected '%s', but got '%s'", token_kind_stringify(expected), token_stringify(t));
 }
 
 int find_lvar(Parser* p, const String* name) {
@@ -170,7 +167,6 @@ int register_str_literal(Parser* p, char* s) {
 AstNode* parse_primary_expr(Parser* p) {
     Token* t = next_token(p);
     AstNode* e;
-    char* buf;
     if (t->kind == TokenKind_literal_int) {
         return ast_new_int(atoi(string_to_cstr(&t->raw)));
     } else if (t->kind == TokenKind_literal_str) {
@@ -188,9 +184,7 @@ AstNode* parse_primary_expr(Parser* p) {
             e = ast_new(AstNodeKind_func_call);
             int func_idx = find_func(p, name);
             if (func_idx == -1) {
-                buf = calloc(1024, sizeof(char));
-                sprintf(buf, "undefined function: %.*s", name->len, name->data);
-                fatal_error(buf);
+                fatal_error("undefined function: %.*s", name->len, name->data);
             }
             e->name.data = name->data;
             e->name.len = name->len;
@@ -204,9 +198,7 @@ AstNode* parse_primary_expr(Parser* p) {
             if (gvar_idx == -1) {
                 int enum_member_idx = find_enum_member(p, name);
                 if (enum_member_idx == -1) {
-                    buf = calloc(1024, sizeof(char));
-                    sprintf(buf, "undefined variable: %.*s", name->len, name->data);
-                    fatal_error(buf);
+                    fatal_error("undefined variable: %.*s", name->len, name->data);
                 }
                 int enum_idx = enum_member_idx / 1000;
                 int n = enum_member_idx % 1000;
@@ -229,9 +221,7 @@ AstNode* parse_primary_expr(Parser* p) {
         e->ty = p->lvars[lvar_idx].ty;
         return e;
     } else {
-        buf = calloc(1024, sizeof(char));
-        sprintf(buf, "expected primary expression, but got '%s'", token_stringify(t));
-        fatal_error(buf);
+        fatal_error("expected primary expression, but got '%s'", token_stringify(t));
     }
 }
 
@@ -298,23 +288,18 @@ int is_type_token(Parser* p, Token* token) {
 
 Type* parse_type(Parser* p) {
     Token* t = next_token(p);
-    char* buf;
     String* name;
     if (t->kind == TokenKind_keyword_const) {
         t = next_token(p);
     }
     if (!is_type_token(p, t)) {
-        buf = calloc(1024, sizeof(char));
-        sprintf(buf, "parse_type: expected type, but got '%s'", token_stringify(t));
-        fatal_error(buf);
+        fatal_error("parse_type: expected type, but got '%s'", token_stringify(t));
     }
     Type* ty;
     if (t->kind == TokenKind_ident) {
         int typedef_idx = find_typedef(p, &t->raw);
         if (typedef_idx == -1) {
-            buf = calloc(1024, sizeof(char));
-            sprintf(buf, "parse_type: unknown typedef, %.*s", t->raw.len, t->raw.data);
-            fatal_error(buf);
+            fatal_error("parse_type: unknown typedef, %.*s", t->raw.len, t->raw.data);
         }
         ty = p->typedefs[typedef_idx].ty;
     } else {
@@ -332,9 +317,7 @@ Type* parse_type(Parser* p) {
             name = parse_ident(p);
             int enum_idx = find_enum(p, name);
             if (enum_idx == -1) {
-                buf = calloc(1024, sizeof(char));
-                sprintf(buf, "parse_type: unknown enum, %.*s", name->len, name->data);
-                fatal_error(buf);
+                fatal_error("parse_type: unknown enum, %.*s", name->len, name->data);
             }
             ty->def = p->enums + enum_idx;
         } else if (t->kind == TokenKind_keyword_struct) {
@@ -342,9 +325,7 @@ Type* parse_type(Parser* p) {
             name = parse_ident(p);
             int struct_idx = find_struct(p, name);
             if (struct_idx == -1) {
-                buf = calloc(1024, sizeof(char));
-                sprintf(buf, "parse_type: unknown struct, %.*s", name->len, name->data);
-                fatal_error(buf);
+                fatal_error("parse_type: unknown struct, %.*s", name->len, name->data);
             }
             ty->def = p->structs + struct_idx;
         } else {
@@ -680,9 +661,7 @@ AstNode* parse_var_decl(Parser* p) {
     expect(p, TokenKind_semicolon);
 
     if (find_lvar(p, name) != -1 || find_gvar(p, name) != -1) {
-        char* buf = calloc(1024, sizeof(char));
-        sprintf(buf, "parse_var_decl: %.*s redeclared", name->len, name->data);
-        fatal_error(buf);
+        fatal_error("parse_var_decl: %.*s redeclared", name->len, name->data);
     }
     p->lvars[p->n_lvars].name.data = name->data;
     p->lvars[p->n_lvars].name.len = name->len;
@@ -882,9 +861,7 @@ AstNode* parse_struct_decl_or_def(Parser* p) {
         return ast_new(AstNodeKind_struct_decl);
     }
     if (p->structs[struct_idx].node_members) {
-        char* buf = calloc(1024, sizeof(char));
-        sprintf(buf, "parse_struct_decl_or_def: struct %.*s redefined", name->len, name->data);
-        fatal_error(buf);
+        fatal_error("parse_struct_decl_or_def: struct %.*s redefined", name->len, name->data);
     }
     expect(p, TokenKind_brace_l);
     AstNode* members = parse_struct_members(p);
@@ -935,9 +912,7 @@ AstNode* parse_enum_def(Parser* p) {
         p->enums[enum_idx].name.len = name->len;
         ++p->n_enums;
     } else {
-        char* buf = calloc(1024, sizeof(char));
-        sprintf(buf, "parse_enum_def: enum %.*s redefined", name->len, name->data);
-        fatal_error(buf);
+        fatal_error("parse_enum_def: enum %.*s redefined", name->len, name->data);
     }
     expect(p, TokenKind_brace_l);
     AstNode* members = parse_enum_members(p);
@@ -973,9 +948,7 @@ AstNode* parse_extern_var_decl(Parser* p) {
     expect(p, TokenKind_semicolon);
 
     if (find_lvar(p, name) != -1 || find_gvar(p, name) != -1) {
-        char* buf = calloc(1024, sizeof(char));
-        sprintf(buf, "parse_extern_var_decl: %.*s redeclared", name->len, name->data);
-        fatal_error(buf);
+        fatal_error("parse_extern_var_decl: %.*s redeclared", name->len, name->data);
     }
     p->gvars[p->n_gvars].name.data = name->data;
     p->gvars[p->n_gvars].name.len = name->len;
diff --git a/preprocess.c b/preprocess.c
index 0a577a2..7c09994 100644
--- a/preprocess.c
+++ b/preprocess.c
@@ -197,7 +197,7 @@ void pp_tokenize_all(Preprocessor* pp) {
                 tok->raw.len = pp->pos - start;
                 tok->raw.data = pp->src + pp->pos - tok->raw.len;
             } else if (pp->src[pp->pos] == '*') {
-                fatal_error("unimplemented");
+                unimplemented();
             } else {
                 tok->kind = PpTokenKind_punctuator;
                 tok->raw.len = 1;
@@ -410,9 +410,7 @@ void process_pp_directives(Preprocessor* pp) {
                     // Read and preprocess included file.
                     FILE* include_file = fopen(include_name_buf, "rb");
                     if (include_file == NULL) {
-                        char* buf = calloc(1024, sizeof(char));
-                        sprintf(buf, "cannot open include file: %s", include_name_buf);
-                        fatal_error(buf);
+                        fatal_error("cannot open include file: %s", include_name_buf);
                     }
                     char* include_source = read_all(include_file);
                     fclose(include_file);
diff --git a/tokenize.c b/tokenize.c
index f177d82..b6b5233 100644
--- a/tokenize.c
+++ b/tokenize.c
@@ -205,7 +205,6 @@ Lexer* lexer_new(PpToken* pp_tokens) {
 }
 
 void tokenize_all(Lexer* l) {
-    char* buf;
     int ch;
     int start;
     while (l->src[l->pos].kind != PpTokenKind_eof) {
@@ -214,7 +213,7 @@ void tokenize_all(Lexer* l) {
         PpTokenKind k = pp_tok->kind;
         ++l->pos;
         if (k == PpTokenKind_header_name) {
-            fatal_error("not implemented yet");
+            unimplemented();
         } else if (k == PpTokenKind_identifier) {
             if (string_equals_cstr(&pp_tok->raw, "break")) {
                 tok->kind = TokenKind_keyword_break;
@@ -284,7 +283,7 @@ void tokenize_all(Lexer* l) {
                     ch = '\v';
                 }
             }
-            buf = calloc(4, sizeof(char));
+            char* buf = calloc(4, sizeof(char));
             sprintf(buf, "%d", ch);
             tok->raw.data = buf;
             tok->raw.len = strlen(buf);
@@ -356,8 +355,7 @@ void tokenize_all(Lexer* l) {
             } else if (string_equals_cstr(&pp_tok->raw, ">")) {
                 tok->kind = TokenKind_gt;
             } else {
-                sprintf(buf, "unknown token: %.*s", pp_tok->raw.len, pp_tok->raw.data);
-                fatal_error(buf);
+                fatal_error("unknown token: %.*s", pp_tok->raw.len, pp_tok->raw.data);
             }
             tok->raw.data = pp_tok->raw.data;
             tok->raw.len = pp_tok->raw.len;