Add bool values to parser, and bool nodes to ast

ccodegen.cpp

@@ -20,11 +20,6 @@ gen_indent(){
 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_UINT: gen("UInt "); 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;
@@ -34,23 +29,18 @@ gen_simple_decl_prefix(Ast_Resolved_Type *ast){
       auto name = constant->name;
       gen("%s ", name.str);
     }break;
-    invalid_default_case;
+    default: gen("%s ", name(ast));
   }
 }
 
 function void
 gen_simple_decl_postfix(Ast_Resolved_Type *ast){
   switch(ast->kind){
-    case TYPE_INT: break;
-    case TYPE_BOOL: break;
-    case TYPE_UINT: 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;
     case TYPE_ENUM: case TYPE_STRUCT:break;
-    invalid_default_case;
+    default: name(ast);
   }
 }
 
@@ -321,13 +311,16 @@ gen_ast(Ast *ast){
         }
       }
       else if(sym->type == type_f64){
-        gen("// constant int %s = %f;", node->name.str, sym->f64_val);
+        gen("// constant F64 %s = %f;", node->name.str, sym->f64_val);
       }
       else if(sym->type == type_int){
-        gen("// constant int %s = %lld;", node->name.str, sym->int_val);
+        gen("// constant Int %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);
+        gen("// const String %s = LIT(\"%s\");", node->name.str, sym->intern_val.str);
+      }
+      else if(sym->type == type_bool){
+        gen("// const Bool %s = %d;", node->name.str, sym->bool_val);
       }
       else if(sym->type == type_type){
         if(sym->type_val->kind == TYPE_STRUCT){

main.cpp

@@ -58,6 +58,8 @@ For now I don't thing it should be overloadable.
 
 @donzo
 [x] - lvalue, rvalue concept so we cant assign value to some arbitrary weird expression
+[x] - Add basic support for floats
+[x] - Add basic setup for new type system
 [x] - Access through struct names to constants Arena.CONSTANT
 [x] - Enums
 [x] - Initial for loop
@@ -100,16 +102,18 @@ int main(){
 
   String result = {};
 #if 1
-  // result = compile_file("globals.kl"_s);
+  result = compile_file("globals.kl"_s);
-  // printf("%s", result.str);
+  printf("%s", result.str);
-  // result = compile_file("enums.kl"_s);
+  result = compile_file("enums.kl"_s);
-  // printf("%s", result.str);
+  printf("%s", result.str);
-  // result = compile_file("order1.kl"_s);
+  result = compile_file("order1.kl"_s);
-  // printf("%s", result.str);
+  printf("%s", result.str);
-  // result = compile_file("lambdas.kl"_s);
+  result = compile_file("lambdas.kl"_s);
-  // printf("%s", result.str);
+  printf("%s", result.str);
   result = compile_file("order2.kl"_s);
   printf("%s", result.str);
+    result = compile_file("new_types.kl"_s);
+  printf("%s", result.str);
 #endif
 
   // result = compile_file("lexer.kl"_s);

new_ast.cpp

@@ -10,6 +10,8 @@ Intern_String keyword_union;
 Intern_String keyword_return;
 Intern_String keyword_if;
 Intern_String keyword_else;
+Intern_String keyword_true;
+Intern_String keyword_false;
 Intern_String keyword_for;
 Intern_String keyword_pass;
 Intern_String keyword_cast;
@@ -58,6 +60,8 @@ struct Parse_Ctx:Lexer{
     keyword_struct= intern("struct"_s);
     keyword_union = intern("union"_s);
     keyword_cast = intern("cast"_s);
+    keyword_true = intern("true"_s);
+    keyword_false = intern("false"_s);
     keyword_return = intern("return"_s);
     keyword_if = intern("if"_s);
     keyword_pass = intern("pass"_s);
@@ -283,7 +287,7 @@ struct Ast_Package:Ast{
 function Ast_Atom *
 ast_str(Token *pos, Intern_String string){
   AST_NEW(Atom, VALUE, pos, AST_EXPR | AST_ATOM);
-  result->type = type_string; // @todo untyped
+  result->type = type_string;
   result->intern_val = string;
   return result;
 }
@@ -295,10 +299,18 @@ ast_ident(Token *pos, Intern_String string){
   return result;
 }
 
+function Ast_Atom *
+ast_bool(Token *pos, B32 bool_val){
+  AST_NEW(Atom, VALUE, pos, AST_EXPR | AST_ATOM);
+  result->bool_val = bool_val;
+  result->type     = type_bool;
+  return result;
+}
+
 function Ast_Atom *
 ast_float(Token *pos, F64 value){
   AST_NEW(Atom, VALUE, pos, AST_EXPR | AST_ATOM);
-  result->type = type_f64; // @todo untyped
+  result->type = type_f64;
   result->f64_val = value;
   return result;
 }
@@ -306,7 +318,7 @@ ast_float(Token *pos, F64 value){
 function Ast_Atom *
 ast_int(Token *pos, S64 integer){
   AST_NEW(Atom, VALUE, pos, AST_EXPR | AST_ATOM);
-  result->type = type_int; // @todo untyped
+  result->type = type_int;
   result->int_val = integer;
   return result;
 }

new_parse.cpp

@@ -374,7 +374,9 @@ parse_expr(S64 min_bp){
     }break;
 
     case TK_Keyword: {
-      if(token->intern_val == keyword_cast){
+      if(token->intern_val == keyword_true) left = ast_bool(token, 1);
+      else if(token->intern_val == keyword_false) left = ast_bool(token, 0);
+      else if(token->intern_val == keyword_cast){
         token_expect(TK_OpenParen);
         Ast_Expr *expr = parse_expr(0);
         token_expect(TK_Colon);

typecheck.h

@@ -178,25 +178,6 @@ sym_insert_builtins(){
   sym_insert_builtin_type("U64"_s, type_u64);
   sym_insert_builtin_type("F32"_s, type_f32);
   sym_insert_builtin_type("F64"_s, type_f64);
-
-
-  {
-    Intern_String string = intern_string(&pctx->interns, "true"_s);
-    Value val;
-    val.type = type_bool;
-    val.bool_val = 1;
-    Sym *sym = sym_new_resolved(SYM_CONST, string, val, &empty_decl, false);
-    sym_insert(sym);
-  }
-
-  {
-    Intern_String string = intern_string(&pctx->interns, "false"_s);
-    Value val;
-    val.type = type_bool;
-    val.bool_val = 0;
-    Sym *sym = sym_new_resolved(SYM_CONST, string, val, &empty_decl, false);
-    sym_insert(sym);
-  }
 }
 
 //-----------------------------------------------------------------------------