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

Delete previous progress

Browse Source
This commit is contained in:
Krzosa Karol
2022-05-02 09:49:22 +02:00
parent 6d68fd07aa
commit 3c376bbe30
13 changed files with 81 additions and 1274 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
ast.c
View File

@@ -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);
}

2
expr.c
View File

@@ -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){

2
expr.h
View File

@@ -19,7 +19,7 @@ struct Expr {
Expr *next;
union {
struct {
AST_Node *type;
//Typespec *type;
Expr* expr;
} cast;
struct {

38
ideas.cpp
View File

@@ -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*;

37
lex.c
View File

@@ -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;
}
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;

77
main.c
View File

@@ -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;

391
output.cc
View File

@@ -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;
}

3
parse_decl.c
View File

@@ -1,4 +1,4 @@
#if 0
function Token *
parse__get_name(Parser *p){
@@ -218,3 +218,4 @@ parse(Parser *p){
return result;
}
#endif

2
parse_expr.c
View File

@@ -90,6 +90,7 @@ 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) {
@@ -112,6 +113,7 @@ Expr* parse_unary_expr(Parser* p) {
result = parse_postfix_expr(p);
}
}
*/
else {
result = parse_postfix_expr(p);
}

170
parser.c
View File

@@ -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);
}

19
parser.h
View File

@@ -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;
@@ -46,6 +30,3 @@ 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);

415
print.c
View File

@@ -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");
}
}
}

53
ast.h → test.cc
View File

@@ -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;
}