Recursive lambdas with new system
This commit is contained in:
Krzosa Karol
331
ccodegen.cpp
Normal file
331
ccodegen.cpp
Normal file
@@ -0,0 +1,331 @@
|
||||
|
||||
#define gen(...) pctx->gen.addf(__VA_ARGS__)
|
||||
#define genln(...) do{gen("\n"); gen_indent(); gen(__VA_ARGS__); }while(0)
|
||||
global S32 global_indent;
|
||||
|
||||
function void
|
||||
gen_indent(){
|
||||
for(S32 i = 0; i < global_indent; i++) gen(" ");
|
||||
}
|
||||
|
||||
// @todo: Gen complicated decl
|
||||
//array 10 ( pointer (pointer array 5 int a))
|
||||
// int (*(*(a[5])))[10]
|
||||
//
|
||||
// 1 Get to the bottom
|
||||
// 2 Add variable name
|
||||
// 3 Going backwards add arrays and pointers in parens
|
||||
// 4 Add type name on the left side
|
||||
|
||||
function void
|
||||
gen_simple_decl_prefix(Ast_Resolved_Type *ast){
|
||||
switch(ast->kind){
|
||||
case TYPE_Int: gen("int "); break;
|
||||
case TYPE_Bool: gen("bool "); break;
|
||||
case TYPE_Unsigned: gen("unsigned "); break;
|
||||
case TYPE_String: gen("String "); break;
|
||||
case TYPE_Void: gen("void "); break;
|
||||
case TYPE_Pointer:{gen_simple_decl_prefix(ast->base); gen("*");} break;
|
||||
case TYPE_Array: gen_simple_decl_prefix(ast->base); break;
|
||||
case TYPE_Lambda:break;
|
||||
invalid_default_case;
|
||||
}
|
||||
}
|
||||
|
||||
function void
|
||||
gen_simple_decl_postfix(Ast_Resolved_Type *ast){
|
||||
switch(ast->kind){
|
||||
case TYPE_Int: break;
|
||||
case TYPE_Bool: break;
|
||||
case TYPE_Unsigned: break;
|
||||
case TYPE_String: break;
|
||||
case TYPE_Void: break;
|
||||
case TYPE_Pointer: gen_simple_decl_postfix(ast->base); break;
|
||||
case TYPE_Array: gen("[%d]", (int)ast->arr.size); gen_simple_decl_postfix(ast->arr.base); break;
|
||||
case TYPE_Lambda:break;
|
||||
invalid_default_case;
|
||||
}
|
||||
}
|
||||
|
||||
function void
|
||||
gen_simple_decl(Ast_Resolved_Type *ast, Intern_String name){
|
||||
if(ast->kind == TYPE_Lambda) {
|
||||
gen_simple_decl_prefix(ast->func.ret);
|
||||
gen("(*%s)(", name.str);
|
||||
For(ast->func.args){
|
||||
gen_simple_decl_prefix(it[0]);
|
||||
if(it != ast->func.args.end() - 1) gen(", ");
|
||||
}
|
||||
gen(")");
|
||||
}
|
||||
else{
|
||||
gen_simple_decl_prefix(ast);
|
||||
if(name.len) {
|
||||
gen("%s", name.str);
|
||||
gen_simple_decl_postfix(ast);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function void
|
||||
gen_expr(Ast_Expr *ast){
|
||||
switch(ast->kind){
|
||||
Ast_Begin(AST_IDENT, Ast_Atom){
|
||||
gen("%s", node->intern_val.str);
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
Ast_Begin(AST_INT, Ast_Atom){
|
||||
gen("%lld", node->int_val);
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
Ast_Begin(AST_STR, Ast_Atom){
|
||||
gen("LIT(\"%s\")", node->intern_val.str);
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
Ast_Begin(AST_INDEX, Ast_Index){
|
||||
gen_expr(node->expr);
|
||||
gen("[");
|
||||
gen_expr(node->index);
|
||||
gen("]");
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
Ast_Begin(AST_BINARY, Ast_Binary){
|
||||
gen("(");
|
||||
gen_expr(node->left);
|
||||
gen("%s", token_kind_string(node->op).str);
|
||||
gen_expr(node->right);
|
||||
gen(")");
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
Ast_Begin(AST_UNARY, Ast_Unary){
|
||||
switch(node->op){
|
||||
case TK_Pointer: {
|
||||
gen("(*");
|
||||
gen_expr(node->expr);
|
||||
gen(")");
|
||||
} break;
|
||||
case TK_Dereference: {
|
||||
gen("(&");
|
||||
gen_expr(node->expr);
|
||||
gen(")");
|
||||
} break;
|
||||
invalid_default_case;
|
||||
}
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
Ast_Begin(AST_CAST, Ast_Cast){
|
||||
gen("(");
|
||||
gen("(");
|
||||
gen_simple_decl(resolved_type_get(node->typespec), {});
|
||||
gen(")");
|
||||
gen_expr(node->expr);
|
||||
gen(")");
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
Ast_Begin(AST_COMPOUND, Ast_Compound){
|
||||
gen("(");
|
||||
gen_simple_decl(node->type, {});
|
||||
gen(")");
|
||||
|
||||
gen("{");
|
||||
For(node->exprs){
|
||||
auto comp = it[0];
|
||||
if(comp->name){
|
||||
gen("[");
|
||||
gen_expr(comp->name);
|
||||
gen("] = ");
|
||||
}
|
||||
if(comp->index){
|
||||
gen("[");
|
||||
gen_expr(comp->index);
|
||||
gen("] = ");
|
||||
}
|
||||
assert(comp->item);
|
||||
gen_expr(comp->item);
|
||||
|
||||
if(!node->exprs.is_last(it)) gen(", ");
|
||||
}
|
||||
gen("}");
|
||||
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
invalid_default_case;
|
||||
}
|
||||
}
|
||||
|
||||
function void
|
||||
gen_ast(Ast *ast);
|
||||
function void
|
||||
gen_block(Ast_Block *block){
|
||||
gen("{");
|
||||
global_indent++;
|
||||
For(block->stmts) {
|
||||
genln("");
|
||||
gen_ast(it[0]);
|
||||
}
|
||||
global_indent--;
|
||||
genln("}");
|
||||
}
|
||||
|
||||
function void
|
||||
gen_ast(Ast *ast){
|
||||
switch(ast->kind){
|
||||
|
||||
Ast_Begin(AST_PACKAGE, Ast_Package){
|
||||
For(node->ordered) {
|
||||
genln("");
|
||||
gen_ast(*it);
|
||||
}
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
Ast_Begin(AST_RETURN, Ast_Return){
|
||||
gen("return");
|
||||
if(node->expr){
|
||||
gen(" ");
|
||||
gen_expr(node->expr);
|
||||
}
|
||||
gen(";");
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
Ast_Begin(AST_VAR, Ast_Var){
|
||||
Sym *sym = resolved_get(node);
|
||||
gen_simple_decl(sym->type, node->name);
|
||||
if(node->expr){
|
||||
gen(" = ");
|
||||
gen_expr(node->expr);
|
||||
}
|
||||
gen(";");
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
Ast_Begin(AST_INIT, Ast_Init){
|
||||
Sym *sym = resolved_get(node);
|
||||
gen_simple_decl(sym->type, node->ident->intern_val);
|
||||
if(node->expr){
|
||||
gen(" = ");
|
||||
gen_expr(node->expr);
|
||||
}
|
||||
gen(";");
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
Ast_Begin(AST_IF, Ast_If){
|
||||
For(node->ifs){
|
||||
if(it[0]->init) gen_ast(it[0]->init);
|
||||
if(node->ifs.is_first(it)){
|
||||
genln("if(");
|
||||
gen_expr(it[0]->expr);
|
||||
gen(")");
|
||||
gen_block(it[0]->block);
|
||||
}
|
||||
else{
|
||||
genln("else");
|
||||
if(it[0]->expr){
|
||||
gen(" if(");
|
||||
gen_expr(it[0]->expr);
|
||||
gen(")");
|
||||
}
|
||||
gen_block(it[0]->block);
|
||||
}
|
||||
}
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
Ast_Begin(AST_CONST, Ast_Const){
|
||||
Sym *sym = resolved_get(node);
|
||||
|
||||
if(sym->type->kind == TYPE_Lambda){
|
||||
if(node->expr->kind == AST_LAMBDA){
|
||||
Ast_Lambda *lambda = (Ast_Lambda *)node->expr;
|
||||
gen("static ");
|
||||
Ast_Resolved_Type *ret = resolved_type_get(lambda->ret);
|
||||
gen_simple_decl(ret, node->name);
|
||||
gen("(");
|
||||
For(lambda->args){
|
||||
assert(it[0]->kind == AST_LAMBDA_ARG);
|
||||
Ast_Resolved_Type *type = resolved_type_get(it[0]->typespec);
|
||||
gen_simple_decl(type, it[0]->name);
|
||||
if(it != (lambda->args.end() - 1)) gen(", ");
|
||||
}
|
||||
gen(")");
|
||||
|
||||
if(lambda->block) {
|
||||
gen_block(lambda->block);
|
||||
}
|
||||
else gen(";");
|
||||
}
|
||||
else{
|
||||
gen_simple_decl(sym->type, node->name);
|
||||
gen(" = ");
|
||||
gen_expr(node->expr);
|
||||
gen(";");
|
||||
}
|
||||
}
|
||||
else if(sym->type == type_int){
|
||||
gen("enum { %s = %lld };", node->name.str, sym->int_val);
|
||||
}
|
||||
else if(sym->type == type_string){
|
||||
gen("String %s = LIT(\"%s\");", node->name.str, sym->intern_val.str);
|
||||
}
|
||||
else if(sym->type == type_type){
|
||||
gen("typedef ");
|
||||
gen_simple_decl(sym->type_val, node->name);
|
||||
gen(";");
|
||||
}
|
||||
else{
|
||||
parsing_error(node->pos, "C_Codegen: Unhandled type of constant expression");
|
||||
}
|
||||
|
||||
Ast_End();
|
||||
}
|
||||
|
||||
invalid_default_case;
|
||||
}
|
||||
}
|
||||
|
||||
function String
|
||||
compile_string(String filecontent, String filename = "default_name"_s){
|
||||
Scratch scratch(thread_ctx.scratch);
|
||||
OS_Heap heap = win32_os_heap_create(false, mib(4), 0);
|
||||
|
||||
Parse_Ctx ctx = {};
|
||||
ctx.init(scratch, &heap);
|
||||
pctx = &ctx;
|
||||
|
||||
lex_restream(&ctx, filecontent, filename);
|
||||
Ast_Package *result = parse_file();
|
||||
sym_insert_builtins();
|
||||
pctx->resolving_package = result;
|
||||
|
||||
gen(R"==(//-------------------------------
|
||||
#define NULL_POINTER 0
|
||||
#define NULL_LAMBDA 0
|
||||
//-------------------------------)==");
|
||||
|
||||
resolve_package(result);
|
||||
// eval_decl(result);
|
||||
gen_ast(result);
|
||||
exp_destroy(&heap);
|
||||
|
||||
String string_result = string_flatten(scratch, &pctx->gen);
|
||||
return string_result;
|
||||
}
|
||||
|
||||
function String
|
||||
compile_file(String filename){
|
||||
Scratch scratch;
|
||||
String filecontent = os_read_file(scratch, filename);
|
||||
assert(filecontent.len);
|
||||
String result = compile_string(filecontent, filename);
|
||||
return result;
|
||||
}
|
||||
Reference in New Issue
Block a user