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

Basic resolving, codegen with packages

Browse Source
This commit is contained in:
Krzosa Karol
2022-06-10 10:35:10 +02:00
parent fbe911d267
commit b0077fe9df
9 changed files with 553 additions and 433 deletions
Download Patch File Download Diff File Expand all files Collapse all files

371
ccodegen.cpp
View File

@@ -26,7 +26,7 @@ gen_simple_decl_prefix(Ast_Resolved_Type *ast){
case TYPE_LAMBDA:break;
case TYPE_ENUM:
case TYPE_STRUCT: {
auto constant = (Ast_Const *)ast->ast->parent;
auto constant = (Ast_Decl *)ast->ast;
auto name = constant->name;
gen("%s ", name.str);
}break;
@@ -98,60 +98,58 @@ gen_expr(Ast_Expr *ast){
BREAK();
}
CASE(INDEX, Index){
Sym *sym = resolved_get(node);
if(is_array(sym->type)){
gen("(");
gen("(");
// CASE(INDEX, Index){
// Sym *sym = resolved_get(node);
// if(is_array(sym->type)){
// gen("(");
// gen("(");
gen("(");
gen_simple_decl(sym->type->arr.base, {});
gen("*)");
gen_expr(node->expr);
gen(".data)");
// gen("(");
// gen_simple_decl(sym->type->arr.base, {});
// gen("*)");
// gen_expr(node->expr);
// gen(".data)");
gen("[");
gen_expr(node->index);
gen("]");
gen(")");
} else{
gen("(");
gen_expr(node->expr);
gen("[");
gen_expr(node->index);
gen("]");
gen(")");
}
BREAK();
}
// gen("[");
// gen_expr(node->index);
// gen("]");
// gen(")");
// } else{
// gen("(");
// gen_expr(node->expr);
// gen("[");
// gen_expr(node->index);
// gen("]");
// gen(")");
// }
// BREAK();
// }
CASE(BINARY, Binary){
if(node->op == TK_Dot){
Sym *sym = resolved_get(node->left);
gen_expr(node->left);
if(sym->type->kind == TYPE_POINTER) gen("->");
else gen(".");
gen_expr(node->right);
}
else if(node->op == TK_ColonAssign){
// if(node->op == TK_Dot){
// Sym *sym = resolved_get(node->left);
// gen_expr(node->left);
// if(sym->type->kind == TYPE_POINTER) gen("->");
// else gen(".");
// gen_expr(node->right);
// }
// else if(node->op == TK_ColonAssign){
Sym *sym = resolved_get(node);
Ast_Atom *atom = (Ast_Atom *)node->left;
assert(is_atom(atom));
gen_simple_decl(sym->type, atom->intern_val);
if(node->right){
gen(" = ");
gen_expr(node->right);
}
}
else{
if(!token_is_assign(node->op)) gen("(");
gen_expr(node->left);
gen("%s", name(node->op));
gen_expr(node->right);
if(!token_is_assign(node->op)) gen(")");
}
// Sym *sym = resolved_get(node);
// Ast_Atom *atom = (Ast_Atom *)node->left;
// assert(is_atom(atom));
// gen_simple_decl(sym->type, atom->intern_val);
// if(node->right){
// gen(" = ");
// gen_expr(node->right);
// }
// }
if(!token_is_assign(node->op)) gen("(");
gen_expr(node->left);
gen("%s", name(node->op));
gen_expr(node->right);
if(!token_is_assign(node->op)) gen(")");
BREAK();
}
@@ -164,15 +162,15 @@ gen_expr(Ast_Expr *ast){
BREAK();
}
CASE(CAST, Cast){
gen("(");
gen("(");
gen_simple_decl(resolved_type_get(node->typespec), {});
gen(")");
gen_expr(node->expr);
gen(")");
BREAK();
}
// CASE(CAST, Cast){
// gen("(");
// gen("(");
// gen_simple_decl(resolved_type_get(node->typespec), {});
// gen(")");
// gen_expr(node->expr);
// gen(")");
// BREAK();
// }
CASE(CALL, Call){
// @todo: Reach into map instead of direct lookup
@@ -242,10 +240,10 @@ gen_line(Ast *node){
function void
gen_ast(Ast *ast);
function void
gen_block(Ast_Block *block){
gen_stmt_scope(Ast_Scope *scope){
gen("{");
global_indent++;
For(block->stmts) {
For(scope->stmts) {
gen_line(it);
genln("");
gen_ast(it);
@@ -292,17 +290,6 @@ function void
gen_ast(Ast *ast){
switch(ast->kind){
CASE(PACKAGE, Package){
if(emit_line_directives)
genln("#line 0 \"%s\"", node->name.str);
For(node->ordered) {
gen_line(it);
genln("");
gen_ast(it);
}
BREAK();
}
CASE(RETURN, Return){
gen("return");
if(node->expr){
@@ -313,9 +300,8 @@ gen_ast(Ast *ast){
BREAK();
}
CASE(VAR, Var){
Sym *sym = resolved_get(node);
gen_var(sym->name, sym->type, node->expr, is_inside_struct ? DONT_EMIT_VALUE : ALWAYS_EMIT_VALUE);
CASE(VAR, Decl){
gen_var(node->name, node->type, node->expr, is_inside_struct ? DONT_EMIT_VALUE : ALWAYS_EMIT_VALUE);
gen(";");
BREAK();
}
@@ -327,7 +313,7 @@ gen_ast(Ast *ast){
gen("if(");
gen_expr(it->expr);
gen(")");
gen_block(it->block);
gen_stmt_scope(it->scope);
}
else{
genln("else");
@@ -336,7 +322,7 @@ gen_ast(Ast *ast){
gen_expr(it->expr);
gen(")");
}
gen_block(it->block);
gen_stmt_scope(it->scope);
}
}
BREAK();
@@ -362,113 +348,116 @@ gen_ast(Ast *ast){
gen(";");
if(node->iter) gen_expr(node->iter);
gen(")");
gen_block(node->block);
gen_stmt_scope(node->scope);
BREAK();
}
CASE(CONST, Const){
Sym *sym = resolved_get(node);
CASE(LAMBDA, Decl){
if(node->kind == AST_LAMBDA){
if(is_flag_set(node->flags, AST_FOREIGN)){
return;
}
Ast_Lambda *lambda = node->lambda;
Ast_Resolved_Type *ret = node->type->func.ret;
gen_simple_decl(ret, node->name);
gen("(");
For(lambda->args){
gen_var(it->name, it->type, 0, DONT_EMIT_VALUE);
if(&it != (lambda->args.end() - 1)) gen(", ");
}
gen(")");
switch(sym->type->kind){
if(lambda->scope) {
// gen_stmt_scope(lambda->scope);
// @todo stmts
}
else gen(";");
}
else{
gen_simple_decl(node->type, node->name);
gen(" = ");
gen_expr((Ast_Expr *)node->expr);
gen(";");
}
BREAK();
}
CASE(CONST, Decl){
switch(node->type->kind){
CASE_FLOAT:{
gen("// F64 %s = ", node->name.str);
gen_value(sym->value);
gen_value(node->value);
} break;
CASE_INT:{
gen("// constant int %s = ", node->name.str);
gen_value(sym->value);
gen_value(node->value);
}break;
CASE_STRING:{
gen("// const String %s = ", node->name.str);
gen_value(sym->value);
gen_value(node->value);
}break;
CASE_BOOL:{
gen("// const Bool %s = ", node->name.str);
gen_value(sym->value);
gen_value(node->value);
}break;
case TYPE_LAMBDA:{
if(node->value->kind == AST_LAMBDA){
if(is_flag_set(node->flags, AST_FOREIGN)){
return;
}
Ast_Lambda *lambda = (Ast_Lambda *)node->value;
Ast_Resolved_Type *ret = resolved_type_get(lambda->ret);
gen_simple_decl(ret, node->name);
gen("(");
For(lambda->args){
assert(it->kind == AST_LAMBDA_ARG);
Ast_Resolved_Type *type = resolved_type_get(it->typespec);
gen_var(it->name, type, 0, DONT_EMIT_VALUE);
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((Ast_Expr *)node->value);
gen(";");
}
}break;
case TYPE_TYPE:{
if(sym->type_val->kind == TYPE_STRUCT){
Ast_Struct *agg = (Ast_Struct *)sym->type_val->ast;
if(node->value->kind == AST_STRUCT){
gen("typedef struct %s{", node->name.str);
global_indent++;
is_inside_struct++;
For(agg->members){
genln("");
gen_ast(it);
}
For(agg->const_members){
genln("");
gen_ast(it);
}
is_inside_struct--;
global_indent--;
genln("}%s;", node->name.str);
}
else{
// Type alias
}
}
else if(sym->type_val->kind == TYPE_ENUM){
Ast_Enum *enu = (Ast_Enum *)sym->type_val->ast;
assert(enu->kind == AST_ENUM);
if(node->value->kind == AST_ENUM){
gen("/*enum %s{", node->name.str);
// @todo add typespec
global_indent++;
For(enu->members){
genln("%s", it->name.str);
gen(" = ");
Sym *value_sym = resolved_get(it);
gen("%d", bigint_as_signed(&value_sym->big_int_val));
gen(",");
}
global_indent--;
genln("};*/");
}
else{
// Type alias
}
}
else{
gen("// typedef ");
gen_simple_decl(sym->type_val, node->name);
gen(";");
}
}break;
default: compiler_error(node->pos, "C_Codegen: Unhandled type %s of constant expression", docname(sym->type));
// if(sym->type_val->kind == TYPE_STRUCT){
// Ast_Struct *agg = (Ast_Struct *)sym->type_val->ast;
// if(node->value->kind == AST_STRUCT){
// gen("typedef struct %s{", node->name.str);
// global_indent++;
// is_inside_struct++;
// For(agg->members){
// genln("");
// gen_ast(it);
// }
// For(agg->const_members){
// genln("");
// gen_ast(it);
// }
// is_inside_struct--;
// global_indent--;
// genln("}%s;", node->name.str);
// }
// else{
// // Type alias
// }
// }
// else if(sym->type_val->kind == TYPE_ENUM){
// Ast_Enum *enu = (Ast_Enum *)sym->type_val->ast;
// assert(enu->kind == AST_ENUM);
// if(node->value->kind == AST_ENUM){
// gen("/*enum %s{", node->name.str);
// // @todo add typespec
// global_indent++;
// For(enu->members){
// genln("%s", it->name.str);
// gen(" = ");
// Sym *value_sym = resolved_get(it);
// gen("%d", bigint_as_signed(&value_sym->big_int_val));
// gen(",");
// }
// global_indent--;
// genln("};*/");
// }
// else{
// // Type alias
// }
// }
// else{
// gen("// typedef ");
// gen_simple_decl(sym->type_val, node->name);
// gen(";");
// }
// }break;
default: compiler_error(node->pos, "C_Codegen: Unhandled type %s of constant expression", docname(node->type));
}
BREAK();
@@ -482,6 +471,7 @@ gen_ast(Ast *ast){
}
}
#if 0
function String
compile_string(String filecontent, String filename = "default_name"_s){
F64 total_time = os_time();
@@ -574,3 +564,64 @@ compile_file(String filename){
String result = compile_string(filecontent, filename);
return result;
}
#endif
function String
compile_files(Array<String> filename){
Scratch scratch(thread_ctx.scratch);
Array<Ast_File> files = {scratch};
For(filename){
String filecontent = os_read_file(scratch, it);
assert(filecontent.len);
files.add(ast_file(it, filecontent));
}
F64 total_time = os_time();
OS_Heap heap = win32_os_heap_create(false, mib(16), 0);
Parse_Ctx ctx = {};
parse_init(&ctx, scratch, &heap);
F64 parse_begin = os_time();
Array<Ast_Package> packages = {&heap};
For(files){
parse_file(&it);
Ast_Package *package = find_package(it.name, &packages);
if(package){
package->decls.add(it.decls);
} else {
Ast_Package p = ast_package(&heap, it.name, it.decls);
insert_builtin_types_into_package(&p);
packages.add(p);
}
}
F64 parse_end = os_time();
For(packages){
resolve_package(&it);
}
For(pctx->ordered_decls){
genln("");
gen_ast(it);
}
exp_destroy(&heap);
F64 flattening_begin = os_time();
String string_result = string_flatten(scratch, &pctx->gen);
F64 flattening_end = os_time();
printf("\n//-------------------------------");
printf("\n// Parse : %f", parse_end - parse_begin);
printf("\n// Flattening : %f", flattening_end - flattening_begin);
printf("\n// Total : %f", flattening_end - total_time);
printf("\n//-------------------------------");
return string_result;
}