diff --git a/ccodegen.cpp b/ccodegen.cpp index 3f100fa..9a8203d 100644 --- a/ccodegen.cpp +++ b/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 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(); diff --git a/enums.kl b/enums.kl index fc3c4d5..5d9cb81 100644 --- a/enums.kl +++ b/enums.kl @@ -1,6 +1,6 @@ Thing :: struct - len: Int + len: int Constant_String :: "Test" Constant :: 10 diff --git a/globals.kl b/globals.kl index ee0ccf0..f0d2977 100644 --- a/globals.kl +++ b/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) -array2 := [32]Int(1,2,3,4) -array3 := [32]Int( +array1: [4]int = [4]int(1,2,3,4) +array2 := [32]int(1,2,3,4) +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 -variable_from_deref: Int = *poInter_decl -poInter_from_var : *Int = &variable_from_deref -Boolean_poInter := &Boolean +pointer_decl : *int +variable_from_deref: int = *pointer_decl +pointer_from_var : *int = &variable_from_deref +Boolean_pointer := &Boolean //----------------------------------------------------------------------------- // Implicit type //----------------------------------------------------------------------------- -implicit_Int :: 10 +implicit_int :: 10 implicit_str :: "Hello world" //----------------------------------------------------------------------------- -// PoInters +// Pointers //----------------------------------------------------------------------------- -// poInter1: *Int = 0 -// poInter2: *Int = poInter1 -// poInter3: **Int = 0 +// pointer1: *int = 0 +// pointer2: *int = pointer1 +// pointer3: **int = 0 //----------------------------------------------------------------------------- // String types @@ -61,7 +61,7 @@ string1 :: "Test" string2 :: string1 //----------------------------------------------------------------------------- -// Constant Int variables +// Constant int variables //----------------------------------------------------------------------------- thing0 :: 10 thing1 :: thing0 + 11 diff --git a/lambdas.kl b/lambdas.kl index 614bea0..055cd7b 100644 --- a/lambdas.kl +++ b/lambdas.kl @@ -1,8 +1,8 @@ -a_type :: Int -poInter_type :: *Int -// null_poInter: poInter_type = null +a_type :: int +pointer_type :: *int +// 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_20 :: (new_size: Int): Int +add_10 :: (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) - val1: Int = return_constant() - val2: Int = add_10(val1) +returning_void :: (insert: int) + val1: int = return_constant() + val2: int = add_10(val1) return diff --git a/lang.h b/lang.h new file mode 100644 index 0000000..fa5ac68 --- /dev/null +++ b/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 +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 +//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) diff --git a/lex.c b/lex.c new file mode 100644 index 0000000..9c8b873 --- /dev/null +++ b/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", +}; diff --git a/main.cpp b/main.cpp index ca875b0..4a6f761 100644 --- a/main.cpp +++ b/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(); } diff --git a/new_ast.cpp b/new_ast.cpp index 5ba7281..4251eb7 100644 --- a/new_ast.cpp +++ b/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_int = intern_string(&interns, "Int"_s); + intern_void = intern_string(&interns, "void"_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); } }; diff --git a/new_lex.cpp b/new_lex.cpp index ebba091..f8f9d6d 100644 --- a/new_lex.cpp +++ b/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; diff --git a/new_types.kl b/new_types.kl index 37d1805..a38fbd1 100644 --- a/new_types.kl +++ b/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 diff --git a/order1.kl b/order1.kl index 71c6b38..86b6518 100644 --- a/order1.kl +++ b/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 diff --git a/order2.kl b/order2.kl index decbaee..e7556a2 100644 --- a/order2.kl +++ b/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 -deref := *poInter +pointer := &with_type +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 diff --git a/program.c b/program.c index 803a504..df0c593 100644 --- a/program.c +++ b/program.c @@ -1,5 +1,4 @@ - #include 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;(ikind){ - case TYPE_VOID: return "Void"; - case TYPE_INT: return "Int"; - case TYPE_UINT: return "UInt"; + case TYPE_VOID: return "void"; + case TYPE_INT: return "int"; + case TYPE_UINT: return "uint"; case TYPE_BOOL: return "Bool"; case TYPE_STRING: return "String";