Generating valid c code, more work on null values

cgenerate.cpp

@@ -0,0 +1,232 @@
+
+#define genln(...) do{printf("\n"); gen_indent(); gen(__VA_ARGS__); }while(0)
+#define gen(...) printf(__VA_ARGS__)
+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_Expr){
+      gen("%s", node->intern_val.str);
+      Ast_End();
+    }
+
+    Ast_Begin(AST_INT, Ast_Expr){
+      gen("%lld", node->int_val);
+      Ast_End();
+    }
+
+    Ast_Begin(AST_STR, Ast_Expr){
+      gen("LIT(\"%s\")", node->intern_val.str);
+      Ast_End();
+    }
+
+    Ast_Begin(AST_INDEX, Ast_Expr){
+      gen_expr(node->index.expr);
+      gen("[");
+      gen_expr(node->index.index);
+      gen("]");
+      Ast_End();
+    }
+
+    Ast_Begin(AST_UNARY, Ast_Expr){
+      switch(node->unary.op){
+        case TK_Pointer: {
+          gen("(*");
+          gen_expr(node->unary.expr);
+          gen(")");
+        } break;
+        case TK_Dereference: {
+          gen("(&");
+          gen_expr(node->unary.expr);
+          gen(")");
+        } break;
+        invalid_default_case;
+      }
+      Ast_End();
+    }
+
+    Ast_Begin(AST_CAST, Ast_Expr){
+      gen("(");
+      gen("(");
+      gen_simple_decl(node->cast.typespec->resolved_type, {});
+      gen(")");
+      gen_expr(node->cast.expr);
+      gen(")");
+      Ast_End();
+    }
+
+    Ast_Begin(AST_COMPOUND, Ast_Expr){
+      gen("(");
+      gen_simple_decl(node->compound.type, {});
+      gen(")");
+
+      gen("{");
+      For(node->compound.exprs){
+        auto comp = it[0]->compound_item;
+        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->compound.exprs.is_last(it)) gen(", ");
+      }
+      gen("}");
+
+      Ast_End();
+    }
+
+    invalid_default_case;
+  }
+}
+
+function void
+gen_ast(Ast *ast){
+  switch(ast->kind){
+
+    Ast_Begin(AST_PACKAGE, Ast_Package){
+      For(node->decls) gen_ast(*it);
+      Ast_End();
+    }
+
+    Ast_Begin(AST_VAR, Ast_Decl){
+      genln("");
+      Sym *sym = sym_get(node->name);
+      gen_simple_decl(sym->type, node->name);
+      if(node->var.expr){
+        gen(" = ");
+        gen_expr(node->var.expr);
+      }
+      gen(";");
+      Ast_End();
+    }
+
+    Ast_Begin(AST_CONST, Ast_Decl){
+      Sym *sym = sym_get(node->name);
+
+      if(sym->type->kind == TYPE_Lambda){
+        if(node->var.expr->kind == AST_LAMBDA){
+          Ast_Lambda *lambda = (Ast_Lambda *)node->var.expr;
+          genln("");
+          gen_simple_decl(lambda->ret->resolved_type, node->name);
+          gen("(");
+          For(lambda->params){
+            assert(it[0]->kind == AST_LAMBDA_PARAM);
+            gen_simple_decl(it[0]->lambda_param.typespec->resolved_type, it[0]->lambda_param.name);
+            if(it != (lambda->params.end() - 1)) gen(", ");
+          }
+          gen(")");
+        }
+        else{
+          genln("");
+          gen_simple_decl(sym->type, node->name);
+          gen(" = ");
+          gen_expr(node->var.expr);
+          gen(";");
+        }
+      }
+      else if(sym->type == type_int){
+        genln("enum { %s = %lld };", node->name.str, sym->int_val);
+      }
+      else if(sym->type == type_string){
+        genln("String %s = LIT(\"%s\");", node->name.str, sym->intern_val.str);
+      }
+      else{
+        parsing_error(node->pos, "Unhandled type of constant expression");
+      }
+
+      Ast_End();
+    }
+
+    invalid_default_case;
+  }
+}
+
+function void
+test_gen(){
+  TEST_PARSER();
+  String filename = "test3.kl"_s;
+  String file_content = os_read_file(scratch, filename);
+  lex_restream(&ctx, file_content, filename);
+  Ast_Package *result = parse_file();
+  sym_insert_builtins();
+  eval_decl(result);
+  gen(R"==(
+#define null_pointer 0
+#define null_lambda  0
+  )==");
+  gen_ast(result);
+  __debugbreak();
+}