aboutsummaryrefslogtreecommitdiffhomepage
path: root/parse.c
diff options
context:
space:
mode:
Diffstat (limited to 'parse.c')
-rw-r--r--parse.c191
1 files changed, 94 insertions, 97 deletions
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;
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2025-12-01 05:55:55 +0000