Compiling and running first program!

ccodegen.cpp

@@ -288,7 +288,6 @@ gen_ast(Ast *ast){
       if(sym->type->kind == TYPE_LAMBDA){
         if(node->value->kind == AST_LAMBDA){
           Ast_Lambda *lambda = (Ast_Lambda *)node->value;
-          gen("static ");
           Ast_Resolved_Type *ret = resolved_type_get(lambda->ret);
           gen_simple_decl(ret, node->name);
           gen("(");
@@ -316,7 +315,7 @@ gen_ast(Ast *ast){
         gen("// constant F64 %s = %f;", node->name.str, sym->f64_val);
       }
       else if(sym->type == untyped_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 == untyped_string){
         gen("// const String %s = LIT(\"%s\");", node->name.str, sym->intern_val.str);
@@ -405,7 +404,6 @@ compile_string(String filecontent, String filename = "default_name"_s){
 
 
   gen(R"==(
-
 #include <stdint.h>
 typedef int8_t   S8;
 typedef int16_t  S16;
@@ -420,15 +418,15 @@ typedef S16      B16;
 typedef S32      B32;
 typedef S64      B64;
 typedef U64      SizeU;
-typedef S64      SizeI;
+typedef S64      SizeS;
 typedef float    F32;
 typedef double   F64;
 
-struct String{
+typedef struct String{
   U8 *str;
   S64 len;
-};
+}String;
-
+#define LIT(x) (String){.str=(U8 *)x, .len=sizeof(x)-1}
   )==");
 
   F64 resolve_begin = os_time();

enums.kl

@@ -1,6 +1,6 @@
 
 Thing :: struct
-  len: Int
+  len: int
 
   Constant_String :: "Test"
   Constant :: 10

globals.kl

@@ -1,58 +1,58 @@
 //-----------------------------------------------------------------------------
 // Function types
 //-----------------------------------------------------------------------------
-test_function :: (thing: Int): *Int
+test_function :: (thing: int): *int
 function_type: test_function
 const_function_alias :: test_function
-// null_function: (t: Int): *Int = null
+// null_function: (t: int): *int = null
 
 //-----------------------------------------------------------------------------
 // Booleans
 //-----------------------------------------------------------------------------
 Boolean: Bool      = true
-value_of_Bool: Int = cast(Boolean: Int)
+value_of_Bool: int = cast(Boolean: int)
 
 //-----------------------------------------------------------------------------
 // Nulls
 //-----------------------------------------------------------------------------
-// Int_null: Int = null
+// int_null: int = null
 // str_null: String = null
 // Bool_null: Bool = null
 
 //-----------------------------------------------------------------------------
 // Compound expressions
 //-----------------------------------------------------------------------------
-array1: [4]Int  = [4]Int(1,2,3,4)
+array1: [4]int  = [4]int(1,2,3,4)
-array2 := [32]Int(1,2,3,4)
+array2 := [32]int(1,2,3,4)
-array3 := [32]Int(
+array3 := [32]int(
   [0] = 0,
   [1] = 1,
   [2] = 2,
   [31] = 31,
 )
 array_item := array1[0]
-array_item_imp: Int = array2[2]
+array_item_imp: int = array2[2]
 
 //-----------------------------------------------------------------------------
-// PoInters
+// Pointers
 //-----------------------------------------------------------------------------
-poInter_decl       : *Int
+pointer_decl       : *int
-variable_from_deref: Int = *poInter_decl
+variable_from_deref: int = *pointer_decl
-poInter_from_var   : *Int = &variable_from_deref
+pointer_from_var   : *int = &variable_from_deref
-Boolean_poInter    := &Boolean
+Boolean_pointer    := &Boolean
 
 //-----------------------------------------------------------------------------
 // Implicit type
 //-----------------------------------------------------------------------------
-implicit_Int :: 10
+implicit_int :: 10
 implicit_str :: "Hello world"
 
 //-----------------------------------------------------------------------------
-// PoInters
+// Pointers
 //-----------------------------------------------------------------------------
-// poInter1:    *Int = 0
+// pointer1:    *int = 0
-// poInter2:    *Int = poInter1
+// pointer2:    *int = pointer1
-// poInter3:   **Int = 0
+// pointer3:   **int = 0
 
 //-----------------------------------------------------------------------------
 // String types
@@ -61,7 +61,7 @@ string1 :: "Test"
 string2 :: string1
 
 //-----------------------------------------------------------------------------
-// Constant Int variables
+// Constant int variables
 //-----------------------------------------------------------------------------
 thing0 :: 10
 thing1 :: thing0 + 11

lambdas.kl

@@ -1,8 +1,8 @@
-a_type :: Int
+a_type :: int
-poInter_type :: *Int
+pointer_type :: *int
-// null_poInter: poInter_type = null
+// null_pointer: pointer_type = null
 
-if_stmt :: (cond: Int): type
+if_stmt :: (cond: int): type
   CONSTANT :: 10
   thing := 10
   if i := thing + cond, cond + CONSTANT
@@ -17,11 +17,11 @@ for_stmt :: ()
   for i := 0, i + 10, i+=1
     pass
 
-add_10 :: (size: Int): Int
+add_10 :: (size: int): int
-  add_20 :: (new_size: Int): Int
+  add_20 :: (new_size: int): int
     return 20
 
-  add :: (a: Int, b: Int = 10): Int
+  add :: (a: int, b: int = 10): int
     return a + b
 
   constant :: 20; result := constant + 10
@@ -38,13 +38,13 @@ add_10 :: (size: Int): Int
 
   return v4
 
-return_constant :: (): Int
+return_constant :: (): int
   constant :: 10
   return constant
 
-returning_Void :: (insert: Int)
+returning_void :: (insert: int)
-  val1: Int = return_constant()
+  val1: int = return_constant()
-  val2: Int = add_10(val1)
+  val2: int = add_10(val1)
   return
 
 

lang.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#define global static
+#define function static
+
+#define assert(x) do{if(!(x)) __debugbreak();}while(0)
+#define assert_msg(x,...) assert(x)
+#define not_implemented assert_msg(0, "Not implemented")
+#define invalid_codepath assert_msg(0, "Invalid codepath")
+
+#define buff_cap(x) (sizeof(x)/sizeof((x)[0]))
+#define lit(x) ((String){(U8*)x,buff_cap(x)-1})
+#define meta(x)
+
+#include <stdint.h>
+typedef int8_t   S8;
+typedef int16_t  S16;
+typedef int32_t  S32;
+typedef int64_t  S64;
+typedef uint8_t  U8;
+typedef uint16_t U16;
+typedef uint32_t U32;
+typedef uint64_t U64;
+typedef S8       B8;
+typedef S16      B16;
+typedef S32      B32;
+typedef S64      B64;
+typedef uint64_t SizeU;
+typedef int64_t  SizeS;
+typedef float    F32;
+typedef double   F64;
+
+#include <stdbool.h>
+//const B32 true = 1;
+//const B32 false = 0;
+#define kib(x) ((x)*1024llu)
+#define mib(x) (kib(x)*1024llu)
+#define gib(x) (mib(x)*1024llu)
+#define string_expand(x) (int)x.len, x.str
+
+typedef struct String_Node String_Node;
+typedef struct String_List String_List;
+typedef struct String{
+  U8 *str;
+  S64 len;
+}String;
+
+struct String_Node{
+  String_Node *next;
+  union{
+    String string;
+    struct{U8*str; S64 len;};
+  };
+};
+
+struct String_List{
+  String_Node *first;
+  String_Node *last;
+  S64 char_count;
+  S64 node_count;
+};
+
+#define SLLQueuePushMod(f,l,n,next) do{\
+if((f)==0){\
+(f)=(l)=(n);\
+}\
+else{\
+(l)=(l)->next=(n);\
+} \
+}while(0)
+
+#define SLLQueuePush(f,l,n) SLLQueuePushMod(f,l,n,next)
+
+
+#define SLLStackPush(l,n) do{\
+(n)->next = (l);\
+(l) = (n);\
+}while(0)
+
+#define SLLStackPop(l,n) do{\
+if(l){\
+(n) = (l);\
+(l) = (l)->next;\
+(n)->next = 0;\
+}\
+}while(0)

lex.c

@@ -0,0 +1,642 @@
+global Intern_String keyword_if;
+global Intern_String keyword_for;
+global Intern_String keyword_cast;
+global Intern_String keyword_else;
+global Intern_String keyword_defer;
+global Intern_String keyword_do;
+global Intern_String keyword_size_type;
+global Intern_String keyword_size_expr;
+global Intern_String keyword_const;
+global Intern_String keyword_typedef;
+global Intern_String keyword_return;
+global Intern_String keyword_typeof;
+global Intern_String keyword_while;
+global Intern_String keyword_switch;
+global Intern_String keyword_case;
+global Intern_String keyword_struct;
+global Intern_String keyword_enum;
+global Intern_String keyword_union;
+global U8 *first_keyword;
+global U8 *last_keyword;
+
+global Intern_String intern_char;
+global Intern_String intern_void;
+global Intern_String intern_int;
+
+function void
+init_default_keywords(Intern_Table *t){
+  keyword_if = intern_string(t, lit("if"));
+  first_keyword = keyword_if.s.str;
+
+  keyword_cast = intern_string(t, lit("cast"));
+  keyword_for = intern_string(t, lit("for"));
+  keyword_else = intern_string(t, lit("else"));
+  keyword_defer = intern_string(t, lit("defer"));
+  keyword_do = intern_string(t, lit("do"));
+  keyword_size_type = intern_string(t, lit("size_type"));
+  keyword_size_expr = intern_string(t, lit("size_expr"));
+  keyword_typeof = intern_string(t, lit("typeof"));
+  keyword_const = intern_string(t, lit("const"));
+  keyword_while = intern_string(t, lit("while"));
+  keyword_return = intern_string(t, lit("return"));
+  keyword_switch = intern_string(t, lit("switch"));
+  keyword_typedef = intern_string(t, lit("typedef"));
+  keyword_case = intern_string(t, lit("case"));
+  keyword_struct = intern_string(t, lit("struct"));
+  keyword_enum = intern_string(t, lit("enum"));
+
+  keyword_union = intern_string(t, lit("union"));
+  last_keyword = keyword_union.s.str;
+
+  intern_char = intern_string(t, lit("char"));
+  intern_void = intern_string(t, lit("void"));
+  intern_int = intern_string(t, lit("int"));
+}
+
+function B32
+lex_is_keyword(Intern_String str){
+  B32 result = str.s.str >= first_keyword && str.s.str <= last_keyword;
+  return result;
+}
+
+typedef enum Token_Kind{
+  TK_End,
+
+  TK_Mul,
+  TK_Div,
+  TK_Mod,
+  TK_LeftShift,
+  TK_RightShift,
+  TK_FirstMul = TK_Mul,
+  TK_LastMul = TK_RightShift,
+
+  TK_Add,
+  TK_Sub,
+  TK_FirstAdd = TK_Add,
+  TK_LastAdd = TK_Sub,
+
+  TK_Equals,
+  TK_LesserThenOrEqual,
+  TK_GreaterThenOrEqual,
+  TK_LesserThen,
+  TK_GreaterThen,
+  TK_NotEquals,
+  TK_FirstCompare = TK_Equals,
+  TK_LastCompare = TK_NotEquals,
+
+  TK_BitAnd,
+  TK_BitOr,
+  TK_Pointer,
+  TK_And,
+  TK_Or,
+  TK_FirstLogical = TK_BitAnd,
+  TK_LastLogical = TK_Or,
+
+  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_Colon,
+
+  TK_Assign,
+  TK_ColonAssign,
+  TK_DivAssign,
+  TK_MulAssign,
+  TK_ModAssign,
+  TK_SubAssign,
+  TK_AddAssign,
+  TK_AndAssign,
+  TK_OrAssign,
+  TK_XorAssign,
+  TK_LeftShiftAssign,
+  TK_RightShiftAssign,
+  TK_FirstAssign = TK_Assign,
+  TK_LastAssign = TK_RightShiftAssign,
+
+  TK_DoubleColon,
+  TK_At,
+  TK_Decrement,
+  TK_Increment,
+  TK_PostDecrement,
+  TK_PostIncrement,
+
+  TK_Arrow,
+  TK_ExprSizeof,
+  TK_DocComment,
+  TK_Comment,
+  TK_Identifier,
+  TK_StringLit,
+  TK_Character,
+  TK_Error,
+  TK_Float,
+  TK_Integer,
+  TK_Keyword,
+}Token_Kind;
+
+typedef struct Token{
+  Token_Kind kind;
+  union{
+    String string;
+    struct{U8 *str; S64 len;};
+  };
+
+  union {
+    U64 int_val;
+    F64 float_val;
+    String error_val;
+    Intern_String intern_val;
+  };
+
+  String file;
+  S32    line;
+  U8    *line_begin;
+}Token;
+#include "token_array.c"
+
+typedef struct Lex_Stream{
+  String stream;
+  S64    iter;
+
+  U8    *line_begin;
+  String file;
+  S32    line;
+}Lex_Stream;
+
+
+function U8
+lexc(Lex_Stream *s){
+  return s->stream.str[s->iter];
+}
+
+function U8
+lexci(Lex_Stream *s, S32 i){
+  return s->stream.str[s->iter+i];
+}
+
+function U8 *
+lexcp(Lex_Stream *s){
+  return s->stream.str + s->iter;
+}
+
+function B32
+lex_is_whitespace(U8 c){
+  B32 result = c == '\n' || c == '\r' || c == ' ' || c == '\r';
+  return result;
+}
+
+function B32
+lex_is_alphabetic(U8 c){
+  B32 result = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
+  return result;
+}
+
+function B32
+lex_is_numeric(U8 c){
+  B32 result = c >= '0' && c <= '9';
+  return result;
+}
+
+function B32
+lex_is_alphanumeric(U8 c){
+  B32 result = lex_is_numeric(c) || lex_is_alphabetic(c);
+  return result;
+}
+
+function void
+lex_set_len(Lex_Stream *s, Token *token){
+  assert(lexcp(s) >= token->str);
+  token->len = lexcp(s) - token->str;
+}
+
+function void
+token_error(Token *t, String error_val){
+  t->kind = TK_Error;
+  t->error_val = error_val;
+}
+
+function void
+lex_parse_u64(Token *t){
+  U64 result = 0;
+  U64 m = 1;
+  for(S64 i = t->len - 1; i >= 0; --i){
+    U64 val = t->str[i] - '0';
+    U64 new_val = val * m;
+    if((result + new_val) < result){
+      token_error(t, lit("Integer overflow"));
+      return;
+    }
+    result+=new_val;
+    m *= 10;
+  }
+  t->int_val = result;
+}
+
+function void
+lex_advance(Lex_Stream *s){
+  if(s->iter >= s->stream.len){
+    return;
+  }
+  else if(lexc(s) == '\n'){
+    s->iter++;
+    s->line++;
+    s->line_begin = lexcp(s);
+  }
+  else{
+    s->iter++;
+  }
+}
+
+function void
+lex_parse_string(Lex_Stream *s, Token *t, U8 c){
+  for(;;){
+    if(lexc(s) == '\\') lex_advance(s);
+    else if(lexc(s) == c) break;
+    else if(lexc(s) == 0){
+      token_error(t, lit("Unterminated string, reached end of file"));
+      break;
+    }
+    lex_advance(s);
+  }
+  if(t->kind != TK_Error){
+    lex_advance(s);
+    lex_set_len(s,t);
+  }
+}
+
+#define CASE2(op, OpName, Assign)                                                      \
+case op:                                                                             \
+if (lexc(s) == '=') {                                                                \
+lex_advance(s);                                                                    \
+t.kind = Assign;                                                                  \
+} else {                                                                             \
+t.kind = OpName;                                                                  \
+}                                                                                    \
+break
+#define CASE3(op, OpName, Assign, Incr)                                                \
+case op:                                                                             \
+if (lexc(s) == '=') {                                                                \
+lex_advance(s);                                                                    \
+t.kind = Assign;                                                                  \
+} else if (lexc(s) == op) {                                                          \
+lex_advance(s);                                                                    \
+t.kind = Incr;                                                                    \
+} else {                                                                             \
+t.kind = OpName;                                                                  \
+}                                                                                    \
+break
+
+function void
+lex__stream(Token_Array *array, Lex_Stream *s){
+  while(lexc(s)){
+    while(lex_is_whitespace(lexc(s)))
+      lex_advance(s);
+
+    Token t = {0};
+    t.str = lexcp(s);
+    t.file = s->file;
+    t.line = s->line;
+    t.line_begin = s->line_begin;
+    lex_advance(s);
+
+    switch(*t.str){
+      case 0: break;
+      case '@': t.kind = TK_At; break;
+      case '(': t.kind = TK_OpenParen; break;
+      case ')': t.kind = TK_CloseParen; break;
+      case '{': t.kind = TK_OpenBrace; break;
+      case '}': t.kind = TK_CloseBrace; break;
+      case '[': t.kind = TK_OpenBracket; break;
+      case ']': t.kind = TK_CloseBracket; break;
+      case ',': t.kind = TK_Comma; break;
+      case '~': t.kind = TK_Neg; break;
+      case '?': t.kind = TK_Question; break;
+      case ';': t.kind = TK_Semicolon; break;
+      case '#': t.kind = TK_Pound; break;
+      CASE2('!', TK_Not, TK_NotEquals);
+      CASE2('^', TK_Pointer, 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 '.': {
+        if(lexc(s) == '.' && lexci(s,1) == '.') {
+          lex_advance(s); lex_advance(s);
+          t.kind = TK_ThreeDots;
+        }
+        else {
+          t.kind = TK_Dot;
+        }
+      } break;
+
+
+      case '<': {
+        if (lexc(s) == '<') {
+          lex_advance(s);
+          if (lexc(s) == '=') {
+            lex_advance(s);
+            t.kind = TK_LeftShiftAssign;
+          }
+          else {
+            t.kind = TK_LeftShift;
+          }
+        }
+        else if (lexc(s) == '=') {
+          lex_advance(s);
+          t.kind = TK_LesserThenOrEqual;
+        }
+        else {
+          t.kind = TK_LesserThen;
+        }
+      } break;
+
+      case '>': {
+        if (lexc(s) == '>') {
+          lex_advance(s);
+          if (lexc(s) == '=') {
+            lex_advance(s);
+            t.kind = TK_RightShiftAssign;
+          }
+          else {
+            t.kind = TK_RightShift;
+          }
+        }
+        else if (lexc(s) == '=') {
+          lex_advance(s);
+          t.kind = TK_GreaterThenOrEqual;
+        }
+        else {
+          t.kind = TK_GreaterThen;
+        }
+      } break;
+
+      case ':': {
+        if (lexc(s) == ':') {
+          lex_advance(s);
+          t.kind = TK_DoubleColon;
+        }
+        else if(lexc(s) == '='){
+          lex_advance(s);
+          t.kind = TK_ColonAssign;
+        }
+        else {
+          t.kind = TK_Colon;
+        }
+      } break;
+
+      case '-':{
+        if (lexc(s) == '=') {
+          lex_advance(s);
+          t.kind = TK_SubAssign;
+        }
+        else if (lexc(s) == '-') {
+          lex_advance(s);
+          t.kind = TK_Decrement;
+        }
+        else if (lexc(s) == '>') {
+          lex_advance(s);
+          t.kind = TK_Arrow;
+        }
+        else {
+          t.kind = TK_Sub;
+        }
+      } break;
+
+
+      case '\'':{not_implemented;} break;
+      case '"': {
+        t.kind = TK_StringLit;
+        lex_parse_string(s,&t,'"');
+        if(t.kind != TK_Error){
+          t.str += 1;
+          t.len -= 2;
+        }
+        t.intern_val = intern_string(&array->interns, t.string);
+      } break;
+
+      case '/': {
+        if(lexc(s) == '='){
+          t.kind = TK_DivAssign;
+          lex_advance(s);
+        }
+        else if(lexc(s) == '/'){
+          lex_advance(s);
+          t.kind = TK_Comment;
+          for(;;){
+            if(lexc(s) == '\n' || lexc(s) == 0) break;
+            lex_advance(s);
+          }
+          continue;
+        }
+        else if(lexc(s) == '*'){
+          lex_advance(s);
+          t.kind = TK_Comment;
+          for(;;){
+            if(lexc(s) == '*' && lexci(s,1) == '/'){
+              lex_advance(s);
+              lex_advance(s);
+              break;
+            }
+            else if(lexc(s) == 0){
+              token_error(&t, lit("Unterminated block comment"));
+              goto skip_continue;
+            }
+            lex_advance(s);
+          }
+          continue;
+          skip_continue:;
+        }
+        else {
+          t.kind = TK_Div;
+        }
+      } break;
+
+      case '0':case '1':case '2':case '3':case '4':
+      case '5':case '6':case '7':case '8':case '9':{
+        t.kind = TK_Integer;
+        while(lex_is_numeric(lexc(s)))
+          lex_advance(s);
+        lex_set_len(s, &t);
+        lex_parse_u64(&t);
+      } break;
+
+      case 'A':case 'a':case 'M':case 'm':case 'B':
+      case 'b':case 'N':case 'n':case 'C':case 'c':case 'O':
+      case 'o':case 'D':case 'd':case 'P':case 'p':case 'E':
+      case 'e':case 'Q':case 'q':case 'F':case 'f':case 'R':
+      case 'r':case 'G':case 'g':case 'S':case 's':case 'H':
+      case 'h':case 'T':case 't':case 'I':case 'i':case 'U':
+      case 'u':case 'J':case 'j':case 'V':case 'v':case 'K':
+      case 'k':case 'W':case 'w':case 'L':case 'X':case 'l':
+      case 'x':case 'Z':case 'z':case 'Y':case 'y':case '_': {
+        t.kind = TK_Identifier;
+        while(lex_is_alphanumeric(lexc(s)) || lexc(s) == '_')
+          lex_advance(s);
+        lex_set_len(s,&t);
+        t.intern_val = intern_string(&array->interns, t.string);
+        if(lex_is_keyword(t.intern_val)){
+          t.kind = TK_Keyword;
+        }
+      } break;
+
+      default: {
+        token_error(&t, lit("Unknown token"));
+      }
+    }
+
+    if(t.len==0)
+      lex_set_len(s,&t);
+
+    token_array_push(array, &t);
+  }
+}
+
+function void
+lex_add_stream(Token_Array *array, String stream, String file){
+  Lex_Stream s = {stream, 0, stream.str, file, 0};
+  lex__stream(array, &s);
+}
+
+function Token_Array
+lex_make_token_array(Arena *arena){
+  Token_Array array = token_array_make(arena);
+  init_default_keywords(&array.interns);
+  return array;
+}
+
+function Token_Array
+lex_stream(Arena *arena, String stream, String file){
+  Token_Array array = lex_make_token_array(arena);
+  lex_add_stream(&array, stream, file);
+  return array;
+}
+
+function void
+lex_restream(Token_Array *array, String stream, String file){
+  token_array_reset(array);
+  lex_add_stream(array, stream, file);
+}
+
+function void
+lex_test(){
+  Arena *scratch = arena_begin_scratch();
+  String test = lit("18446744073709551616{})(@?&+-;....->,:::/**/\"Thing\"//R\n Thingy"
+                    "\"Test_Meme\"+=-===42524 4294967295 18446744073709551615"
+                    "for if while switch :=");
+  Token_Array array = lex_stream(scratch, test, lit("Test1"));
+
+  Token_Kind kind[] = {
+    TK_Error,TK_OpenBrace,TK_CloseBrace,TK_CloseParen,TK_OpenParen,
+    TK_At,TK_Question,TK_BitAnd,TK_Add,TK_Sub,TK_Semicolon,
+    TK_ThreeDots, TK_Dot, TK_Arrow, TK_Comma, TK_DoubleColon, TK_Colon,
+    TK_StringLit, TK_Identifier, TK_StringLit, TK_AddAssign, TK_SubAssign,
+    TK_Equals, TK_Integer, TK_Integer, TK_Integer, TK_Keyword, TK_Keyword,
+    TK_Keyword, TK_Keyword, TK_ColonAssign, TK_End
+  };
+  String strs[] = {
+    lit("18446744073709551616"),lit("{"),lit("}"),lit(")"),lit("("),
+    lit("@"),lit("?"),lit("&"),lit("+"),lit("-"),lit(";"),
+    lit("..."),lit("."),lit("->"),lit(","),lit("::"),lit(":"),
+    lit("Thing"),lit("Thingy"),lit("Test_Meme"), lit("+="),lit("-="),
+    lit("=="),lit("42524"),lit("4294967295"),lit("18446744073709551615"),
+    lit("for"), lit("if"), lit("while"), lit("switch"), lit(":="), lit(""),
+  };
+  U64 vals[] = {
+    42524, 4294967295, 18446744073709551615llu
+  };
+
+  int i = 0;
+  int ui = 0;
+  for(Token *t = token_array_iter_begin(&array); t->kind != TK_End; t = token_array_iter_next(&array)){
+    assert(t->kind == kind[i]);
+    assert(string_compare(t->string, strs[i++]));
+    if(t->kind == TK_Integer){
+      assert(t->int_val == vals[ui++]);
+    }
+  }
+  arena_end_scratch();
+
+}
+
+//-----------------------------------------------------------------------------
+// Token metadata
+//-----------------------------------------------------------------------------
+global const char *token_kind_string[] = {
+  [TK_End] = "End of stream",
+  [TK_Mul] = "*",
+  [TK_Div] = "/",
+  [TK_Add] = "+",
+  [TK_Sub] = "-",
+  [TK_Mod] = "%",
+  [TK_BitAnd] = "&",
+  [TK_BitOr] = "|",
+  [TK_Pointer] = "^",
+  [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_ColonAssign] = ":=",
+  [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] = "sizeof",
+  [TK_DocComment] = "DocComment",
+  [TK_Comment] = "Comment",
+  [TK_Identifier] = "Identifier",
+  [TK_StringLit] = "StringLit",
+  [TK_Character] = "Character",
+  [TK_Error] = "Error",
+  [TK_Float] = "Float",
+  [TK_Integer] = "int",
+  [TK_Keyword] = "Keyword",
+};

main.cpp

@@ -33,7 +33,6 @@ For now I don't thing it should be overloadable.
 
 @todo
 [ ] - Converting from U64 token to S64 Atom introduces unnanounced error (negates) - probably need big int
-[ ] - Compiling and running a program
 [ ] - Passing down program to compile through command line
 [ ] - More for loop variations
 [ ] - Write up on order independent declarations
@@ -69,6 +68,7 @@ For now I don't thing it should be overloadable.
 [x] - Enums
 [x] - Initial for loop
 [x] - Enum . access to values
+[x] - Compiling and running a program
 [x] - Infinite for loop
 [x] - in new typesystem: Fix calls, fix all example programs
 [x] - Fix arithmetic operations in new type system
@@ -131,5 +131,7 @@ int main(){
   fprintf(f, "%.*s", (int)result.len, result.str);
   fclose(f);
 
+  system("clang.exe program.c -g -o program.exe && program.exe");
+
   __debugbreak();
 }

new_ast.cpp

@@ -71,10 +71,10 @@ struct Parse_Ctx:Lexer{
     interns.first_keyword = keyword_struct.str;
     interns.last_keyword  = keyword_enum.str;
 
-    intern_void = intern_string(&interns, "Void"_s);
+    intern_void = intern_string(&interns, "void"_s);
-    intern_int = intern_string(&interns, "Int"_s);
+    intern_int = intern_string(&interns, "int"_s);
     intern_str = intern_string(&interns, "String"_s);
-    intern_uint = intern_string(&interns, "UInt"_s);
+    intern_uint = intern_string(&interns, "uint"_s);
   }
 };
 

new_lex.cpp

@@ -741,7 +741,7 @@ token_kind_string(Token_Kind kind){
     case TK_Character: return "Character"_s;
     case TK_Error: return "Error"_s;
     case TK_Float: return "Float"_s;
-    case TK_Integer: return "Int"_s;
+    case TK_Integer: return "int"_s;
     case TK_Keyword: return "Keyword"_s;
     case CLOSE_SCOPE: return "Close_Scope"_s;
     case OPEN_SCOPE: return "Open_Scope"_s;

new_types.kl

@@ -5,7 +5,7 @@ unary_test :: ()
   float_val :: 124.42
   conversion: F64 = -+int_val
   float2 := -float_val
-  unsigned: Int = -+-+-int_val
+  unsigned: int = -+-+-int_val
 
   not: Bool = !int_val
   notf := !float_val

order1.kl

@@ -2,7 +2,7 @@
 other_func :: ()
   a_val := recursive_lambda
 
-recursive_lambda :: (thing: Int)
+recursive_lambda :: (thing: int)
   in_val := recursive_lambda
   some_value := thing + const_in_lambda
 

order2.kl

@@ -1,5 +1,5 @@
 Str16 :: String16
-// arena_poInter: *Arena = null
+// arena_pointer: *Arena = null
 thing: Arena
 no_type := thing
 constant_access := Arena.constant_inside
@@ -11,20 +11,20 @@ arena := Arena(
   cap = 1000,
 )
 
-// lambda_value := (val: Int) // @todo
+// lambda_value := (val: int) // @todo
   // return
 
 Arena :: struct
   // arena: Arena
   next: *Arena
-  data: *Int
+  data: *int
   len : S64
-  cap : Int
+  cap : int
 
   Sub :: struct
-    len: Int
+    len: int
     Sub_Sub :: struct
-      len: Int
+      len: int
 
   get_len :: (s: *Arena): S64 // @todo
     return s.next.len
@@ -36,11 +36,11 @@ string16: Str16
 
 String16 :: struct
   data: *Void
-  len : Int
+  len : int
 
 with_type: Arena = thing
-poInter := &with_type
+pointer := &with_type
-deref := *poInter
+deref := *pointer
 
 
 test_assignments :: ()
@@ -60,7 +60,7 @@ test_assignments :: ()
   CONST :: 23 == 23
   CONST_FLOAT :: 23.52
 
-  j: *Int
+  j: *int
   *j = 1
   /* invalid
   8 = 32

program.c

@@ -1,5 +1,4 @@
 
-
 #include <stdint.h>
 typedef int8_t   S8;
 typedef int16_t  S16;
@@ -14,21 +13,21 @@ typedef S16      B16;
 typedef S32      B32;
 typedef S64      B64;
 typedef U64      SizeU;
-typedef S64      SizeI;
+typedef S64      SizeS;
 typedef float    F32;
 typedef double   F64;
 
-struct String{
+typedef struct String{
   U8 *str;
   S64 len;
-};
+}String;
-
+#define LIT(x) (String){.str=(U8 *)x, .len=sizeof(x)-1}
   
 struct Lex_Stream{
   U8 *stream;
   U8 *end;
 };
-static Void main(){
+int main(){
   String string_to_lex = LIT("Identifier 2425525 Not_Number");
   for(S64 i = 0;(i<string_to_lex.len);(i+=1)){
     (string_to_lex.str[0]=64);

program.kl

@@ -3,7 +3,7 @@ Lex_Stream :: struct
   stream: *U8
   end   : *U8
 
-main :: ()
+main :: (): int
   string_to_lex := "Identifier 2425525 Not_Number"
 
 

typecheck.h

@@ -164,9 +164,9 @@ sym_insert_builtin_type(String name, Ast_Resolved_Type *type){
 
 function void
 sym_insert_builtins(){
-  sym_insert_builtin_type("Void"_s  , type_void);
+  sym_insert_builtin_type("void"_s  , type_void);
   sym_insert_builtin_type("Bool"_s  , type_bool);
-  sym_insert_builtin_type("Int"_s   , type_int);
+  sym_insert_builtin_type("int"_s   , type_int);
   sym_insert_builtin_type("String"_s, type_string);
   sym_insert_builtin_type("S8"_s, type_s8);
   sym_insert_builtin_type("S16"_s, type_s16);

types.h

@@ -56,12 +56,12 @@ const char *type_names[] = {
   "[Untyped_Float]",
   "[Untyped_String]",
 
-  "[Int]",
+  "[int]",
   "[S64]",
   "[S32]",
   "[S16]",
   "[S8]",
-  "[UInt]",
+  "[uint]",
   "[U64]",
   "[U32]",
   "[U16]",
@@ -70,7 +70,7 @@ const char *type_names[] = {
   "[Float64]",
   "[Bool]",
   "[String]",
-  "[Void]",
+  "[void]",
   "[Pointer]",
   "[Array]",
   "[Lambda]",
@@ -120,12 +120,12 @@ docname(Ast_Resolved_Type *type){
     case TYPE_UNTYPED_INT: return "[Untyped_Int]";
     case TYPE_UNTYPED_FLOAT: return "[Untyped_Float]";
     case TYPE_UNTYPED_STRING: return "[Untyped_String]";
-    case TYPE_INT: return "[Int]";
+    case TYPE_INT: return "[int]";
     case TYPE_S64: return "[S64]";
     case TYPE_S32: return "[S32]";
     case TYPE_S16: return "[S16]";
     case TYPE_S8: return "[S8]";
-    case TYPE_UINT: return "[UInt]";
+    case TYPE_UINT: return "[uint]";
     case TYPE_U64: return "[U64]";
     case TYPE_U32: return "[U32]";
     case TYPE_U16: return "[U16]";
@@ -134,7 +134,7 @@ docname(Ast_Resolved_Type *type){
     case TYPE_F64: return "[Float64]";
     case TYPE_BOOL: return "[Bool]";
     case TYPE_STRING: return "[String]";
-    case TYPE_VOID: return "[Void]";
+    case TYPE_VOID: return "[void]";
     case TYPE_POINTER: return "[Pointer]";
     case TYPE_ARRAY: return "[Array]";
     case TYPE_LAMBDA: return "[Lambda]";
@@ -150,9 +150,9 @@ docname(Ast_Resolved_Type *type){
 function const char *
 name(Ast_Resolved_Type *type){
   switch(type->kind){
-    case TYPE_VOID: return "Void";
+    case TYPE_VOID: return "void";
-    case TYPE_INT: return  "Int";
+    case TYPE_INT: return  "int";
-    case TYPE_UINT: return "UInt";
+    case TYPE_UINT: return "uint";
     case TYPE_BOOL: return "Bool";
     case TYPE_STRING: return "String";