refactor: replace String with char*

6 files changed, 217 insertions, 259 deletions

diff --git a/ast.c b/ast.c
index 6473d46..8a586c2 100644
--- a/ast.c
+++ b/ast.c
@@ -95,8 +95,8 @@ int type_sizeof_struct(Type* ty);
 int type_sizeof_union(Type* ty);
 int type_alignof_struct(Type* ty);
 int type_alignof_union(Type* ty);
-int type_offsetof(Type* ty, const String* name);
-Type* type_member_typeof(Type* ty, const String* name);
+int type_offsetof(Type* ty, const char* name);
+Type* type_member_typeof(Type* ty, const char* name);
 
 int type_sizeof(Type* ty) {
     if (type_is_unsized(ty)) {
@@ -221,7 +221,7 @@ typedef enum AstNodeKind AstNodeKind;
 
 struct AstNode {
     AstNodeKind kind;
-    String name;
+    const char* name;
     Type* ty;
     struct AstNode* __n1;
     struct AstNode* __n2;
@@ -235,7 +235,7 @@ typedef struct AstNode AstNode;
 struct Program {
     AstNode* funcs;
     AstNode* vars;
-    char** str_literals;
+    const char** str_literals;
 };
 typedef struct Program Program;
 
@@ -356,7 +356,7 @@ AstNode* ast_new_deref_expr(AstNode* operand) {
     return e;
 }
 
-AstNode* ast_new_member_access_expr(AstNode* obj, const String* name) {
+AstNode* ast_new_member_access_expr(AstNode* obj, const char* name) {
     AstNode* e = ast_new(AstNodeKind_deref_expr);
     e->node_operand = ast_new_binary_expr(TokenKind_plus, obj, ast_new_int(type_offsetof(obj->ty->base, name)));
     e->ty = type_member_typeof(obj->ty->base, name);
@@ -430,7 +430,7 @@ int type_alignof_union(Type* ty) {
     return union_align;
 }
 
-int type_offsetof(Type* ty, const String* name) {
+int type_offsetof(Type* ty, const char* name) {
     if (ty->kind == TypeKind_union) {
         return 0;
     }
@@ -446,7 +446,7 @@ int type_offsetof(Type* ty, const String* name) {
         int align = type_alignof(member->ty);
 
         next_offset = to_aligned(next_offset, align);
-        if (string_equals(&member->name, name)) {
+        if (strcmp(member->name, name) == 0) {
             return next_offset;
         }
         next_offset += size;
@@ -455,14 +455,14 @@ int type_offsetof(Type* ty, const String* name) {
     fatal_error("type_offsetof: member not found");
 }
 
-Type* type_member_typeof(Type* ty, const String* name) {
+Type* type_member_typeof(Type* ty, const char* name) {
     if (ty->kind != TypeKind_struct && ty->kind != TypeKind_union) {
         fatal_error("type_member_typeof: type is neither a struct nor a union");
     }
 
     for (int i = 0; i < ty->def->node_members->node_len; ++i) {
         AstNode* member = ty->def->node_members->node_items + i;
-        if (string_equals(&member->name, name)) {
+        if (strcmp(member->name, name) == 0) {
             return member->ty;
         }
     }
diff --git a/codegen.c b/codegen.c
index f71d74a..4fdfe46 100644
--- a/codegen.c
+++ b/codegen.c
@@ -295,9 +295,9 @@ void codegen_assign_expr(CodeGen* g, AstNode* ast) {
 }
 
 void codegen_func_call(CodeGen* g, AstNode* ast) {
-    String* func_name = &ast->name;
+    const char* func_name = ast->name;
 
-    if (string_equals_cstr(func_name, "va_start")) {
+    if (strcmp(func_name, "va_start") == 0) {
         printf("  # va_start BEGIN\n");
         for (int i = 0; i < 6; ++i) {
             printf("  mov rax, %s\n", param_reg(i));
@@ -337,7 +337,7 @@ void codegen_func_call(CodeGen* g, AstNode* ast) {
 
     printf("  mov rax, 0\n");
     printf("  sub rsp, 8\n");
-    printf("  call %.*s\n", func_name->len, func_name->data);
+    printf("  call %s\n", func_name);
     printf("  add rsp, 8\n");
     printf("  push rax\n");
 
@@ -345,7 +345,7 @@ void codegen_func_call(CodeGen* g, AstNode* ast) {
     printf(".Laligned%d:\n", label);
 
     printf("  mov rax, 0\n");
-    printf("  call %.*s\n", func_name->len, func_name->data);
+    printf("  call %s\n", func_name);
     printf("  push rax\n");
 
     printf(".Lend%d:\n", label);
@@ -361,7 +361,7 @@ void codegen_lvar(CodeGen* g, AstNode* ast, GenMode gen_mode) {
 }
 
 void codegen_gvar(CodeGen* g, AstNode* ast, GenMode gen_mode) {
-    printf("  lea rax, %.*s[rip]\n", ast->name.len, ast->name.data);
+    printf("  lea rax, %s[rip]\n", ast->name);
     printf("  push rax\n");
     if (gen_mode == GenMode_rval) {
         codegen_lval2rval(ast->ty);
@@ -536,11 +536,11 @@ void codegen_stmt(CodeGen* g, AstNode* ast) {
 }
 
 void codegen_func(CodeGen* g, AstNode* ast) {
-    printf("%.*s:\n", ast->name.len, ast->name.data);
+    printf("%s:\n", ast->name);
 
     codegen_func_prologue(g, ast);
     codegen_stmt(g, ast->node_body);
-    if (string_equals_cstr(&ast->name, "main")) {
+    if (strcmp(ast->name, "main") == 0) {
         // C99: 5.1.2.2.3
         printf("  mov rax, 0\n");
     }
@@ -569,15 +569,15 @@ void codegen(Program* prog) {
         AstNode* var = prog->vars->node_items + i;
         if (var->node_expr) {
             if (var->ty->kind == TypeKind_char)
-                printf("  %.*s: .byte %d\n", var->name.len, var->name.data, var->node_expr->node_int_value);
+                printf("  %s: .byte %d\n", var->name, var->node_expr->node_int_value);
             else if (var->ty->kind == TypeKind_short)
-                printf("  %.*s: .word %d\n", var->name.len, var->name.data, var->node_expr->node_int_value);
+                printf("  %s: .word %d\n", var->name, var->node_expr->node_int_value);
             else if (var->ty->kind == TypeKind_int)
-                printf("  %.*s: .int %d\n", var->name.len, var->name.data, var->node_expr->node_int_value);
+                printf("  %s: .int %d\n", var->name, var->node_expr->node_int_value);
             else
                 unimplemented();
         } else {
-            printf("  %.*s: .zero %d\n", var->name.len, var->name.data, type_sizeof(var->ty));
+            printf("  %s: .zero %d\n", var->name, type_sizeof(var->ty));
         }
     }
 
diff --git a/common.c b/common.c
index 2c1fb37..921b89b 100644
--- a/common.c
+++ b/common.c
@@ -10,31 +10,3 @@ void fatal_error(const char* msg, ...) {
 #define unreachable() fatal_error("%s:%d: unreachable", __FILE__, __LINE__)
 
 #define unimplemented() fatal_error("%s:%d: unimplemented", __FILE__, __LINE__)
-
-struct String {
-    const char* data;
-    size_t len;
-};
-typedef struct String String;
-
-char* string_to_cstr(const String* s) {
-    char* buf = calloc(s->len + 1, sizeof(char));
-    memcpy(buf, s->data, s->len);
-    return buf;
-}
-
-String* cstr_to_new_string(const char* cstr) {
-    String* s = calloc(1, sizeof(String));
-    s->len = strlen(cstr);
-    s->data = strndup(cstr, s->len);
-    return s;
-}
-
-BOOL string_equals(const String* s1, const String* s2) {
-    return s1->len == s2->len && strncmp(s1->data, s2->data, s1->len) == 0;
-}
-
-BOOL string_equals_cstr(const String* s1, const char* s2) {
-    size_t s2_len = strlen(s2);
-    return s1->len == s2_len && strncmp(s1->data, s2, s1->len) == 0;
-}
diff --git a/parse.c b/parse.c
index 55cbce5..1e27b5a 100644
--- a/parse.c
+++ b/parse.c
@@ -1,7 +1,7 @@
 #define LVAR_MAX 32
 
 struct LocalVar {
-    String name;
+    const char* name;
     Type* ty;
     int stack_offset;
 };
@@ -9,19 +9,19 @@ typedef struct LocalVar LocalVar;
 
 struct Scope {
     struct Scope* outer;
-    String* lvar_names;
+    const char** lvar_names;
     int* lvar_indices;
 };
 typedef struct Scope Scope;
 
 struct GlobalVar {
-    String name;
+    const char* name;
     Type* ty;
 };
 typedef struct GlobalVar GlobalVar;
 
 struct Func {
-    String name;
+    const char* name;
     Type* ty;
 };
 typedef struct Func Func;
@@ -44,7 +44,7 @@ struct Parser {
     int n_enums;
     AstNode* typedefs;
     int n_typedefs;
-    char** str_literals;
+    const char** str_literals;
     int n_str_literals;
 };
 typedef struct Parser Parser;
@@ -60,7 +60,7 @@ Parser* parser_new(TokenArray* tokens) {
     p->typedefs = calloc(64, sizeof(AstNode));
     p->str_literals = calloc(1024, sizeof(char*));
 
-    p->funcs[p->n_funcs].name = *cstr_to_new_string("va_start");
+    p->funcs[p->n_funcs].name = "va_start";
     p->funcs[p->n_funcs].ty = calloc(1, sizeof(Type));
     p->funcs[p->n_funcs].ty->kind = TypeKind_void;
     ++p->n_funcs;
@@ -89,20 +89,20 @@ Token* expect(Parser* p, TokenKind expected) {
                 token_stringify(t));
 }
 
-int find_lvar_in_scope(Parser* p, Scope* scope, const String* name) {
+int find_lvar_in_scope(Parser* p, Scope* scope, const char* name) {
     for (int i = 0; i < LVAR_MAX; ++i) {
-        if (string_equals(&scope->lvar_names[i], name)) {
+        if (scope->lvar_names[i] && strcmp(scope->lvar_names[i], name) == 0) {
             return scope->lvar_indices[i];
         }
     }
     return -1;
 }
 
-int find_lvar_in_current_scope(Parser* p, const String* name) {
+int find_lvar_in_current_scope(Parser* p, const char* name) {
     return find_lvar_in_scope(p, p->scope, name);
 }
 
-int find_lvar(Parser* p, const String* name) {
+int find_lvar(Parser* p, const char* name) {
     Scope* scope = p->scope;
     while (scope) {
         int idx = find_lvar_in_scope(p, scope, name);
@@ -135,14 +135,14 @@ int calc_stack_offset(Parser* p, Type* ty, BOOL is_param) {
     return to_aligned(offset, align);
 }
 
-int add_lvar(Parser* p, String* name, Type* ty, BOOL is_param) {
+int add_lvar(Parser* p, const char* name, Type* ty, BOOL is_param) {
     int stack_offset = calc_stack_offset(p, ty, is_param);
-    p->lvars[p->n_lvars].name = *name;
+    p->lvars[p->n_lvars].name = name;
     p->lvars[p->n_lvars].ty = ty;
     p->lvars[p->n_lvars].stack_offset = stack_offset;
     for (int i = 0; i < LVAR_MAX; ++i) {
-        if (p->scope->lvar_names[i].len == 0) {
-            p->scope->lvar_names[i] = *name;
+        if (p->scope->lvar_names[i] == NULL) {
+            p->scope->lvar_names[i] = name;
             p->scope->lvar_indices[i] = p->n_lvars;
             break;
         }
@@ -151,77 +151,75 @@ int add_lvar(Parser* p, String* name, Type* ty, BOOL is_param) {
     return stack_offset;
 }
 
-String* generate_temporary_lvar_name(Parser* p) {
-    String* ret = calloc(1, sizeof(String));
+char* generate_temporary_lvar_name(Parser* p) {
     char* buf = calloc(256, sizeof(char));
     for (int i = 1;; ++i) {
-        ret->len = sprintf(buf, "__%d", i);
-        ret->data = buf;
-        if (find_lvar(p, ret) == -1) {
-            return ret;
+        sprintf(buf, "__%d", i);
+        if (find_lvar(p, buf) == -1) {
+            return buf;
         }
     }
 }
 
 AstNode* generate_temporary_lvar(Parser* p, Type* ty) {
-    String* name = generate_temporary_lvar_name(p);
+    const char* name = generate_temporary_lvar_name(p);
     int stack_offset = add_lvar(p, name, ty, FALSE);
     AstNode* lvar = ast_new(AstNodeKind_lvar);
-    lvar->name = *name;
+    lvar->name = name;
     lvar->node_stack_offset = stack_offset;
     lvar->ty = ty;
     return lvar;
 }
 
-int find_gvar(Parser* p, const String* name) {
+int find_gvar(Parser* p, const char* name) {
     for (int i = 0; i < p->n_gvars; ++i) {
-        if (string_equals(&p->gvars[i].name, name)) {
+        if (strcmp(p->gvars[i].name, name) == 0) {
             return i;
         }
     }
     return -1;
 }
 
-int find_func(Parser* p, const String* name) {
+int find_func(Parser* p, const char* name) {
     for (int i = 0; i < p->n_funcs; ++i) {
-        if (string_equals(&p->funcs[i].name, name)) {
+        if (strcmp(p->funcs[i].name, name) == 0) {
             return i;
         }
     }
     return -1;
 }
 
-int find_struct(Parser* p, const String* name) {
+int find_struct(Parser* p, const char* name) {
     for (int i = 0; i < p->n_structs; ++i) {
-        if (string_equals(&p->structs[i].name, name)) {
+        if (strcmp(p->structs[i].name, name) == 0) {
             return i;
         }
     }
     return -1;
 }
 
-int find_union(Parser* p, const String* name) {
+int find_union(Parser* p, const char* name) {
     for (int i = 0; i < p->n_unions; ++i) {
-        if (string_equals(&p->unions[i].name, name)) {
+        if (strcmp(p->unions[i].name, name) == 0) {
             return i;
         }
     }
     return -1;
 }
 
-int find_enum(Parser* p, const String* name) {
+int find_enum(Parser* p, const char* name) {
     for (int i = 0; i < p->n_enums; ++i) {
-        if (string_equals(&p->enums[i].name, name)) {
+        if (strcmp(p->enums[i].name, name) == 0) {
             return i;
         }
     }
     return -1;
 }
 
-int find_enum_member(Parser* p, const String* name) {
+int find_enum_member(Parser* p, const char* name) {
     for (int i = 0; i < p->n_enums; ++i) {
         for (int j = 0; j < p->enums[i].node_members->node_len; ++j) {
-            if (string_equals(&p->enums[i].node_members->node_items[j].name, name)) {
+            if (strcmp(p->enums[i].node_members->node_items[j].name, name) == 0) {
                 return i * 1000 + j;
             }
         }
@@ -229,9 +227,9 @@ int find_enum_member(Parser* p, const String* name) {
     return -1;
 }
 
-int find_typedef(Parser* p, const String* name) {
+int find_typedef(Parser* p, const char* name) {
     for (int i = 0; i < p->n_typedefs; ++i) {
-        if (string_equals(&p->typedefs[i].name, name)) {
+        if (strcmp(p->typedefs[i].name, name) == 0) {
             return i;
         }
     }
@@ -242,7 +240,7 @@ void enter_scope(Parser* p) {
     Scope* outer_scope = p->scope;
     p->scope = calloc(1, sizeof(Scope));
     p->scope->outer = outer_scope;
-    p->scope->lvar_names = calloc(LVAR_MAX, sizeof(String));
+    p->scope->lvar_names = calloc(LVAR_MAX, sizeof(char*));
     p->scope->lvar_indices = calloc(LVAR_MAX, sizeof(int));
 }
 
@@ -264,11 +262,11 @@ AstNode* parse_assignment_expr(Parser* p);
 AstNode* parse_expr(Parser* p);
 AstNode* parse_stmt(Parser* p);
 
-String* parse_ident(Parser* p) {
-    return &expect(p, TokenKind_ident)->value.string;
+const char* parse_ident(Parser* p) {
+    return expect(p, TokenKind_ident)->value.string;
 }
 
-int register_str_literal(Parser* p, char* s) {
+int register_str_literal(Parser* p, const char* s) {
     p->str_literals[p->n_str_literals] = s;
     ++p->n_str_literals;
     return p->n_str_literals;
@@ -280,23 +278,23 @@ AstNode* parse_primary_expr(Parser* p) {
         return ast_new_int(t->value.integer);
     } else if (t->kind == TokenKind_literal_str) {
         AstNode* e = ast_new(AstNodeKind_str_expr);
-        e->node_idx = register_str_literal(p, string_to_cstr(&t->value.string));
-        e->ty = type_new_static_string(t->value.string.len);
+        e->node_idx = register_str_literal(p, t->value.string);
+        e->ty = type_new_static_string(strlen(t->value.string));
         return e;
     } else if (t->kind == TokenKind_paren_l) {
         AstNode* e = parse_expr(p);
         expect(p, TokenKind_paren_r);
         return e;
     } else if (t->kind == TokenKind_ident || t->kind == TokenKind_va_start) {
-        String* name = &t->value.string;
+        const char* name = t->value.string;
 
         if (peek_token(p)->kind == TokenKind_paren_l) {
             AstNode* e = ast_new(AstNodeKind_func_call);
             int func_idx = find_func(p, name);
             if (func_idx == -1) {
-                fatal_error("undefined function: %.*s", name->len, name->data);
+                fatal_error("undefined function: %s", name);
             }
-            e->name = *name;
+            e->name = name;
             e->ty = p->funcs[func_idx].ty;
             return e;
         }
@@ -307,7 +305,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) {
-                    fatal_error("undefined variable: %.*s", name->len, name->data);
+                    fatal_error("undefined variable: %s", name);
                 }
                 int enum_idx = enum_member_idx / 1000;
                 int n = enum_member_idx % 1000;
@@ -317,13 +315,13 @@ AstNode* parse_primary_expr(Parser* p) {
                 return e;
             }
             AstNode* e = ast_new(AstNodeKind_gvar);
-            e->name = *name;
+            e->name = name;
             e->ty = p->gvars[gvar_idx].ty;
             return e;
         }
 
         AstNode* e = ast_new(AstNodeKind_lvar);
-        e->name = *name;
+        e->name = name;
         e->node_stack_offset = p->lvars[lvar_idx].stack_offset;
         e->ty = p->lvars[lvar_idx].ty;
         return e;
@@ -393,11 +391,11 @@ AstNode* parse_postfix_expr(Parser* p) {
             ret = ast_new_deref_expr(ast_new_binary_expr(TokenKind_plus, ret, idx));
         } else if (tk == TokenKind_dot) {
             next_token(p);
-            String* name = parse_ident(p);
+            const char* name = parse_ident(p);
             ret = ast_new_member_access_expr(ast_new_ref_expr(ret), name);
         } else if (tk == TokenKind_arrow) {
             next_token(p);
-            String* name = parse_ident(p);
+            const char* name = parse_ident(p);
             ret = ast_new_member_access_expr(ret, name);
         } else if (tk == TokenKind_plusplus) {
             next_token(p);
@@ -423,7 +421,7 @@ BOOL is_type_token(Parser* p, Token* token) {
     if (token->kind != TokenKind_ident) {
         return FALSE;
     }
-    return find_typedef(p, &token->value.string) != -1;
+    return find_typedef(p, token->value.string) != -1;
 }
 
 Type* parse_type(Parser* p) {
@@ -436,9 +434,9 @@ Type* parse_type(Parser* p) {
     }
     Type* ty;
     if (t->kind == TokenKind_ident) {
-        int typedef_idx = find_typedef(p, &t->value.string);
+        int typedef_idx = find_typedef(p, t->value.string);
         if (typedef_idx == -1) {
-            fatal_error("parse_type: unknown typedef, %.*s", t->value.string.len, t->value.string.data);
+            fatal_error("parse_type: unknown typedef, %s", t->value.string);
         }
         ty = p->typedefs[typedef_idx].ty;
     } else {
@@ -455,26 +453,26 @@ Type* parse_type(Parser* p) {
             ty->kind = TypeKind_void;
         } else if (t->kind == TokenKind_keyword_enum) {
             ty->kind = TypeKind_enum;
-            String* name = parse_ident(p);
+            const char* name = parse_ident(p);
             int enum_idx = find_enum(p, name);
             if (enum_idx == -1) {
-                fatal_error("parse_type: unknown enum, %.*s", name->len, name->data);
+                fatal_error("parse_type: unknown enum, %s", name);
             }
             ty->def = p->enums + enum_idx;
         } else if (t->kind == TokenKind_keyword_struct) {
             ty->kind = TypeKind_struct;
-            String* name = parse_ident(p);
+            const char* name = parse_ident(p);
             int struct_idx = find_struct(p, name);
             if (struct_idx == -1) {
-                fatal_error("parse_type: unknown struct, %.*s", name->len, name->data);
+                fatal_error("parse_type: unknown struct, %s", name);
             }
             ty->def = p->structs + struct_idx;
         } else if (t->kind == TokenKind_keyword_union) {
             ty->kind = TypeKind_union;
-            String* name = parse_ident(p);
+            const char* name = parse_ident(p);
             int union_idx = find_union(p, name);
             if (union_idx == -1) {
-                fatal_error("parse_type: unknown union, %.*s", name->len, name->data);
+                fatal_error("parse_type: unknown union, %s", name);
             }
             ty->def = p->unions + union_idx;
         } else {
@@ -524,12 +522,12 @@ AstNode* parse_prefix_expr(Parser* p) {
         Token* next_tok = peek_token(p);
         Type* ty = NULL;
         if (next_tok->kind == TokenKind_ident) {
-            int lvar_idx = find_lvar(p, &next_tok->value.string);
+            int lvar_idx = find_lvar(p, next_tok->value.string);
             if (lvar_idx != -1) {
                 next_token(p);
                 ty = p->lvars[lvar_idx].ty;
             }
-            int gvar_idx = find_gvar(p, &next_tok->value.string);
+            int gvar_idx = find_gvar(p, next_tok->value.string);
             if (gvar_idx != -1) {
                 next_token(p);
                 ty = p->gvars[gvar_idx].ty;
@@ -812,7 +810,7 @@ AstNode* parse_var_decl(Parser* p) {
     if (type_is_unsized(ty)) {
         fatal_error("parse_var_decl: invalid type for variable");
     }
-    String* name = parse_ident(p);
+    const char* name = parse_ident(p);
 
     if (peek_token(p)->kind == TokenKind_bracket_l) {
         next_token(p);
@@ -834,15 +832,14 @@ AstNode* parse_var_decl(Parser* p) {
 
     if (find_lvar_in_current_scope(p, name) != -1) {
         // TODO: use name's location.
-        fatal_error("%s:%d: '%.*s' redeclared", peek_token(p)->loc.filename, peek_token(p)->loc.line, name->len,
-                    name->data);
+        fatal_error("%s:%d: '%s' redeclared", peek_token(p)->loc.filename, peek_token(p)->loc.line, name);
     }
     int stack_offset = add_lvar(p, name, ty, FALSE);
 
     AstNode* ret;
     if (init) {
         AstNode* lhs = ast_new(AstNodeKind_lvar);
-        lhs->name = *name;
+        lhs->name = name;
         lhs->node_stack_offset = stack_offset;
         lhs->ty = ty;
         AstNode* assign = ast_new_assign_expr(TokenKind_assign, lhs, init);
@@ -988,19 +985,19 @@ AstNode* parse_stmt(Parser* p) {
 void register_params(Parser* p, AstNode* params) {
     for (int i = 0; i < params->node_len; ++i) {
         AstNode* param = params->node_items + i;
-        add_lvar(p, &param->name, param->ty, TRUE);
+        add_lvar(p, param->name, param->ty, TRUE);
     }
 }
 
-void register_func(Parser* p, const String* name, Type* ty) {
-    p->funcs[p->n_funcs].name = *name;
+void register_func(Parser* p, const char* name, Type* ty) {
+    p->funcs[p->n_funcs].name = name;
     p->funcs[p->n_funcs].ty = ty;
     ++p->n_funcs;
 }
 
 AstNode* parse_param(Parser* p) {
     Type* ty = parse_type(p);
-    String* name = NULL;
+    const char* name = NULL;
     TokenKind tk = peek_token(p)->kind;
     if (tk != TokenKind_comma && tk != TokenKind_paren_r) {
         name = parse_ident(p);
@@ -1008,7 +1005,7 @@ AstNode* parse_param(Parser* p) {
     AstNode* param = ast_new(AstNodeKind_param);
     param->ty = ty;
     if (name) {
-        param->name = *name;
+        param->name = name;
     }
     return param;
 }
@@ -1042,7 +1039,7 @@ AstNode* parse_param_list(Parser* p) {
     return list;
 }
 
-AstNode* parse_global_var_decl(Parser* p, Type* ty, String* name) {
+AstNode* parse_global_var_decl(Parser* p, Type* ty, const char* name) {
     if (type_is_unsized(ty)) {
         fatal_error("parse_global_var_decl: invalid type for variable");
     }
@@ -1066,15 +1063,15 @@ AstNode* parse_global_var_decl(Parser* p, Type* ty, String* name) {
     expect(p, TokenKind_semicolon);
 
     if (find_gvar(p, name) != -1) {
-        fatal_error("parse_global_var_decl: %.*s redeclared", name->len, name->data);
+        fatal_error("parse_global_var_decl: %s redeclared", name);
     }
 
-    p->gvars[p->n_gvars].name = *name;
+    p->gvars[p->n_gvars].name = name;
     p->gvars[p->n_gvars].ty = ty;
     ++p->n_gvars;
 
     AstNode* ret = ast_new(AstNodeKind_gvar_decl);
-    ret->name = *name;
+    ret->name = name;
     ret->ty = ty;
     ret->node_expr = init;
     return ret;
@@ -1082,7 +1079,7 @@ AstNode* parse_global_var_decl(Parser* p, Type* ty, String* name) {
 
 AstNode* parse_func_decl_or_def(Parser* p) {
     Type* ty = parse_type(p);
-    String* name = parse_ident(p);
+    const char* name = parse_ident(p);
 
     if (peek_token(p)->kind != TokenKind_paren_l) {
         return parse_global_var_decl(p, ty, name);
@@ -1102,7 +1099,7 @@ AstNode* parse_func_decl_or_def(Parser* p) {
     leave_func(p);
     AstNode* func = ast_new(AstNodeKind_func_def);
     func->ty = ty;
-    func->name = *name;
+    func->name = name;
     func->node_params = params;
     func->node_body = body;
     return func;
@@ -1110,10 +1107,10 @@ AstNode* parse_func_decl_or_def(Parser* p) {
 
 AstNode* parse_struct_member(Parser* p) {
     Type* ty = parse_type(p);
-    String* name = parse_ident(p);
+    const char* name = parse_ident(p);
     expect(p, TokenKind_semicolon);
     AstNode* member = ast_new(AstNodeKind_struct_member);
-    member->name = *name;
+    member->name = name;
     member->ty = ty;
     return member;
 }
@@ -1129,7 +1126,7 @@ AstNode* parse_struct_members(Parser* p) {
 
 AstNode* parse_struct_decl_or_def(Parser* p) {
     expect(p, TokenKind_keyword_struct);
-    String* name = parse_ident(p);
+    const char* name = parse_ident(p);
 
     if (peek_token(p)->kind != TokenKind_semicolon && peek_token(p)->kind != TokenKind_brace_l) {
         p->pos = p->pos - 2;
@@ -1140,7 +1137,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 = *name;
+        p->structs[struct_idx].name = name;
         ++p->n_structs;
     }
     if (peek_token(p)->kind == TokenKind_semicolon) {
@@ -1148,7 +1145,7 @@ AstNode* parse_struct_decl_or_def(Parser* p) {
         return ast_new(AstNodeKind_struct_decl);
     }
     if (p->structs[struct_idx].node_members) {
-        fatal_error("parse_struct_decl_or_def: struct %.*s redefined", name->len, name->data);
+        fatal_error("parse_struct_decl_or_def: struct %s redefined", name);
     }
     expect(p, TokenKind_brace_l);
     AstNode* members = parse_struct_members(p);
@@ -1160,10 +1157,10 @@ AstNode* parse_struct_decl_or_def(Parser* p) {
 
 AstNode* parse_union_member(Parser* p) {
     Type* ty = parse_type(p);
-    String* name = parse_ident(p);
+    const char* name = parse_ident(p);
     expect(p, TokenKind_semicolon);
     AstNode* member = ast_new(AstNodeKind_union_member);
-    member->name = *name;
+    member->name = name;
     member->ty = ty;
     return member;
 }
@@ -1179,7 +1176,7 @@ AstNode* parse_union_members(Parser* p) {
 
 AstNode* parse_union_decl_or_def(Parser* p) {
     expect(p, TokenKind_keyword_union);
-    String* name = parse_ident(p);
+    const char* name = parse_ident(p);
 
     if (peek_token(p)->kind != TokenKind_semicolon && peek_token(p)->kind != TokenKind_brace_l) {
         p->pos = p->pos - 2;
@@ -1190,7 +1187,7 @@ AstNode* parse_union_decl_or_def(Parser* p) {
     if (union_idx == -1) {
         union_idx = p->n_unions;
         p->unions[union_idx].kind = AstNodeKind_union_def;
-        p->unions[union_idx].name = *name;
+        p->unions[union_idx].name = name;
         ++p->n_unions;
     }
     if (peek_token(p)->kind == TokenKind_semicolon) {
@@ -1198,7 +1195,7 @@ AstNode* parse_union_decl_or_def(Parser* p) {
         return ast_new(AstNodeKind_union_decl);
     }
     if (p->unions[union_idx].node_members) {
-        fatal_error("parse_union_decl_or_def: union %.*s redefined", name->len, name->data);
+        fatal_error("parse_union_decl_or_def: union %s redefined", name);
     }
     expect(p, TokenKind_brace_l);
     AstNode* members = parse_union_members(p);
@@ -1209,9 +1206,9 @@ AstNode* parse_union_decl_or_def(Parser* p) {
 }
 
 AstNode* parse_enum_member(Parser* p) {
-    String* name = parse_ident(p);
+    const char* name = parse_ident(p);
     AstNode* member = ast_new(AstNodeKind_enum_member);
-    member->name = *name;
+    member->name = name;
     return member;
 }
 
@@ -1233,7 +1230,7 @@ AstNode* parse_enum_members(Parser* p) {
 
 AstNode* parse_enum_def(Parser* p) {
     expect(p, TokenKind_keyword_enum);
-    String* name = parse_ident(p);
+    const char* name = parse_ident(p);
 
     if (peek_token(p)->kind != TokenKind_brace_l) {
         p->pos = p->pos - 2;
@@ -1244,10 +1241,10 @@ 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 = *name;
+        p->enums[enum_idx].name = name;
         ++p->n_enums;
     } else {
-        fatal_error("parse_enum_def: enum %.*s redefined", name->len, name->data);
+        fatal_error("parse_enum_def: enum %s redefined", name);
     }
     expect(p, TokenKind_brace_l);
     AstNode* members = parse_enum_members(p);
@@ -1260,12 +1257,12 @@ AstNode* parse_enum_def(Parser* p) {
 AstNode* parse_typedef_decl(Parser* p) {
     expect(p, TokenKind_keyword_typedef);
     Type* ty = parse_type(p);
-    String* name = parse_ident(p);
+    const char* name = parse_ident(p);
     expect(p, TokenKind_semicolon);
     AstNode* decl = ast_new(AstNodeKind_typedef_decl);
-    decl->name = *name;
+    decl->name = name;
     decl->ty = ty;
-    p->typedefs[p->n_typedefs].name = *name;
+    p->typedefs[p->n_typedefs].name = name;
     p->typedefs[p->n_typedefs].ty = ty;
     ++p->n_typedefs;
     return decl;
@@ -1277,13 +1274,13 @@ AstNode* parse_extern_var_decl(Parser* p) {
     if (type_is_unsized(ty)) {
         fatal_error("parse_extern_var_decl: invalid type for variable");
     }
-    String* name = parse_ident(p);
+    const char* name = parse_ident(p);
     expect(p, TokenKind_semicolon);
 
     if (find_lvar(p, name) != -1 || find_gvar(p, name) != -1) {
-        fatal_error("parse_extern_var_decl: %.*s redeclared", name->len, name->data);
+        fatal_error("parse_extern_var_decl: %s redeclared", name);
     }
-    p->gvars[p->n_gvars].name = *name;
+    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 5dfb0d5..0b55131 100644
--- a/preprocess.c
+++ b/preprocess.c
@@ -341,7 +341,7 @@ typedef struct SourceLocation SourceLocation;
 
 // TokenValue is externally tagged by Token's kind.
 union TokenValue {
-    String string;
+    const char* string;
     int integer;
 };
 typedef union TokenValue TokenValue;
@@ -363,8 +363,8 @@ const char* token_stringify(Token* t) {
     } else if (k == TokenKind_other || k == TokenKind_character_constant || k == TokenKind_ident ||
                k == TokenKind_literal_int || k == TokenKind_literal_str) {
         const char* kind_str = token_kind_stringify(k);
-        char* buf = calloc(t->value.string.len + strlen(kind_str) + 3 + 1, sizeof(char));
-        sprintf(buf, "%.*s (%s)", t->value.string.len, t->value.string.data, kind_str);
+        char* buf = calloc(strlen(t->value.string) + strlen(kind_str) + 3 + 1, sizeof(char));
+        sprintf(buf, "%s (%s)", strlen(t->value.string), kind_str);
         return buf;
     } else {
         return token_kind_stringify(k);
@@ -403,6 +403,7 @@ Token* tokens_pop(TokenArray* tokens) {
 }
 
 enum MacroKind {
+    MacroKind_undef,
     MacroKind_obj,
     MacroKind_func,
     MacroKind_builtin_file,
@@ -411,7 +412,9 @@ enum MacroKind {
 typedef enum MacroKind MacroKind;
 
 const char* macro_kind_stringify(MacroKind kind) {
-    if (kind == MacroKind_obj)
+    if (kind == MacroKind_undef)
+        return "undef";
+    else if (kind == MacroKind_obj)
         return "object-like";
     else if (kind == MacroKind_func)
         return "function-like";
@@ -425,7 +428,7 @@ const char* macro_kind_stringify(MacroKind kind) {
 
 struct Macro {
     MacroKind kind;
-    String name;
+    const char* name;
     TokenArray parameters;
     TokenArray replacements;
 };
@@ -436,7 +439,7 @@ int macro_find_param(Macro* macro, Token* tok) {
         return -1;
 
     for (int i = 0; i < macro->parameters.len; ++i) {
-        if (string_equals(&macro->parameters.data[i].value.string, &tok->value.string)) {
+        if (strcmp(macro->parameters.data[i].value.string, tok->value.string) == 0) {
             return i;
         }
     }
@@ -479,7 +482,7 @@ void macros_dump(MacroArray* macros) {
         Macro* m = &macros->data[i];
         fprintf(stderr, "    Macro {\n");
         fprintf(stderr, "      kind = %s\n", macro_kind_stringify(m->kind));
-        fprintf(stderr, "      name = %.*s\n", m->name.len, m->name.data);
+        fprintf(stderr, "      name = %s\n", m->name);
         fprintf(stderr, "      replacements = TODO\n");
         fprintf(stderr, "    }\n");
     }
@@ -492,7 +495,7 @@ void add_predefined_macros(MacroArray* macros) {
 
     m = macros_push_new(macros);
     m->kind = MacroKind_obj;
-    m->name = *cstr_to_new_string("__ducc__");
+    m->name = "__ducc__";
     tokens_init(&m->replacements, 1);
     Token* tok = tokens_push_new(&m->replacements);
     tok->kind = TokenKind_literal_int;
@@ -500,11 +503,11 @@ void add_predefined_macros(MacroArray* macros) {
 
     m = macros_push_new(macros);
     m->kind = MacroKind_builtin_file;
-    m->name = *cstr_to_new_string("__FILE__");
+    m->name = "__FILE__";
 
     m = macros_push_new(macros);
     m->kind = MacroKind_builtin_line;
-    m->name = *cstr_to_new_string("__LINE__");
+    m->name = "__LINE__";
 }
 
 struct MacroArg {
@@ -579,40 +582,38 @@ TokenKind pplexer_tokenize_pp_directive(PpLexer* ppl) {
     while (isalnum(ppl->src[ppl->pos])) {
         ++ppl->pos;
     }
-    String pp_directive_name;
-    pp_directive_name.len = ppl->pos - pp_directive_name_start;
-    pp_directive_name.data = &ppl->src[pp_directive_name_start];
+    int pp_directive_name_len = ppl->pos - pp_directive_name_start;
+    const char* pp_directive_name = strndup(&ppl->src[pp_directive_name_start], pp_directive_name_len);
 
-    if (pp_directive_name.len == 0) {
+    if (pp_directive_name_len == 0) {
         return TokenKind_hash;
-    } else if (string_equals_cstr(&pp_directive_name, "define")) {
+    } else if (strcmp(pp_directive_name, "define") == 0) {
         return TokenKind_pp_directive_define;
-    } else if (string_equals_cstr(&pp_directive_name, "elif")) {
+    } else if (strcmp(pp_directive_name, "elif") == 0) {
         return TokenKind_pp_directive_elif;
-    } else if (string_equals_cstr(&pp_directive_name, "else")) {
+    } else if (strcmp(pp_directive_name, "else") == 0) {
         return TokenKind_pp_directive_else;
-    } else if (string_equals_cstr(&pp_directive_name, "endif")) {
+    } else if (strcmp(pp_directive_name, "endif") == 0) {
         return TokenKind_pp_directive_endif;
-    } else if (string_equals_cstr(&pp_directive_name, "error")) {
+    } else if (strcmp(pp_directive_name, "error") == 0) {
         return TokenKind_pp_directive_error;
-    } else if (string_equals_cstr(&pp_directive_name, "if")) {
+    } else if (strcmp(pp_directive_name, "if") == 0) {
         return TokenKind_pp_directive_if;
-    } else if (string_equals_cstr(&pp_directive_name, "ifdef")) {
+    } else if (strcmp(pp_directive_name, "ifdef") == 0) {
         return TokenKind_pp_directive_ifdef;
-    } else if (string_equals_cstr(&pp_directive_name, "ifndef")) {
+    } else if (strcmp(pp_directive_name, "ifndef") == 0) {
         return TokenKind_pp_directive_ifndef;
-    } else if (string_equals_cstr(&pp_directive_name, "include")) {
+    } else if (strcmp(pp_directive_name, "include") == 0) {
         ppl->expect_header_name = TRUE;
         return TokenKind_pp_directive_include;
-    } else if (string_equals_cstr(&pp_directive_name, "line")) {
+    } else if (strcmp(pp_directive_name, "line") == 0) {
         return TokenKind_pp_directive_line;
-    } else if (string_equals_cstr(&pp_directive_name, "pragma")) {
+    } else if (strcmp(pp_directive_name, "pragma") == 0) {
         return TokenKind_pp_directive_pragma;
-    } else if (string_equals_cstr(&pp_directive_name, "undef")) {
+    } else if (strcmp(pp_directive_name, "undef") == 0) {
         return TokenKind_pp_directive_undef;
     } else {
-        fatal_error("%s:%d: unknown preprocessor directive (%.*s)", ppl->filename, ppl->line, pp_directive_name.len,
-                    pp_directive_name.data);
+        fatal_error("%s:%d: unknown preprocessor directive (%s)", ppl->filename, ppl->line, pp_directive_name);
     }
 }
 
@@ -637,8 +638,7 @@ void pplexer_tokenize_all(PpLexer* ppl) {
             }
             ++ppl->pos;
             tok->kind = TokenKind_header_name;
-            tok->value.string.data = strndup(ppl->src + start, ppl->pos - start);
-            tok->value.string.len = ppl->pos - start;
+            tok->value.string = strndup(ppl->src + start, ppl->pos - start);
             ppl->expect_header_name = FALSE;
         } else if (ppl->expect_header_name && c == '<') {
             int start = ppl->pos - 1;
@@ -651,8 +651,7 @@ void pplexer_tokenize_all(PpLexer* ppl) {
             }
             ++ppl->pos;
             tok->kind = TokenKind_header_name;
-            tok->value.string.data = strndup(ppl->src + start, ppl->pos - start);
-            tok->value.string.len = ppl->pos - start;
+            tok->value.string = strndup(ppl->src + start, ppl->pos - start);
             ppl->expect_header_name = FALSE;
         } else if (c == '(') {
             tok->kind = TokenKind_paren_l;
@@ -776,8 +775,7 @@ void pplexer_tokenize_all(PpLexer* ppl) {
                     tok->kind = TokenKind_ellipsis;
                 } else {
                     tok->kind = TokenKind_other;
-                    tok->value.string.len = 2;
-                    tok->value.string.data = strndup(ppl->src + ppl->pos - tok->value.string.len, tok->value.string.len);
+                    tok->value.string = strndup(ppl->src + ppl->pos - 2, 2);
                 }
             } else {
                 tok->kind = TokenKind_dot;
@@ -840,8 +838,7 @@ void pplexer_tokenize_all(PpLexer* ppl) {
             }
             ppl->pos += 2;
             tok->kind = TokenKind_character_constant;
-            tok->value.string.data = strndup(ppl->src + start, ppl->pos - start);
-            tok->value.string.len = ppl->pos - start;
+            tok->value.string = strndup(ppl->src + start, ppl->pos - start);
         } else if (c == '"') {
             int start = ppl->pos - 1;
             while (1) {
@@ -855,8 +852,7 @@ void pplexer_tokenize_all(PpLexer* ppl) {
             }
             ++ppl->pos;
             tok->kind = TokenKind_literal_str;
-            tok->value.string.data = strndup(ppl->src + start + 1, ppl->pos - start - 2);
-            tok->value.string.len = ppl->pos - start - 2;
+            tok->value.string = strndup(ppl->src + start + 1, ppl->pos - start - 2);
         } else if (isdigit(c)) {
             --ppl->pos;
             int start = ppl->pos;
@@ -864,18 +860,14 @@ void pplexer_tokenize_all(PpLexer* ppl) {
                 ++ppl->pos;
             }
             tok->kind = TokenKind_literal_int;
-            String n;
-            n.data = ppl->src + start;
-            n.len = ppl->pos - start;
-            tok->value.integer = atoi(string_to_cstr(&n));
+            tok->value.integer = atoi(ppl->src + start);
         } else if (isalpha(c) || c == '_') {
             --ppl->pos;
             int start = ppl->pos;
             while (isalnum(ppl->src[ppl->pos]) || ppl->src[ppl->pos] == '_') {
                 ++ppl->pos;
             }
-            tok->value.string.data = strndup(ppl->src + start, ppl->pos - start);
-            tok->value.string.len = ppl->pos - start;
+            tok->value.string = strndup(ppl->src + start, ppl->pos - start);
             tok->kind = TokenKind_ident;
         } else if (c == '\n' || c == '\r') {
             ++ppl->line;
@@ -896,8 +888,7 @@ void pplexer_tokenize_all(PpLexer* ppl) {
             }
         } else {
             tok->kind = TokenKind_other;
-            tok->value.string.len = 1;
-            tok->value.string.data = strndup(ppl->src + ppl->pos - tok->value.string.len, tok->value.string.len);
+            tok->value.string = strndup(ppl->src + ppl->pos - 1, 1);
         }
         ppl->at_bol = tok->kind == TokenKind_newline;
     }
@@ -919,7 +910,7 @@ struct Preprocessor {
     MacroArray* macros;
     int include_depth;
     BOOL skip_pp_tokens;
-    String* include_paths;
+    char** include_paths;
     int n_include_paths;
 };
 typedef struct Preprocessor Preprocessor;
@@ -935,7 +926,7 @@ Preprocessor* preprocessor_new(TokenArray* pp_tokens, int include_depth, MacroAr
     pp->pp_tokens = pp_tokens;
     pp->macros = macros;
     pp->include_depth = include_depth;
-    pp->include_paths = calloc(16, sizeof(String));
+    pp->include_paths = calloc(16, sizeof(char*));
 
     return pp;
 }
@@ -956,9 +947,11 @@ BOOL pp_eof(Preprocessor* pp) {
     return peek_pp_token(pp)->kind == TokenKind_eof;
 }
 
-int find_macro(Preprocessor* pp, String* name) {
+int find_macro(Preprocessor* pp, const char* name) {
     for (int i = 0; i < pp->macros->len; ++i) {
-        if (string_equals(&pp->macros->data[i].name, name)) {
+        if (pp->macros->data[i].kind == MacroKind_undef)
+            continue;
+        if (strcmp(pp->macros->data[i].name, name) == 0) {
             return i;
         }
     }
@@ -966,13 +959,12 @@ int find_macro(Preprocessor* pp, String* name) {
 }
 
 void undef_macro(Preprocessor* pp, int idx) {
-    pp->macros->data[idx].name.len = 0;
+    pp->macros->data[idx].kind = MacroKind_undef;
     // TODO: Can predefined macro like __FILE__ be undefined?
 }
 
 void add_include_path(Preprocessor* pp, char* include_path) {
-    pp->include_paths[pp->n_include_paths].data = include_path;
-    pp->include_paths[pp->n_include_paths].len = strlen(include_path);
+    pp->include_paths[pp->n_include_paths] = include_path;
     ++pp->n_include_paths;
 }
 
@@ -999,8 +991,7 @@ void seek_to_next_newline(Preprocessor* pp) {
 
 void make_token_whitespace(Token* tok) {
     tok->kind = TokenKind_whitespace;
-    tok->value.string.len = 0;
-    tok->value.string.data = NULL;
+    tok->value.string = NULL;
 }
 
 void remove_directive_tokens(Preprocessor* pp, int start, int end) {
@@ -1035,7 +1026,7 @@ void process_ifdef_directive(Preprocessor* pp, int directive_token_pos) {
     Token* macro_name = peek_pp_token(pp);
     if (macro_name->kind == TokenKind_ident) {
         next_pp_token(pp);
-        pp->skip_pp_tokens = find_macro(pp, &macro_name->value.string) == -1;
+        pp->skip_pp_tokens = find_macro(pp, macro_name->value.string) == -1;
     }
     remove_directive_tokens(pp, directive_token_pos, pp->pos);
 }
@@ -1046,29 +1037,27 @@ void process_ifndef_directive(Preprocessor* pp, int directive_token_pos) {
     Token* macro_name = peek_pp_token(pp);
     if (macro_name->kind == TokenKind_ident) {
         next_pp_token(pp);
-        pp->skip_pp_tokens = find_macro(pp, &macro_name->value.string) != -1;
+        pp->skip_pp_tokens = find_macro(pp, macro_name->value.string) != -1;
     }
     remove_directive_tokens(pp, directive_token_pos, pp->pos);
 }
 
-String* read_include_header_name(Preprocessor* pp) {
+const char* read_include_header_name(Preprocessor* pp) {
     Token* tok = next_pp_token(pp);
     if (tok->kind != TokenKind_header_name) {
         fatal_error("%s:%d: invalid #include", tok->loc.filename, tok->loc.line);
     }
 
-    return &tok->value.string;
+    return tok->value.string;
 }
 
-const char* resolve_include_name(Preprocessor* pp, String* include_name) {
-    if (include_name->data[0] == '"') {
-        char* buf = calloc(include_name->len - 2 + 1, sizeof(char));
-        sprintf(buf, "%.*s", include_name->len - 2, include_name->data + 1);
-        return buf;
+const char* resolve_include_name(Preprocessor* pp, const char* include_name) {
+    if (include_name[0] == '"') {
+        return strndup(include_name + 1, strlen(include_name) - 2);
     } else {
         for (int i = 0; i < pp->n_include_paths; ++i) {
-            char* buf = calloc(include_name->len - 2 + 1 + pp->include_paths[i].len, sizeof(char));
-            sprintf(buf, "%s/%.*s", pp->include_paths[i].data, include_name->len - 2, include_name->data + 1);
+            char* buf = calloc(strlen(include_name) - 2 + 1 + strlen(pp->include_paths[i]) + 1, sizeof(char));
+            sprintf(buf, "%s/%.*s", pp->include_paths[i], strlen(include_name) - 2, include_name + 1);
             if (access(buf, F_OK | R_OK) == 0) {
                 return buf;
             }
@@ -1124,12 +1113,12 @@ void expand_include_directive(Preprocessor* pp, int directive_token_pos, const c
 void process_include_directive(Preprocessor* pp, int directive_token_pos) {
     next_pp_token(pp);
     skip_whitespaces(pp);
-    String* include_name = read_include_header_name(pp);
-    const char* include_name_buf = resolve_include_name(pp, include_name);
-    if (include_name_buf == NULL) {
-        fatal_error("cannot resolve include file name: %.*s", include_name->len, include_name->data);
+    const char* include_name = read_include_header_name(pp);
+    const char* include_name_resolved = resolve_include_name(pp, include_name);
+    if (include_name_resolved == NULL) {
+        fatal_error("cannot resolve include file name: %s", include_name);
     }
-    expand_include_directive(pp, directive_token_pos, include_name_buf);
+    expand_include_directive(pp, directive_token_pos, include_name_resolved);
 }
 
 // ws ::= many0(<whitespace>)
@@ -1212,7 +1201,7 @@ void process_undef_directive(Preprocessor* pp, int directive_token_pos) {
     Token* macro_name = peek_pp_token(pp);
     if (macro_name->kind == TokenKind_ident) {
         next_pp_token(pp);
-        int macro_idx = find_macro(pp, &macro_name->value.string);
+        int macro_idx = find_macro(pp, macro_name->value.string);
         if (macro_idx != -1) {
             undef_macro(pp, macro_idx);
         }
@@ -1268,7 +1257,7 @@ MacroArgArray* pp_parse_macro_arguments(Preprocessor* pp) {
 BOOL expand_macro(Preprocessor* pp) {
     int macro_name_pos = pp->pos;
     Token* macro_name = next_pp_token(pp);
-    int macro_idx = find_macro(pp, &macro_name->value.string);
+    int macro_idx = find_macro(pp, macro_name->value.string);
     if (macro_idx == -1) {
         return FALSE;
     }
@@ -1298,7 +1287,7 @@ BOOL expand_macro(Preprocessor* pp) {
     } else if (macro->kind == MacroKind_builtin_file) {
         Token file_tok;
         file_tok.kind = TokenKind_literal_str;
-        file_tok.value.string = *cstr_to_new_string(macro_name->loc.filename);
+        file_tok.value.string = macro_name->loc.filename;
         file_tok.loc.filename = NULL;
         file_tok.loc.line = 0;
         replace_single_pp_token(pp, macro_name_pos, &file_tok);
diff --git a/tokenize.c b/tokenize.c
index a5a376b..d6bd7a6 100644
--- a/tokenize.c
+++ b/tokenize.c
@@ -24,9 +24,9 @@ void tokenize_all(Lexer* l) {
         tok->loc = pp_tok->loc;
         if (k == TokenKind_character_constant) {
             tok->kind = TokenKind_literal_int;
-            int ch = pp_tok->value.string.data[1];
+            int ch = pp_tok->value.string[1];
             if (ch == '\\') {
-                ch = pp_tok->value.string.data[2];
+                ch = pp_tok->value.string[2];
                 if (ch == 'a') {
                     ch = '\a';
                 } else if (ch == 'b') {
@@ -47,81 +47,81 @@ void tokenize_all(Lexer* l) {
             }
             tok->value.integer = ch;
         } else if (k == TokenKind_ident) {
-            if (string_equals_cstr(&pp_tok->value.string, "auto")) {
+            if (strcmp(pp_tok->value.string, "auto") == 0) {
                 tok->kind = TokenKind_keyword_auto;
-            } else if (string_equals_cstr(&pp_tok->value.string, "break")) {
+            } else if (strcmp(pp_tok->value.string, "break") == 0) {
                 tok->kind = TokenKind_keyword_break;
-            } else if (string_equals_cstr(&pp_tok->value.string, "case")) {
+            } else if (strcmp(pp_tok->value.string, "case") == 0) {
                 tok->kind = TokenKind_keyword_case;
-            } else if (string_equals_cstr(&pp_tok->value.string, "char")) {
+            } else if (strcmp(pp_tok->value.string, "char") == 0) {
                 tok->kind = TokenKind_keyword_char;
-            } else if (string_equals_cstr(&pp_tok->value.string, "const")) {
+            } else if (strcmp(pp_tok->value.string, "const") == 0) {
                 tok->kind = TokenKind_keyword_const;
-            } else if (string_equals_cstr(&pp_tok->value.string, "continue")) {
+            } else if (strcmp(pp_tok->value.string, "continue") == 0) {
                 tok->kind = TokenKind_keyword_continue;
-            } else if (string_equals_cstr(&pp_tok->value.string, "default")) {
+            } else if (strcmp(pp_tok->value.string, "default") == 0) {
                 tok->kind = TokenKind_keyword_default;
-            } else if (string_equals_cstr(&pp_tok->value.string, "do")) {
+            } else if (strcmp(pp_tok->value.string, "do") == 0) {
                 tok->kind = TokenKind_keyword_do;
-            } else if (string_equals_cstr(&pp_tok->value.string, "double")) {
+            } else if (strcmp(pp_tok->value.string, "double") == 0) {
                 tok->kind = TokenKind_keyword_double;
-            } else if (string_equals_cstr(&pp_tok->value.string, "else")) {
+            } else if (strcmp(pp_tok->value.string, "else") == 0) {
                 tok->kind = TokenKind_keyword_else;
-            } else if (string_equals_cstr(&pp_tok->value.string, "enum")) {
+            } else if (strcmp(pp_tok->value.string, "enum") == 0) {
                 tok->kind = TokenKind_keyword_enum;
-            } else if (string_equals_cstr(&pp_tok->value.string, "extern")) {
+            } else if (strcmp(pp_tok->value.string, "extern") == 0) {
                 tok->kind = TokenKind_keyword_extern;
-            } else if (string_equals_cstr(&pp_tok->value.string, "float")) {
+            } else if (strcmp(pp_tok->value.string, "float") == 0) {
                 tok->kind = TokenKind_keyword_float;
-            } else if (string_equals_cstr(&pp_tok->value.string, "for")) {
+            } else if (strcmp(pp_tok->value.string, "for") == 0) {
                 tok->kind = TokenKind_keyword_for;
-            } else if (string_equals_cstr(&pp_tok->value.string, "goto")) {
+            } else if (strcmp(pp_tok->value.string, "goto") == 0) {
                 tok->kind = TokenKind_keyword_goto;
-            } else if (string_equals_cstr(&pp_tok->value.string, "if")) {
+            } else if (strcmp(pp_tok->value.string, "if") == 0) {
                 tok->kind = TokenKind_keyword_if;
-            } else if (string_equals_cstr(&pp_tok->value.string, "inline")) {
+            } else if (strcmp(pp_tok->value.string, "inline") == 0) {
                 tok->kind = TokenKind_keyword_inline;
-            } else if (string_equals_cstr(&pp_tok->value.string, "int")) {
+            } else if (strcmp(pp_tok->value.string, "int") == 0) {
                 tok->kind = TokenKind_keyword_int;
-            } else if (string_equals_cstr(&pp_tok->value.string, "long")) {
+            } else if (strcmp(pp_tok->value.string, "long") == 0) {
                 tok->kind = TokenKind_keyword_long;
-            } else if (string_equals_cstr(&pp_tok->value.string, "register")) {
+            } else if (strcmp(pp_tok->value.string, "register") == 0) {
                 tok->kind = TokenKind_keyword_register;
-            } else if (string_equals_cstr(&pp_tok->value.string, "restrict")) {
+            } else if (strcmp(pp_tok->value.string, "restrict") == 0) {
                 tok->kind = TokenKind_keyword_restrict;
-            } else if (string_equals_cstr(&pp_tok->value.string, "return")) {
+            } else if (strcmp(pp_tok->value.string, "return") == 0) {
                 tok->kind = TokenKind_keyword_return;
-            } else if (string_equals_cstr(&pp_tok->value.string, "short")) {
+            } else if (strcmp(pp_tok->value.string, "short") == 0) {
                 tok->kind = TokenKind_keyword_short;
-            } else if (string_equals_cstr(&pp_tok->value.string, "signed")) {
+            } else if (strcmp(pp_tok->value.string, "signed") == 0) {
                 tok->kind = TokenKind_keyword_signed;
-            } else if (string_equals_cstr(&pp_tok->value.string, "sizeof")) {
+            } else if (strcmp(pp_tok->value.string, "sizeof") == 0) {
                 tok->kind = TokenKind_keyword_sizeof;
-            } else if (string_equals_cstr(&pp_tok->value.string, "static")) {
+            } else if (strcmp(pp_tok->value.string, "static") == 0) {
                 tok->kind = TokenKind_keyword_static;
-            } else if (string_equals_cstr(&pp_tok->value.string, "struct")) {
+            } else if (strcmp(pp_tok->value.string, "struct") == 0) {
                 tok->kind = TokenKind_keyword_struct;
-            } else if (string_equals_cstr(&pp_tok->value.string, "switch")) {
+            } else if (strcmp(pp_tok->value.string, "switch") == 0) {
                 tok->kind = TokenKind_keyword_switch;
-            } else if (string_equals_cstr(&pp_tok->value.string, "typedef")) {
+            } else if (strcmp(pp_tok->value.string, "typedef") == 0) {
                 tok->kind = TokenKind_keyword_typedef;
-            } else if (string_equals_cstr(&pp_tok->value.string, "union")) {
+            } else if (strcmp(pp_tok->value.string, "union") == 0) {
                 tok->kind = TokenKind_keyword_union;
-            } else if (string_equals_cstr(&pp_tok->value.string, "unsigned")) {
+            } else if (strcmp(pp_tok->value.string, "unsigned") == 0) {
                 tok->kind = TokenKind_keyword_unsigned;
-            } else if (string_equals_cstr(&pp_tok->value.string, "void")) {
+            } else if (strcmp(pp_tok->value.string, "void") == 0) {
                 tok->kind = TokenKind_keyword_void;
-            } else if (string_equals_cstr(&pp_tok->value.string, "volatile")) {
+            } else if (strcmp(pp_tok->value.string, "volatile") == 0) {
                 tok->kind = TokenKind_keyword_volatile;
-            } else if (string_equals_cstr(&pp_tok->value.string, "while")) {
+            } else if (strcmp(pp_tok->value.string, "while") == 0) {
                 tok->kind = TokenKind_keyword_while;
-            } else if (string_equals_cstr(&pp_tok->value.string, "_Bool")) {
+            } else if (strcmp(pp_tok->value.string, "_Bool") == 0) {
                 tok->kind = TokenKind_keyword__Bool;
-            } else if (string_equals_cstr(&pp_tok->value.string, "_Complex")) {
+            } else if (strcmp(pp_tok->value.string, "_Complex") == 0) {
                 tok->kind = TokenKind_keyword__Complex;
-            } else if (string_equals_cstr(&pp_tok->value.string, "_Imaginary")) {
+            } else if (strcmp(pp_tok->value.string, "_Imaginary") == 0) {
                 tok->kind = TokenKind_keyword__Imaginary;
-            } else if (string_equals_cstr(&pp_tok->value.string, "va_start")) {
+            } else if (strcmp(pp_tok->value.string, "va_start") == 0) {
                 tok->kind = TokenKind_va_start;
                 tok->value = pp_tok->value;
             } else {