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

Compiling and running first program!

Browse Source
This commit is contained in:
Krzosa Karol
2022-06-03 23:15:16 +02:00
parent 5e798bd179
commit a324a5abf0
16 changed files with 800 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
ccodegen.cpp
View File

@@ -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();

2
enums.kl
View File

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

38
globals.kl
View File

@@ -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

22
lambdas.kl
View File

@@ -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

86
lang.h Normal file
View File

@@ -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)

642
lex.c Normal file
View File

@@ -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",
};

4
main.cpp
View File

@@ -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();
}

6
new_ast.cpp
View File

@@ -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);
}
};

2
new_lex.cpp
View File

@@ -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;

2
new_types.kl
View File

@@ -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

2
order1.kl
View File

@@ -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

20
order2.kl
View File

@@ -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

11
program.c
View File

@@ -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);

2
program.kl
View File

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

4
typecheck.h
View File

@@ -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);

18
types.h
View File

@@ -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_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";