refactor: use struct assignment

3 files changed, 23 insertions, 48 deletions

diff --git a/parse.c b/parse.c
index f61386b..b1e65d4 100644
--- a/parse.c
+++ b/parse.c
@@ -113,8 +113,7 @@ int calc_stack_offset(Parser* p, Type* ty, int is_param) {
 
 int add_lvar(Parser* p, String* name, Type* ty, int is_param) {
     int stack_offset = calc_stack_offset(p, ty, is_param);
-    p->lvars[p->n_lvars].name.data = name->data;
-    p->lvars[p->n_lvars].name.len = name->len;
+    p->lvars[p->n_lvars].name = *name;
     p->lvars[p->n_lvars].ty = ty;
     p->lvars[p->n_lvars].stack_offset = stack_offset;
     ++p->n_lvars;
@@ -220,8 +219,7 @@ AstNode* parse_primary_expr(Parser* p) {
             if (func_idx == -1) {
                 fatal_error("undefined function: %.*s", name->len, name->data);
             }
-            e->name.data = name->data;
-            e->name.len = name->len;
+            e->name = *name;
             e->ty = p->funcs[func_idx].ty;
             return e;
         }
@@ -242,15 +240,13 @@ AstNode* parse_primary_expr(Parser* p) {
                 return e;
             }
             e = ast_new(AstNodeKind_gvar);
-            e->name.data = name->data;
-            e->name.len = name->len;
+            e->name = *name;
             e->ty = p->gvars[gvar_idx].ty;
             return e;
         }
 
         e = ast_new(AstNodeKind_lvar);
-        e->name.data = name->data;
-        e->name.len = name->len;
+        e->name = *name;
         e->node_stack_offset = p->lvars[lvar_idx].stack_offset;
         e->ty = p->lvars[lvar_idx].ty;
         return e;
@@ -729,8 +725,7 @@ AstNode* parse_var_decl(Parser* p) {
     AstNode* ret;
     if (init) {
         AstNode* lhs = ast_new(AstNodeKind_lvar);
-        lhs->name.data = name->data;
-        lhs->name.len = name->len;
+        lhs->name = *name;
         lhs->node_stack_offset = stack_offset;
         lhs->ty = ty;
         AstNode* assign = ast_new_assign_expr(TokenKind_assign, lhs, init);
@@ -807,8 +802,7 @@ void register_params(Parser* p, AstNode* params) {
 }
 
 void register_func(Parser* p, const String* name, Type* ty) {
-    p->funcs[p->n_funcs].name.data = name->data;
-    p->funcs[p->n_funcs].name.len = name->len;
+    p->funcs[p->n_funcs].name = *name;
     p->funcs[p->n_funcs].ty = ty;
     ++p->n_funcs;
 }
@@ -823,8 +817,7 @@ AstNode* parse_param(Parser* p) {
     AstNode* param = ast_new(AstNodeKind_param);
     param->ty = ty;
     if (name) {
-        param->name.data = name->data;
-        param->name.len = name->len;
+        param->name = *name;
     }
     return param;
 }
@@ -874,8 +867,7 @@ AstNode* parse_func_decl_or_def(Parser* p) {
     AstNode* body = parse_block_stmt(p);
     AstNode* func = ast_new(AstNodeKind_func_def);
     func->ty = ty;
-    func->name.data = name->data;
-    func->name.len = name->len;
+    func->name = *name;
     func->node_params = params;
     func->node_body = body;
     return func;
@@ -886,8 +878,7 @@ AstNode* parse_struct_member(Parser* p) {
     String* name = parse_ident(p);
     expect(p, TokenKind_semicolon);
     AstNode* member = ast_new(AstNodeKind_struct_member);
-    member->name.data = name->data;
-    member->name.len = name->len;
+    member->name = *name;
     member->ty = ty;
     return member;
 }
@@ -914,8 +905,7 @@ AstNode* parse_struct_decl_or_def(Parser* p) {
     if (struct_idx == -1) {
         struct_idx = p->n_structs;
         p->structs[struct_idx].kind = AstNodeKind_struct_def;
-        p->structs[struct_idx].name.data = name->data;
-        p->structs[struct_idx].name.len = name->len;
+        p->structs[struct_idx].name = *name;
         ++p->n_structs;
     }
     if (peek_token(p)->kind == TokenKind_semicolon) {
@@ -936,8 +926,7 @@ AstNode* parse_struct_decl_or_def(Parser* p) {
 AstNode* parse_enum_member(Parser* p) {
     String* name = parse_ident(p);
     AstNode* member = ast_new(AstNodeKind_enum_member);
-    member->name.data = name->data;
-    member->name.len = name->len;
+    member->name = *name;
     return member;
 }
 
@@ -970,8 +959,7 @@ AstNode* parse_enum_def(Parser* p) {
     if (enum_idx == -1) {
         enum_idx = p->n_enums;
         p->enums[enum_idx].kind = AstNodeKind_enum_def;
-        p->enums[enum_idx].name.data = name->data;
-        p->enums[enum_idx].name.len = name->len;
+        p->enums[enum_idx].name = *name;
         ++p->n_enums;
     } else {
         fatal_error("parse_enum_def: enum %.*s redefined", name->len, name->data);
@@ -990,11 +978,9 @@ AstNode* parse_typedef_decl(Parser* p) {
     String* name = parse_ident(p);
     expect(p, TokenKind_semicolon);
     AstNode* decl = ast_new(AstNodeKind_typedef_decl);
-    decl->name.data = name->data;
-    decl->name.len = name->len;
+    decl->name = *name;
     decl->ty = ty;
-    p->typedefs[p->n_typedefs].name.data = name->data;
-    p->typedefs[p->n_typedefs].name.len = name->len;
+    p->typedefs[p->n_typedefs].name = *name;
     p->typedefs[p->n_typedefs].ty = ty;
     ++p->n_typedefs;
     return decl;
@@ -1012,8 +998,7 @@ AstNode* parse_extern_var_decl(Parser* p) {
     if (find_lvar(p, name) != -1 || find_gvar(p, name) != -1) {
         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;
+    p->gvars[p->n_gvars].name = *name;
     p->gvars[p->n_gvars].ty = ty;
     ++p->n_gvars;
 
diff --git a/preprocess.c b/preprocess.c
index 560b6b7..4d939fd 100644
--- a/preprocess.c
+++ b/preprocess.c
@@ -508,8 +508,7 @@ PpToken* process_ifdef_directive(Preprocessor* pp, PpToken* tok) {
 
 PpToken* read_include_header_name(PpToken* tok2, String* include_name) {
     if (tok2->kind == PpTokenKind_string_literal) {
-        include_name->data = tok2->raw.data;
-        include_name->len = tok2->raw.len;
+        *include_name = tok2->raw;
         ++tok2;
         return tok2;
     } else if (tok2->kind == PpTokenKind_punctuator && string_equals_cstr(&tok2->raw, "<")) {
@@ -628,14 +627,11 @@ PpToken* process_define_directive(Preprocessor* pp, PpToken* tok) {
                 if (tok3) {
                     pp_macro = pp->pp_macros->data + pp->pp_macros->len;
                     pp_macro->kind = PpMacroKind_func;
-                    pp_macro->name.len = macro_name->raw.len;
-                    pp_macro->name.data = macro_name->raw.data;
+                    pp_macro->name = macro_name->raw;
                     pp_macro->n_replacements = tok3 - tok2;
                     pp_macro->replacements = calloc(pp_macro->n_replacements, sizeof(PpToken));
                     for (i = 0; i < pp_macro->n_replacements; ++i) {
-                        pp_macro->replacements[i].kind = tok2[i].kind;
-                        pp_macro->replacements[i].raw.len = tok2[i].raw.len;
-                        pp_macro->replacements[i].raw.data = tok2[i].raw.data;
+                        pp_macro->replacements[i] = tok2[i];
                     }
                     ++pp->pp_macros->len;
                 }
@@ -645,14 +641,11 @@ PpToken* process_define_directive(Preprocessor* pp, PpToken* tok) {
                 if (tok3) {
                     pp_macro = pp->pp_macros->data + pp->pp_macros->len;
                     pp_macro->kind = PpMacroKind_obj;
-                    pp_macro->name.len = macro_name->raw.len;
-                    pp_macro->name.data = macro_name->raw.data;
+                    pp_macro->name = macro_name->raw;
                     pp_macro->n_replacements = tok3 - tok2;
                     pp_macro->replacements = calloc(pp_macro->n_replacements, sizeof(PpToken));
                     for (i = 0; i < pp_macro->n_replacements; ++i) {
-                        pp_macro->replacements[i].kind = tok2[i].kind;
-                        pp_macro->replacements[i].raw.len = tok2[i].raw.len;
-                        pp_macro->replacements[i].raw.data = tok2[i].raw.data;
+                        pp_macro->replacements[i] = tok2[i];
                     }
                     ++pp->pp_macros->len;
                 }
diff --git a/tokenize.c b/tokenize.c
index 9359efd..0b3c9ba 100644
--- a/tokenize.c
+++ b/tokenize.c
@@ -260,12 +260,10 @@ void tokenize_all(Lexer* l) {
             } else {
                 tok->kind = TokenKind_ident;
             }
-            tok->raw.data = pp_tok->raw.data;
-            tok->raw.len = pp_tok->raw.len;
+            tok->raw = pp_tok->raw;
         } else if (k == PpTokenKind_pp_number) {
             tok->kind = TokenKind_literal_int;
-            tok->raw.data = pp_tok->raw.data;
-            tok->raw.len = pp_tok->raw.len;
+            tok->raw = pp_tok->raw;
         } else if (k == PpTokenKind_character_constant) {
             tok->kind = TokenKind_literal_int;
             ch = pp_tok->raw.data[1];
@@ -363,8 +361,7 @@ void tokenize_all(Lexer* l) {
             } else {
                 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;
+            tok->raw = pp_tok->raw;
         } else if (k == PpTokenKind_whitespace) {
             continue;
         }