From 3c376bbe30275f164aacf9925ebadde78575301a Mon Sep 17 00:00:00 2001 From: Krzosa Karol Date: Mon, 2 May 2022 09:49:22 +0200 Subject: [PATCH] Delete previous progress --- ast.c | 102 ------------ expr.c | 2 + expr.h | 2 +- ideas.cpp | 38 ++++- lex.c | 43 ++--- main.c | 77 +-------- output.cc | 391 -------------------------------------------- parse_decl.c | 5 +- parse_expr.c | 36 ++-- parser.c | 170 +------------------ parser.h | 21 +-- print.c | 415 ----------------------------------------------- ast.h => test.cc | 53 ------ 13 files changed, 81 insertions(+), 1274 deletions(-) delete mode 100644 ast.c delete mode 100644 print.c rename ast.h => test.cc (84%) diff --git a/ast.c b/ast.c deleted file mode 100644 index 4ee6bc0..0000000 --- a/ast.c +++ /dev/null @@ -1,102 +0,0 @@ -typedef AST_Node AST_Node_List; - -function B32 -ast_is_named(AST_Node *n){ - B32 result = n && n->name.s.str; - return result; -} - -function AST_Node * -ast_node_new(Parser *p, AST_Kind kind, Token *token, Intern_String name){ - AST_Node *node = arena_push_struct(&p->main_arena, AST_Node); - node->pos = token; - node->name = name; - node->kind = kind; - return node; -} - -function AST_Node * -ast_note(Parser *p, Token *token, Intern_String name, Expr *expr){ - AST_Node *node = ast_node_new(p, AK_Note, token, name); - node->expr = expr; - return node; -} - -function AST_Node * -ast_enum(Parser *p, Token *token, Intern_String name){ - AST_Node *node = ast_node_new(p, AK_Enum, token, name); - return node; -} - -function AST_Node * -ast_struct(Parser *p, Token *token, Intern_String name, AST_Kind kind){ - AST_Node *node = ast_node_new(p, kind, token, name); - return node; -} - -function AST_Node * -ast_variable(Parser *p, Token *token, Intern_String name, AST_Node *type, Expr *expr){ - AST_Node *node = ast_node_new(p, AK_Variable, token, name); - node->variable_type = type; - node->expr = expr; - return node; -} - -function AST_Node * -ast_typedef(Parser *p, Token *token, Intern_String name, AST_Node *type){ - AST_Node *node = ast_node_new(p, AK_Typedef, token, name); - node->typedef_type = type; - return node; -} - -function AST_Node * -ast_function(Parser *p, Token *token, Intern_String name, AST_Node *return_type){ - AST_Node *node = ast_node_new(p, AK_Function, token, name); - node->func_return_type = return_type; - return node; -} - -function AST_Node * -ast_enum_child(Parser *p, Token *token, Intern_String name, Expr *expr){ - AST_Node *node = ast_node_new(p, AK_EnumChild, token, name); - node->expr = expr; - return node; -} - -function void -ast_copy_symbol(AST_Node *dst, AST_Node *src){ - AST_Node *scope_next = dst->next_scope; - *dst = *src; - dst->next_scope = scope_next; -} - -function AST_Node * -ast_type_pointer(Parser *p, Token *token, AST_Node *pointer_to){ - AST_Node *node = ast_node_new(p, AK_Pointer, token, intern_empty); - node->pointer = pointer_to; - return node; -} - -function AST_Node * -ast_type_array(Parser *p, Token *token, AST_Node *pointer_to, Expr *expr){ - AST_Node *node = ast_node_new(p, AK_Array, token, intern_empty); - node->pointer = pointer_to; - node->expr = expr; - return node; -} - -function void -ast_node_pass_note_list(AST_Node *node, AST_Node *notes){ - node->first_note = notes->first_note; - node->last_note = notes->last_note; -} - -function void -ast_node_push_note(AST_Node *node, AST_Node *child){ - SLLQueuePush(node->first_note, node->last_note, child); -} - -function void -ast_node_push_child(AST_Node *node, AST_Node *child){ - SLLQueuePush(node->first_child, node->last_child, child); -} diff --git a/expr.c b/expr.c index b4624e7..e66330f 100644 --- a/expr.c +++ b/expr.c @@ -53,6 +53,7 @@ expr_index(Parser *p, Token *token, Expr *atom, Expr *index){ return expr; } +/* function Expr * expr_cast(Parser *p, Token *token, AST_Node *type, Expr *exp){ Expr *expr = expr_new(p, EK_Cast, token); @@ -60,6 +61,7 @@ expr_cast(Parser *p, Token *token, AST_Node *type, Expr *exp){ expr->cast.expr = exp; return expr; } + */ function Expr * expr_list(Parser *p, Token *token){ diff --git a/expr.h b/expr.h index 12d12a3..fd19b4a 100644 --- a/expr.h +++ b/expr.h @@ -19,7 +19,7 @@ struct Expr { Expr *next; union { struct { - AST_Node *type; + //Typespec *type; Expr* expr; } cast; struct { diff --git a/ideas.cpp b/ideas.cpp index 25bc94b..ac46da9 100644 --- a/ideas.cpp +++ b/ideas.cpp @@ -1,8 +1,38 @@ -call:(param:U32)U32{ +Thingy::enum{ + @str=10 Value = 1, } +Thing::union{ + union:{ + } + struct:{ + } + +} + +Thing::struct{ + data: U32; + + inside_call :: (param: U32){ + } + +} + +call :: (param:U32) U32{ + inner_call :: (param2:U32){ + size_of_s64 = sizeof(:S64); + size_of_val = sizeof(param); + + + param2 + 10; + return; + } + + inner_call(); +} + @stringify Enumeration:enum{ None, @@ -13,7 +43,11 @@ Enumeration:enum{ @sllqueue() @sllqueue(prefix=thing_scope, next=next_scope) -Thing:struct{ +Thing::struct{ + Inner_Struct :: { + test_val : U32; + } + thing:Inner_Struct; next: Thing*; first: Thing*; last: Thing*; diff --git a/lex.c b/lex.c index 1439061..1ad524b 100644 --- a/lex.c +++ b/lex.c @@ -111,20 +111,9 @@ parse_u64(U8 *str, S64 len){ return result; } -function void -token_push_error(Lex_Stream *stream, Tokens *tokens, String error_val){ - Token *token = token_alloc(tokens); - token->kind = TK_Error; - token->error_val = error_val; - lex_token_seed(stream, token); -} - function void lex_base(Lex_Stream *s, Tokens *tokens){ while(*s->stream){ - while(lex_is_whitespace(*s->stream)) - lex_advance(s); - #define CASE2(op, OpName, Assign) \ case op: \ @@ -148,29 +137,13 @@ t->kind = OpName; } \ break - Token *t = token_alloc(tokens); - if(0){ - top: - while(lex_is_whitespace(*s->stream)) - lex_advance(s); - if(lexc(s) == 0) - break; - } + top: + while(lex_is_whitespace(*s->stream)) + lex_advance(s); lex_token_seed(s, t); lex_advance(s); switch(*t->str) { - CASE2('!', TK_Not, TK_NotEquals); - CASE2('^', TK_BitXor, TK_XorAssign); - CASE2('=', TK_Assign, TK_Equals); - CASE2('*', TK_Mul, TK_MulAssign); - CASE2('%', TK_Mod, TK_ModAssign); - CASE3('+', TK_Add, TK_AddAssign, TK_Increment); - CASE3('&', TK_BitAnd, TK_AndAssign, TK_And); - CASE3('|', TK_BitOr, TK_OrAssign, TK_Or); -#undef CASE2 -#undef CASE3 - case 0: break; case '@': t->kind = TK_At; break; case '(': t->kind = TK_OpenParen; break; @@ -183,6 +156,16 @@ break case '~': t->kind = TK_Neg; break; case '?': t->kind = TK_Question; break; case ';': t->kind = TK_Semicolon; break; + CASE2('!', TK_Not, TK_NotEquals); + CASE2('^', TK_BitXor, TK_XorAssign); + CASE2('=', TK_Assign, TK_Equals); + CASE2('*', TK_Mul, TK_MulAssign); + CASE2('%', TK_Mod, TK_ModAssign); + CASE3('+', TK_Add, TK_AddAssign, TK_Increment); + CASE3('&', TK_BitAnd, TK_AndAssign, TK_And); + CASE3('|', TK_BitOr, TK_OrAssign, TK_Or); +#undef CASE2 +#undef CASE3 case '#': { t->kind = TK_Pound; diff --git a/main.c b/main.c index b79492b..ed73962 100644 --- a/main.c +++ b/main.c @@ -7,7 +7,6 @@ #include "memory.h" #include "lex.h" -#include "ast.h" #include "parser.h" #include "expr.h" @@ -22,10 +21,8 @@ global FILE *global_output_file; #include "lex.c" #include "expr.c" -#include "ast.c" #include "parse_expr.c" #include "parse_decl.c" -#include "print.c" function void lex_test(){ @@ -86,52 +83,19 @@ parser_test(){ lit("5--"), // @Todo(Krzosa): lit("-5"), lit("(+5)"), - lit("(S64)5"), - lit("(S64)5+3"), + lit("cast(S64)5"), + lit("cast(S64)5+3"), lit("534>43?435:42"), - lit("(534>43?435:42,234,(S64)42,Thing[10][2],Thing(1,2))"), + lit("(534>43?435:42,234,cast(S64)42,Thing[10][2],Thing(1,2))"), }; for(S64 i = 0; i < buff_cap(exprs); i++){ parser_lex_stream(&p, exprs[i], lit("File")); Expr *expr = parse_expr(&p); assert(expr); - //expr_print(expr); - //lex_print("\n"); + expr_print(expr); + lex_print("\n"); } - String decls = os_read_file(lit("ast.h")); - parser_lex_stream(&p, decls, lit("File")); - AST_Node *node = parse(&p); - assert(node->first_child); - assert(node->last_child); - ast_print(node); - - for(AST_Node *n = node->first_child; n; n=n->next){ - if(n->kind == AK_Enum){ - AST_Node *prefix = ast_find_note(n, lit("prefix")); - lex_print("global String %s_metadata[] = {\n", n->name.s.str); - for(AST_Node *member = n->first_child; member; member=member->next){ - lex_print("["); - if(prefix) expr_print(prefix->expr); - lex_print("%s] = ", member->name.s.str); - AST_Node *str = ast_find_note(member, lit("str")); - lex_print("lit(\""); - if(str){ - expr_print(str->expr); - } - else { - lex_print("%s", member->name.s.str); - } - lex_print("\")"); - lex_print(",\n"); - } - lex_print("};\n"); - - } - else if(n->kind == AK_Struct){ - gen_struct(n, (Intern_String){}); - } - } } function S32 @@ -141,37 +105,6 @@ os_main(){ lex_test(); parser_test(); - String_Map maps[] = { - {lit("cap"), lit("cap")}, - {lit("len"), lit("len")}, - {lit("data"), lit("tokens")}, - {lit("parent_type"), lit("Tokens")}, - {lit("parent_type_lower"), lit("tokens")}, - {lit("var_type_lower"), lit("token")}, - {lit("var_type"), lit("Token")}, - {lit("var_name"), lit("tokens")}, - }; - - - /* - String keywords[]={ - lit("S64"), - lit("U64"), - lit("void"), - lit("SizeU"), - lit("struct"), - lit("union"), - lit("function"), - lit("global"), - }; - - for(S64 i = 0; i < buff_cap(keywords); i++){ - lex_print("global Intern_String keyword_%s;\n", keywords[i].str); - } - for(S64 i = 0; i < buff_cap(keywords); i++){ - lex_print("keyword_%s = intern_string(p, lit(\"%s\"));\n", keywords[i].str, keywords[i].str); - } - */ fclose(global_output_file); return 0; diff --git a/output.cc b/output.cc index 045926d..e69de29 100644 --- a/output.cc +++ b/output.cc @@ -1,391 +0,0 @@ -typedef struct OS_Memory OS_Memory; -struct OS_Memory{ -void *data; -SizeU commit; -SizeU reserve; -}; - -typedef struct Arena Arena; -struct Arena{ -union{ -OS_Memory memory; -struct { -void *data; -SizeU commit; -SizeU reserve; -}; -} -U64 len; -U64 alignment; -}; - -typedef struct String String; -struct String{ -U8 *str; -S64 len; -}; - -typedef String Intern_String; -typedef enum Token_Kind{ - TK_End, - TK_Mul, - TK_Div, - TK_Add, - TK_Sub, - TK_Mod, - TK_BitAnd, - TK_BitOr, - TK_BitXor, - TK_Neg, - TK_Not, - TK_OpenParen, - TK_CloseParen, - TK_OpenBrace, - TK_CloseBrace, - TK_OpenBracket, - TK_CloseBracket, - TK_Comma, - TK_Pound, - TK_Question, - TK_ThreeDots, - TK_Semicolon, - TK_Dot, - TK_LesserThen, - TK_GreaterThen, - TK_Colon, - TK_Assign, - TK_DivAssign, - TK_MulAssign, - TK_ModAssign, - TK_SubAssign, - TK_AddAssign, - TK_AndAssign, - TK_OrAssign, - TK_XorAssign, - TK_LeftShiftAssign, - TK_RightShiftAssign, - TK_DoubleColon, - TK_At, - TK_Decrement, - TK_Increment, - TK_PostDecrement, - TK_PostIncrement, - TK_LesserThenOrEqual, - TK_GreaterThenOrEqual, - TK_Equals, - TK_And, - TK_Or, - TK_NotEquals, - TK_LeftShift, - TK_RightShift, - TK_Arrow, - TK_ExprSizeof, - TK_DocComment, - TK_Comment, - TK_Identifier, - TK_StringLit, - TK_U8Lit, - TK_Character, - TK_Error, - TK_Float, - TK_Int, - TK_Keyword, -}Token_Kind; - -typedef struct Token Token; -struct Token{ -Token_Kind kind; -union{ -String string; -struct { -U8 *str; -S64 len; -}; -} -union { -S64 int_val; -String error_val; -Intern_String intern_val; -}; -String file; -S64 line; -U8 *line_begin; -}; - -typedef struct Tokens Tokens; -struct Tokens{ -Token *tokens; -S64 len; -S64 cap; -S64 iter; -}; - -typedef struct Lex_Stream Lex_Stream; -struct Lex_Stream{ -U8 *stream; -U8 *line_begin; -String filename; -S64 line; -}; - -typedef enum Expr_Kind{ - EK_None, - EK_Atom, - EK_Unary, - EK_Binary, - EK_Ternary, - EK_Cast, - EK_List, - EK_Call, - EK_Index, -}Expr_Kind; - -typedef enum AST_Kind{ - AK_None, - AK_BaseType, - AK_Typedef, - AK_Enum, - AK_Struct, - AK_Union, - AK_Note, - AK_List, - AK_Pointer, - AK_Array, - AK_Function, - AK_Variable, - AK_EnumChild, -}AST_Kind; - -typedef struct AST_Node AST_Node; -struct AST_Node{ -AST_Kind kind; -Token *pos; -Intern_String name; -AST_Node *next; -AST_Node *next_scope; -AST_Node *first_note; -AST_Node *last_note; -AST_Node *first_child; -AST_Node *last_child; -union { -SizeU base_type_size; -AST_Node *pointer; -AST_Node *typedef_type; -AST_Node *variable_type; -AST_Node *func_return_type; -}; -}; - -typedef struct Parser_Error Parser_Error; -struct Parser_Error{ -Parser_Error *next; -String message; -Token *token; -}; - -typedef struct Scope Scope; -struct Scope{ -Scope *next; -AST_Node *first; -AST_Node *last; -}; - -typedef struct Parser Parser; -struct Parser{ -Arena main_arena; -Arena intern_table_arena; -Arena symbol_table_arena; -Scope *scope_free_list; -Scope *scope_stack; -Scope *global_scope; -S64 symbols_inserted; -S64 symbols_count; -AST_Node *symbols; -Intern_String *interns; -S64 interns_in_bytes; -S64 interns_inserted; -S64 interns_count; -U8 *first_keyword; -U8 *last_keyword; -Parser_Error *first_default; -Parser_Error *last_default; - -Parser_Error *first_error; -Parser_Error *last_error; - -union{ -Tokens token_array; -struct { -Token *tokens; -S64 len; -S64 cap; -S64 iter; -}; -} -}; - -global String Token_Kind_metadata[] = { -[TK_End] = lit("End of stream"), -[TK_Mul] = lit("*"), -[TK_Div] = lit("/"), -[TK_Add] = lit("+"), -[TK_Sub] = lit("-"), -[TK_Mod] = lit("%"), -[TK_BitAnd] = lit("&"), -[TK_BitOr] = lit("|"), -[TK_BitXor] = lit("^"), -[TK_Neg] = lit("~"), -[TK_Not] = lit("!"), -[TK_OpenParen] = lit("("), -[TK_CloseParen] = lit(" "), -[TK_OpenBrace] = lit("{"), -[TK_CloseBrace] = lit("}"), -[TK_OpenBracket] = lit("["), -[TK_CloseBracket] = lit("]"), -[TK_Comma] = lit(","), -[TK_Pound] = lit("#"), -[TK_Question] = lit("?"), -[TK_ThreeDots] = lit("..."), -[TK_Semicolon] = lit(";"), -[TK_Dot] = lit("."), -[TK_LesserThen] = lit("<"), -[TK_GreaterThen] = lit(">"), -[TK_Colon] = lit(":"), -[TK_Assign] = lit("="), -[TK_DivAssign] = lit("/="), -[TK_MulAssign] = lit("*="), -[TK_ModAssign] = lit("%="), -[TK_SubAssign] = lit("-="), -[TK_AddAssign] = lit("+="), -[TK_AndAssign] = lit("&="), -[TK_OrAssign] = lit("|="), -[TK_XorAssign] = lit("^="), -[TK_LeftShiftAssign] = lit("<<="), -[TK_RightShiftAssign] = lit(">>="), -[TK_DoubleColon] = lit("::"), -[TK_At] = lit("@"), -[TK_Decrement] = lit("--"), -[TK_Increment] = lit("++"), -[TK_PostDecrement] = lit("--"), -[TK_PostIncrement] = lit("++"), -[TK_LesserThenOrEqual] = lit("<="), -[TK_GreaterThenOrEqual] = lit(">="), -[TK_Equals] = lit("=="), -[TK_And] = lit("&&"), -[TK_Or] = lit("||"), -[TK_NotEquals] = lit("!="), -[TK_LeftShift] = lit("<<"), -[TK_RightShift] = lit(">>"), -[TK_Arrow] = lit("->"), -[TK_ExprSizeof] = lit("sizeof"), -[TK_DocComment] = lit("DocComment"), -[TK_Comment] = lit("Comment"), -[TK_Identifier] = lit("Identifier"), -[TK_StringLit] = lit("StringLit"), -[TK_U8Lit] = lit("U8Lit"), -[TK_Character] = lit("Character"), -[TK_Error] = lit("Error"), -[TK_Float] = lit("Float"), -[TK_Int] = lit("Int"), -[TK_Keyword] = lit("Keyword"), -}; -function - Token*Tokens_array_push_empty(Tokens*a){ -if(a->cap==0){ -a->cap=1024; -a->tokens=malloc(sizeof(Token)*a->cap); -} -else if(a->len+1>a->cap){ -a->cap*=2; -a->tokens=realloc(a->tokens,sizeof(Token)*a->cap); -} -Token*result=a->tokens+a->len++; -memory_zero(result,sizeof(*result)); -return result; -} -global String Expr_Kind_metadata[] = { -[EK_None] = lit("None"), -[EK_Atom] = lit("Atom"), -[EK_Unary] = lit("Unary"), -[EK_Binary] = lit("Binary"), -[EK_Ternary] = lit("Ternary"), -[EK_Cast] = lit("Cast"), -[EK_List] = lit("List"), -[EK_Call] = lit("Call"), -[EK_Index] = lit("Index"), -}; -global String AST_Kind_metadata[] = { -[AK_None] = lit("None"), -[AK_BaseType] = lit("BaseType"), -[AK_Typedef] = lit("Typedef"), -[AK_Enum] = lit("Enum"), -[AK_Struct] = lit("Struct"), -[AK_Union] = lit("Union"), -[AK_Note] = lit("Note"), -[AK_List] = lit("List"), -[AK_Pointer] = lit("Pointer"), -[AK_Array] = lit("Array"), -[AK_Function] = lit("Function"), -[AK_Variable] = lit("Variable"), -[AK_EnumChild] = lit("EnumChild"), -}; -function - void parser_default_push(Parser*parent,Parser_Error*child){ -if(parent->first==0){ -parent->first=parent->last=child; -} -else{ -parent->last=parent->last->next=child; -} -} -function - Parser_Error*parser_default_pop_first(Parser*parent){ -if(parent->first==parent->last){ -Parser_Error*node=parent->first; -parent->first=parent->last=0; -return node; -} -else if(parent->first){ -Parser_Error*node=parent->first; -parent->first=parent->first->next; -} -return 0; -} - -function - void parser_error_push(Parser*parent,Parser_Error*child){ -if(parent->first_error==0){ -parent->first_error=parent->last_error=child; -} -else{ -parent->last_error=parent->last_error->next_error=child; -} -} -function - Parser_Error*parser_error_pop_first(Parser*parent){ -if(parent->first_error==parent->last_error){ -Parser_Error*node=parent->first_error; -parent->first_error=parent->last_error=0; -return node; -} -else if(parent->first_error){ -Parser_Error*node=parent->first_error; -parent->first_error=parent->first_error->next_error; -} -return 0; -} - -function - Token*Parser_array_push_empty(Parser*a){ -if(a->cap==0){ -a->cap=1024; -a->tokens=malloc(sizeof(Token)*a->cap); -} -else if(a->len+1>a->cap){ -a->cap*=2; -a->tokens=realloc(a->tokens,sizeof(Token)*a->cap); -} -Token*result=a->tokens+a->len++; -memory_zero(result,sizeof(*result)); -return result; -} diff --git a/parse_decl.c b/parse_decl.c index b30f32c..36f71b7 100644 --- a/parse_decl.c +++ b/parse_decl.c @@ -1,4 +1,4 @@ - +#if 0 function Token * parse__get_name(Parser *p){ @@ -217,4 +217,5 @@ parse(Parser *p){ } return result; -} \ No newline at end of file +} +#endif \ No newline at end of file diff --git a/parse_expr.c b/parse_expr.c index 7fad771..e00a1ba 100644 --- a/parse_expr.c +++ b/parse_expr.c @@ -90,28 +90,30 @@ Expr* parse_unary_expr(Parser* p) { result = parse_unary_expr(p); result = expr_unary(p, token, result); } - else if (token_is(p, TK_OpenParen)) { // cast requires lookahead - Token *token = token_peek(p, 1); - if (token->kind == TK_Identifier) { - - AST_Node *type = symbol_lookup_type(p, token->intern_val); - if(type){ - token_next(p); - token_next(p); - // @Todo(Krzosa): Parse pointer types - token_expect(p, TK_CloseParen); - result = parse_unary_expr(p); - result = expr_cast(p, token, type, result); + /* + else if (token_is(p, TK_OpenParen)) { // cast requires lookahead + Token *token = token_peek(p, 1); + if (token->kind == TK_Identifier) { + + AST_Node *type = symbol_lookup_type(p, token->intern_val); + if(type){ + token_next(p); + token_next(p); + // @Todo(Krzosa): Parse pointer types + token_expect(p, TK_CloseParen); + result = parse_unary_expr(p); + result = expr_cast(p, token, type, result); + } + else { + result = parse_postfix_expr(p); + } + } else { result = parse_postfix_expr(p); } - } - else { - result = parse_postfix_expr(p); - } - } + */ else { result = parse_postfix_expr(p); } diff --git a/parser.c b/parser.c index 2128311..d721454 100644 --- a/parser.c +++ b/parser.c @@ -21,27 +21,11 @@ global Intern_String keyword_union; 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; - function void parser_init(Parser *p){ - p->interns_count = 4096; + p->interns_count = 4096*2; p->interns = arena_push_array(&p->intern_table_arena, Intern_String, p->interns_count); - p->symbols_count = 4096; - p->symbols = arena_push_array(&p->symbol_table_arena, AST_Node, p->symbols_count); - keyword_sizeof = intern_string(p, lit("sizeof")); keyword_struct = intern_string(p, lit("struct")); keyword_enum = intern_string(p, lit("enum")); @@ -65,22 +49,6 @@ parser_init(Parser *p){ 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, 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)); - } function B32 @@ -189,139 +157,3 @@ intern_string(Parser *p, String string){ return result; } - -//----------------------------------------------------------------------------- -// Symbols -//----------------------------------------------------------------------------- -function AST_Node * -symbol_alloc_slot(Parser *p, Intern_String string, B32 is_global){ - Table_Index index = table_index_from_string(string.s, p->symbols_count); - for(;;){ - AST_Node *symbol = p->symbols + index.iter; - - if(symbol->name.s.str == 0){ - /* @Note(Krzosa): Push on scope */ { - if(is_global){ - SLLQueuePushMod(p->scope_stack->first, p->scope_stack->last, symbol, next_scope); - } - else{ - SLLQueuePushMod(p->global_scope->first, p->global_scope->last, symbol, next_scope); - } - } - symbol->name = string; - p->symbols_inserted++; - - return symbol; - } - else if(intern_compare(symbol->name, string)){ - return symbol; - } - - if (table_index_advance(&index)) - break; - } - - assert_msg(0, "Ran out of slots in symbol table"); - return 0; -} - -function AST_Node * -symbol_lookup(Parser *p, Intern_String string){ - Table_Index index = table_index_from_string(string.s, p->symbols_count); - for(;;){ - AST_Node *symbol = p->symbols + index.iter; - - if(symbol->name.s.str == 0){ - return 0; - } - else if(intern_compare(symbol->name, string)){ - return symbol; - } - - if (table_index_advance(&index)) - return 0; - } -} - -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); - if(node){ - if(ast_is_type(node)){ - return node; - } - } - 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; - SLLStackPop(p->scope_free_list, scope); - if(!scope){ - scope = arena_push_struct(&p->main_arena, Scope); - } - SLLStackPush(p->scope_stack, scope); - if(p->global_scope == 0){ - p->global_scope = scope; - } -} - -function void -parser_pop_scope(Parser *p){ - Scope *scope = 0; - SLLStackPop(p->scope_stack, scope); - assert(scope); - - for(AST_Node *s = scope->first; s; s=s->next_scope){ - memory_zero(s, sizeof(AST_Node)); - p->symbols_inserted--; - } - memory_zero(scope, sizeof(Scope)); - SLLStackPush(p->scope_free_list, scope); -} diff --git a/parser.h b/parser.h index f488b44..99494d3 100644 --- a/parser.h +++ b/parser.h @@ -1,7 +1,5 @@ #pragma once typedef struct Expr Expr; -typedef struct Scope Scope; -typedef struct AST_Node AST_Node; typedef struct Parser_Error Parser_Error; struct Parser_Error{ @@ -10,25 +8,11 @@ struct Parser_Error{ Token *token; }; -struct Scope{ - Scope *next; - AST_Node *first; - AST_Node *last; -}; - typedef struct Parser{ Arena main_arena; Arena intern_table_arena; Arena symbol_table_arena; - Scope *scope_free_list; - Scope *scope_stack; - Scope *global_scope; - - S64 symbols_inserted; - AST_Node *symbols; - S64 symbols_count; - S64 interns_in_bytes; S64 interns_inserted; Intern_String *interns; @@ -45,7 +29,4 @@ typedef struct Parser{ function Intern_String intern_string(Parser *p, String string); function Token *token_get(Parser *p); -function B32 intern_compare(Intern_String a, Intern_String b); -function void parser_push_scope(Parser *p); -function AST_Node *symbol_register_basic_type(Parser *p, Intern_String string, SizeU size); -function void ast_copy_symbol(AST_Node *dst, AST_Node *src); \ No newline at end of file +function B32 intern_compare(Intern_String a, Intern_String b); \ No newline at end of file diff --git a/print.c b/print.c deleted file mode 100644 index 540bf91..0000000 --- a/print.c +++ /dev/null @@ -1,415 +0,0 @@ - -function void -tokens_print(Tokens tokens){ - lex_print("\n== Token count = %d\n", (S32)tokens.len); - for(Token *t = tokens.tokens; t != tokens.tokens + tokens.len; t++){ - lex_print("%s \"%.*s\"\n", token_kind_string[t->kind].str, (S32)t->len, t->str); - } -} - -function void -token_print(Token *token){ - lex_print("%.*s", (S32)token->len, token->str); -} - -function void -expr_print(Expr *expr){ - switch(expr->kind) { - case EK_Atom: { - token_print(expr->token); - } break; - - case EK_Binary:{ - lex_print("("); - expr_print(expr->binary.left); - token_print(expr->token); - expr_print(expr->binary.right); - lex_print(")"); - } break; - case EK_Unary:{ - lex_print("("); - token_print(expr->token); - expr_print(expr->unary.expr); - lex_print(")"); - } break; - - case EK_Ternary:{ - lex_print("("); - expr_print(expr->ternary.cond); - lex_print("?"); - expr_print(expr->ternary.on_true); - lex_print(":"); - expr_print(expr->ternary.on_false); - lex_print(")"); - } break; - case EK_List:{ - lex_print("("); - for(Expr *n = expr->list.first; n; n=n->next){ - expr_print(n); - if(n!=expr->list.last) lex_print(","); - } - lex_print(")"); - }break; - - case EK_Cast:{ - lex_print("("); - lex_print("("); - //type_print(expr->cast.type); - lex_print(")"); - expr_print(expr->cast.expr); - lex_print(")"); - } break; - - case EK_Index:{ - expr_print(expr->index.atom); - lex_print("["); - expr_print(expr->index.index); - lex_print("]"); - }break; - - case EK_Call:{ - expr_print(expr->call.atom); - expr_print(expr->call.list); - }break; - default: {invalid_codepath;} break; - } -} - -function void -print_indent(S64 indent){ - for(S64 i = 0; i < indent; i++){ - lex_print(" "); - } -} - -function AST_Node * -ast_get_basis_type(AST_Node *node){ - switch(node->kind) { - case AK_Struct: case AK_Union: case AK_Enum: case AK_BaseType:{return node;} break; - case AK_Function:{return node;} break; - case AK_Typedef:{return node;} break; - case AK_Array: case AK_Pointer:{return ast_get_basis_type(node->pointer);} break; - default: invalid_codepath; - } - return 0; -} - -function void -ast_print_pointers(AST_Node *node){ - if(node->kind == AK_Pointer){ - lex_print("*"); - ast_print_pointers(node->pointer); - } - else if(node->kind == AK_Array){ - ast_print_pointers(node->pointer); - } -} - -function void -ast_print_arrays(AST_Node *node){ - if(node->kind == AK_Pointer){ - ast_print_arrays(node->pointer); - } - else if(node->kind == AK_Array){ - lex_print("["); - expr_print(node->expr); - lex_print("]"); - ast_print_arrays(node->pointer); - } -} - -function void -ast_print_var(AST_Node *node); -function void -ast_print_func_params(AST_Node *node){ - for(AST_Node *n = node->first_child; n; n=n->next){ - ast_print_var(n); - if(n != node->last_child) lex_print(", "); - } -} - -function void -ast_print_var(AST_Node *node){ - AST_Node *basis_type = ast_get_basis_type(node->variable_type); - if(basis_type->kind == AK_Function){ - lex_print("%s (*%s)(", basis_type->func_return_type->name.s.str, node->name.s.str); - ast_print_func_params(basis_type); - lex_print(")"); - } - else{ - lex_print("%s ", basis_type->name.s.str); - ast_print_pointers(node->variable_type); - lex_print("%s", node->name.s.str); - ast_print_arrays(node->variable_type); - } - - if(node->expr){ - lex_print(" = "); - expr_print(node->expr); - } -} - -function AST_Node * -ast_find_note(AST_Node *node, String string){ - for(AST_Node *n = node->first_note; n; n=n->next){ - if(string_compare(n->name.s, string)){ - return n; - } - } - return 0; -} - -function String -ast_find_string(AST_Node *node, String string, String default_val){ - AST_Node *find = ast_find_note(node, string); - if(find){ - if(find->expr->kind == EK_Atom){ - return find->expr->token->string; - } - } - return default_val; -} - -global Arena todo_arena; - -function void -ast__print(AST_Node *node, S64 indent){ - switch(node->kind){ - - case AK_List:{ - for(AST_Node *n = node->first_child; n; n=n->next){ - ast__print(n, indent); - lex_print("\n"); - } - } break; - - case AK_Union: - case AK_Struct:{ - const char *type = node->kind == AK_Struct ? "struct":"union"; - if(indent == 0) lex_print("typedef %s %s %s;\n", type, node->name.s.str, node->name.s.str); - lex_print("%s %s{\n", type, indent == 0 ? node->name.s.str:(U8 *)""); - for(AST_Node *n = node->first_child; n; n=n->next){ - AST_Node *using_note = ast_find_note(n, lit("using")); - AST_Node *array_note = ast_find_note(n, lit("array")); - AST_Node *sllqueue_note = ast_find_note(n, lit("sllqueue")); - if(using_note) { - assert(n->kind == AK_Variable); - lex_print("union{\n"); - ast__print(n, indent+2); - lex_print("\n"); - Intern_String name = n->variable_type->name; - n->variable_type->name = (Intern_String){0}; - assert(n->variable_type->kind == AK_Struct || n->variable_type->kind == AK_Union); - ast__print(n->variable_type, indent+2); - n->variable_type->name = name; - lex_print("\n}"); - } - else if(array_note){ - AST_Node *cap = ast_find_note(n, lit("cap")); - AST_Node *len = ast_find_note(n, lit("len")); - ast__print(n, indent+2); - lex_print("\nS64 len;\nS64 cap;"); - } - else if(sllqueue_note){ - lex_print("%s *first_%s;\n", n->variable_type->name.s.str, string_to_lower(&todo_arena, n->name.s).str); - lex_print("%s *last_%s;\n", n->variable_type->name.s.str, string_to_lower(&todo_arena, n->name.s).str); - } - else { - ast__print(n, indent+2); - } - lex_print("\n"); - } - - lex_print("}"); - lex_print("%s;", indent == 0 ? (U8 *)"":node->name.s.str?node->name.s.str:(U8*)""); - if(indent == 0) lex_new_line(); - } break; - - case AK_Variable:{ - if(indent == 0) lex_print("global "); - ast_print_var(node); - lex_print(";"); - } break; - - case AK_Typedef:{ - lex_print("typedef "); - ast_print_var(node); - lex_print(";"); - } break; - - case AK_Enum:{ - print_indent(indent); - lex_print("typedef enum %s{\n", node->name.s.str); - AST_Node *prefix = ast_find_note(node, lit("prefix")); - - for(AST_Node *n = node->first_child; n; n=n->next){ - print_indent(indent+2); - if(prefix){ - expr_print(prefix->expr); - } - lex_print("%s", n->name.s.str); - if(n->expr){ - lex_print(" = "); - expr_print(n->expr); - } - lex_print(",\n"); - } - - print_indent(indent); - lex_print("}%s;\n", node->name.s.str); - } break; - - default: invalid_codepath; - } -} - -function void -ast_print(AST_Node *node){ - ast__print(node, 0); -} - -function B32 -intern_is_empty(Intern_String string){ - if(string.s.str == 0) - return true; - return false; -} - -typedef struct String_Map{ - String replace; - String with; -}String_Map; - -function B32 -token_is_number(Token *token){ - B32 result = token->kind == TK_Int; - return result; -} - -function void -print_string_replaced(String string, String_Map *maps, SizeU count){ - Tokens tokens = lex_stream(string, lit("Replace")); - for(S64 i = 0; i < tokens.len; i++){ - Token *t = tokens.tokens + i; - if(t->kind == TK_At) continue; - for(String_Map *map = maps; map != maps+count; map++){ - if(string_compare(map->replace, t->string)){ - t->string = map->with; - } - } - - lex_print("%.*s", (S32)t->string.len, t->string.str); - if(t->kind == TK_Keyword) lex_print(" "); - if(t->kind == TK_Identifier && - (t[1].kind== TK_Identifier || token_is_number(t+1))) lex_print(" "); - if(t->kind == TK_OpenBrace) lex_print("\n"); - if(t->kind == TK_CloseBrace) lex_print("\n"); - if(t->kind == TK_Semicolon) lex_print("\n"); - } - free(tokens.tokens); - -} - -function void -gen_struct(AST_Node *n, Intern_String shadow_type_name){ - for(AST_Node *member = n->first_child; member; member=member->next){ - AST_Node *using_note = ast_find_note(member, lit("using")); - AST_Node *array_note = ast_find_note(member, lit("array")); - AST_Node *sllqueue_note = ast_find_note(member, lit("sllqueue")); - if(using_note){ - gen_struct(member->variable_type, n->name); - } - if(array_note){ - AST_Node *array_type = ast_get_basis_type(member->variable_type); - - Intern_String type_name = n->name; - if(!intern_is_empty(shadow_type_name)) - type_name = shadow_type_name; - - - String_Map maps[] = { - {lit("function"), lit("function\n")}, - {lit("base_type"), type_name.s}, - {lit("base_type_lower"), string_to_lower(&todo_arena, type_name.s)}, - {lit("var_type"), array_type->name.s}, - {lit("var_type_lower"), string_to_lower(&todo_arena, array_type->name.s)}, - {lit("var_name"), member->name.s}, - {lit("var_name_lower"), string_to_lower(&todo_arena, member->name.s)}, - {lit("len"), ast_find_string(array_note, lit("len"), lit("len"))}, - {lit("cap"), ast_find_string(array_note, lit("cap"), lit("cap"))}, - {lit("data"), ast_find_string(array_note, lit("data"), lit("data"))}, - }; - - - String a - = lit("function var_type *base_type@_array_push_empty(base_type *a){" - "if(a->cap == 0){\n" - " a->cap = 1024;\n" - " a->tokens = malloc(sizeof(var_type)*a->cap);\n" - "}\n" - "else if(a->len+1 > a->cap){\n" - " a->cap *= 2;\n" - " a->tokens = realloc(a->tokens, sizeof(var_type)*a->cap);\n" - "}\n" - - "var_type *result = a->tokens + a->len++;\n" - "memory_zero(result, sizeof(*result));\n" - "return result;}"); - print_string_replaced(a, maps, buff_cap(maps)); - } - if(sllqueue_note){ - String default_first = lit("first"); - String default_last = lit("last"); - String default_next = lit("next"); - if(!string_compare(member->name.s, lit("default"))){ - default_first = string_fmt(&todo_arena, "first_%s", member->name.s.str); - default_last = string_fmt(&todo_arena, "last_%s", member->name.s.str); - default_next = string_fmt(&todo_arena, "next_%s", member->name.s.str); - } - - String_Map maps[] = { - {lit("function"), lit("function\n")}, - {lit("base_type"), n->name.s}, - {lit("base_type_lower"), string_to_lower(&todo_arena, n->name.s)}, - {lit("var_type"), member->variable_type->name.s}, - {lit("var_type_lower"), string_to_lower(&todo_arena, member->variable_type->name.s)}, - {lit("var_name"), member->name.s}, - {lit("var_name_lower"), string_to_lower(&todo_arena, member->name.s)}, - {lit("next"), ast_find_string(sllqueue_note, lit("next"), default_next)}, - {lit("first"), ast_find_string(sllqueue_note, lit("first"), default_first)}, - {lit("last"), ast_find_string(sllqueue_note, lit("last"), default_last)}, - }; - - String string = - lit( - "function void " - "base_type_lower@_@var_name_lower@_push(base_type *parent, var_type *child){" - "if(parent->first == 0){" - "parent->first = parent->last = child;" - "}" - "else{" - "parent->last = parent->last->next = child;" - "}" - "}" - - "function var_type * " - "base_type_lower@_@var_name_lower@_pop_first(base_type *parent){" - " if(parent->first == parent->last){" - " var_type *node = parent->first;" - " parent->first = parent->last = 0;" - " return node;" - " }" - " else if(parent->first){" - " var_type *node = parent->first;" - " parent->first = parent->first->next;" - " }" - "return 0;" - "}" - - - ); - print_string_replaced(string, maps, buff_cap(maps)); - lex_print("\n"); - } - } -} \ No newline at end of file diff --git a/ast.h b/test.cc similarity index 84% rename from ast.h rename to test.cc index c944148..94f52b4 100644 --- a/ast.h +++ b/test.cc @@ -262,56 +262,3 @@ struct_type_lower_var_name_lower_push(struct_type *parent, var_type *child){ */ #endif - - -typedef struct AST_Node AST_Node; -typedef struct Expr Expr; - -typedef enum AST_Kind{ - AK_None, - - AK_BaseType, - AK_Typedef, - AK_Enum, - AK_Struct, - AK_Union, - - AK_Identifier, - AK_Note, - AK_List, - - AK_Pointer, - AK_Array, - AK_Function, - AK_Variable, - AK_EnumChild, -}AST_Kind; - -struct AST_Node{ - AST_Kind kind; - Token *pos; - Expr *expr; - Intern_String name; - - AST_Node *next; - AST_Node *next_scope; - - AST_Node *first_note; - AST_Node *last_note; - - AST_Node *first_child; - AST_Node *last_child; - union{ - SizeU base_type_size; - AST_Node *pointer; - AST_Node *typedef_type; - AST_Node *variable_type; - AST_Node *func_return_type; - }; -}; - -function B32 -ast_is_type(AST_Node *n){ - B32 result = n->kind >= AK_BaseType && n->kind <= AK_Union; - return result; -}