krzosa/corelang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Swinging in a different direction, different syntax

Browse Source
This commit is contained in:
Krzosa Karol
2022-05-01 13:51:34 +02:00
parent 3a9b748fed
commit c5498b03ad
14 changed files with 903 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
parser.c
View File

@@ -1,9 +1,19 @@
global Intern_String keyword_s64;
global Intern_String keyword_u64;
global Intern_String keyword_void;
global Intern_String keyword_sizeu;
global Intern_String keyword_sizeof;
global Intern_String intern_empty;
global Intern_String intern_s64;
global Intern_String intern_s32;
global Intern_String intern_s16;
global Intern_String intern_s8;
global Intern_String intern_u64;
global Intern_String intern_u32;
global Intern_String intern_u16;
global Intern_String intern_u8;
global Intern_String intern_void;
global Intern_String intern_sizeu;
global Intern_String keyword_sizeof;
global Intern_String keyword_enum;
global Intern_String keyword_typedef;
global Intern_String keyword_struct;
@@ -12,7 +22,15 @@ global Intern_String keyword_function;
global Intern_String keyword_global;
global AST_Node *type_s64;
global AST_Node *type_s32;
global AST_Node *type_s16;
global AST_Node *type_s8;
global AST_Node *type_u64;
global AST_Node *type_u32;
global AST_Node *type_u16;
global AST_Node *type_u8;
global AST_Node *type_void;
global AST_Node *type_sizeu;
@@ -24,10 +42,6 @@ parser_init(Parser *p){
p->symbols_count = 4096;
p->symbols = arena_push_array(&p->symbol_table_arena, AST_Node, p->symbols_count);
keyword_s64 = intern_string(p, lit("S64"));
keyword_u64 = intern_string(p, lit("U64"));
keyword_void = intern_string(p, lit("void"));
keyword_sizeu = intern_string(p, lit("SizeU"));
keyword_sizeof = intern_string(p, lit("sizeof"));
keyword_struct = intern_string(p, lit("struct"));
keyword_enum = intern_string(p, lit("enum"));
@@ -35,14 +49,37 @@ parser_init(Parser *p){
keyword_union = intern_string(p, lit("union"));
keyword_function = intern_string(p, lit("function"));
keyword_global = intern_string(p, lit("global"));
p->first_keyword = keyword_s64.s.str;
p->first_keyword = keyword_sizeof.s.str;
p->last_keyword = keyword_global.s.str;
intern_s64 = intern_string(p, lit("S64"));
intern_s32 = intern_string(p, lit("S32"));
intern_s16 = intern_string(p, lit("S16"));
intern_s8 = intern_string(p, lit("S8"));
intern_u64 = intern_string(p, lit("U64"));
intern_u32 = intern_string(p, lit("U32"));
intern_u16 = intern_string(p, lit("U16"));
intern_u8 = intern_string(p, lit("U8"));
intern_void = intern_string(p, lit("void"));
intern_sizeu = intern_string(p, lit("SizeU"));
parser_push_scope(p); // Global scope
type_s64 = symbol_register_basic_type(p, keyword_s64, sizeof(S64));
type_u64 = symbol_register_basic_type(p, keyword_u64, sizeof(U64));
type_sizeu = symbol_register_basic_type(p, keyword_sizeu, sizeof(SizeU));
type_void = symbol_register_basic_type(p, keyword_void, sizeof(void));
type_s64 = symbol_register_basic_type(p, intern_s64, sizeof(S64));
type_s32 = symbol_register_basic_type(p, intern_s32, sizeof(S32));
type_s16 = symbol_register_basic_type(p, intern_s16, sizeof(S16));
type_s8 = symbol_register_basic_type(p, intern_s8, sizeof(S8));
type_u64 = symbol_register_basic_type(p, intern_u64, sizeof(U64));
type_u32 = symbol_register_basic_type(p, intern_u32, sizeof(U32));
type_u16 = symbol_register_basic_type(p, intern_u16, sizeof(U16));
type_u8 = symbol_register_basic_type(p, intern_u8, sizeof(U8));
type_void = symbol_register_basic_type(p, intern_void, sizeof(void));
type_sizeu = symbol_register_basic_type(p, intern_sizeu, sizeof(SizeU));
}
@@ -53,19 +90,6 @@ intern_is_keyword(Parser *p, Intern_String intern){
return false;
}
function void
intern_tokens(Parser *p){
for(S64 i = 0; i < p->tokens.len; i++){
Token *t = p->tokens.tokens + i;
if(t->kind == TK_Identifier){
t->intern_val = intern_string(p, t->string);
if(intern_is_keyword(p, t->intern_val)){
t->kind = TK_Keyword;
}
}
}
}
function void
parser_push_error(Parser *p, Token *token, char *str, ...){
@@ -90,6 +114,22 @@ parser_push_error(Parser *p, Token *token, char *str, ...){
SLLQueuePush(p->first_error, p->last_error, error);
}
function void
intern_tokens(Parser *p){
for(S64 i = 0; i < p->tokens.len; i++){
Token *t = p->tokens.tokens + i;
if(t->kind == TK_Identifier){
t->intern_val = intern_string(p, t->string);
if(intern_is_keyword(p, t->intern_val)){
t->kind = TK_Keyword;
}
}
else if(t->kind == TK_Error){
parser_push_error(p, t, (char *)t->error_val.str);
}
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
@@ -162,10 +202,10 @@ symbol_alloc_slot(Parser *p, Intern_String string, B32 is_global){
if(symbol->name.s.str == 0){
/* @Note(Krzosa): Push on scope */ {
if(is_global){
SLLQueuePush(p->scope_stack->first, p->scope_stack->last, symbol);
SLLQueuePushMod(p->scope_stack->first, p->scope_stack->last, symbol, next_scope);
}
else{
SLLQueuePush(p->global_scope->first, p->global_scope->last, symbol);
SLLQueuePushMod(p->global_scope->first, p->global_scope->last, symbol, next_scope);
}
}
symbol->name = string;
@@ -181,6 +221,7 @@ symbol_alloc_slot(Parser *p, Intern_String string, B32 is_global){
break;
}
assert_msg(0, "Ran out of slots in symbol table");
return 0;
}
@@ -205,11 +246,39 @@ symbol_lookup(Parser *p, Intern_String string){
function AST_Node *
symbol_register_basic_type(Parser *p, Intern_String string, SizeU size){
AST_Node *node = symbol_alloc_slot(p, string, true);
assert(node->kind == AK_None);
node->kind = AK_BaseType;
node->base_type_size = size;
return node;
}
function void
symbol_register(Parser *p, AST_Node *node){
AST_Node *look = symbol_alloc_slot(p, node->name, false);
if(look->kind == AK_None){
ast_copy_symbol(look, node);
}
else if(look->kind == node->kind){
if(look->kind == AK_Enum ||
look->kind == AK_Function ||
look->kind == AK_Union ||
look->kind == AK_Struct){
if(look->first_child == 0){
ast_copy_symbol(look, node);
}
else {
parser_push_error(p, token_get(p), "Symbol already has a body");
}
}
else {
parser_push_error(p, token_get(p), "Trying to register a symbol again");
}
}
else{
parser_push_error(p, token_get(p), "Trying to register a symbol of different kind with the same name");
}
}
function AST_Node *
symbol_lookup_type(Parser *p, Intern_String string){
AST_Node *node = symbol_lookup(p, string);
@@ -221,6 +290,15 @@ symbol_lookup_type(Parser *p, Intern_String string){
return 0;
}
function AST_Node *
symbol_require_type(Parser *p, Token *token){
AST_Node *result = symbol_lookup_type(p, token->intern_val);
if(!result){
parser_push_error(p, token, "Undefined type");
}
return result;
}
function void
parser_push_scope(Parser *p){
Scope *scope = 0;
@@ -240,7 +318,7 @@ parser_pop_scope(Parser *p){
SLLStackPop(p->scope_stack, scope);
assert(scope);
for(AST_Node *s = scope->first; s; s=s->scope_next){
for(AST_Node *s = scope->first; s; s=s->next_scope){
memory_zero(s, sizeof(AST_Node));
p->symbols_inserted--;
}