diff options
| -rw-r--r-- | Makefile | 11 | ||||
| -rw-r--r-- | README.md | 14 | ||||
| -rw-r--r-- | code/basic.felan | 1 | ||||
| -rw-r--r-- | code/lib/io.felan | 10 | ||||
| -rw-r--r-- | code/lib/memory.felan | 26 | ||||
| -rw-r--r-- | code/lib/operator.felan | 48 | ||||
| -rw-r--r-- | code/lib/print.felan | 172 | ||||
| -rw-r--r-- | code/lib/string.felan | 113 | ||||
| -rw-r--r-- | code/lib/types.felan | 2 | ||||
| -rw-r--r-- | code/lib/vector.felan | 47 | ||||
| -rw-r--r-- | code/main.felan | 184 | ||||
| -rw-r--r-- | src/backend/bba.c | 1 | ||||
| -rw-r--r-- | src/compiler/ast-tree.c | 1030 | ||||
| -rw-r--r-- | src/compiler/ast-tree.h | 24 | ||||
| -rw-r--r-- | src/compiler/lexer.c | 72 | ||||
| -rw-r--r-- | src/compiler/lexer.h | 10 | ||||
| -rw-r--r-- | src/compiler/parser.c | 27 | ||||
| -rw-r--r-- | src/compiler/parser.h | 1 | ||||
| -rw-r--r-- | src/runner/runner.c | 274 | ||||
| -rw-r--r-- | src/runner/runner.h | 5 | ||||
| -rw-r--r-- | src/utils/dl.c | 1 | ||||
| -rw-r--r-- | src/utils/dl.h | 2 |
22 files changed, 1305 insertions, 770 deletions
@@ -1,6 +1,7 @@ PROJECT_NAME := felan -CC := gcc +CC := cc +# CC := gcc # CC := tcc # CC := clang @@ -24,11 +25,11 @@ INC_FLAGS := $(addprefix -I,$(INC_DIRS)) # OP_FLAG := -Oz OP_FLAG := -g -LINK_FLAGS := -lffi +LDFLAGS := -lffi -# CFLAGS := $(INC_FLAGS) -Wall -Wextra -std=gnu23 $(LINK_FLAGS) -DPRINT_STATISTICS -DPRINT_COMPILE_TREE $(OP_FLAG) -CFLAGS := $(INC_FLAGS) -Wall -Wextra -std=gnu23 $(LINK_FLAGS) -DPRINT_STATISTICS $(OP_FLAG) -# CFLAGS := $(INC_FLAGS) -Wall -Wextra -std=gnu23 $(LINK_FLAGS) $(OP_FLAG) +# CFLAGS := $(INC_FLAGS) -Wall -Wextra -std=gnu23 -DPRINT_STATISTICS -DPRINT_COMPILE_TREE $(OP_FLAG) +CFLAGS := $(INC_FLAGS) -Wall -Wextra -std=gnu23 -DPRINT_STATISTICS $(OP_FLAG) +# CFLAGS := $(INC_FLAGS) -Wall -Wextra -std=gnu23 $(OP_FLAG) EXEC_FILE := $(BUILD_DIR)/$(PROJECT_NAME) @@ -1,4 +1,11 @@ # Felan + +<p align="center"> + <a href="https://github.com/A404M/felan"> + <img src="logo.png" width="400" alt="Felan logo"> + </a> +</p> + A strongly statically typed programming language with a simple and friendly syntax. The language has been influenced by many other languages to be more user friendly both for new programmers who don't have many years of programming with other languages and those who want a powerful tool for programming. # Features @@ -16,7 +23,7 @@ A strongly statically typed programming language with a simple and friendly synt * Linux or *nix like OS * git * gnu make -* gcc (you can use clang or tcc but you have to change make for it) +* c compiler (gcc, clang, tcc, ...) * libffi (for calling C functions) # How to use ? @@ -59,7 +66,10 @@ main :: () -> void { # TODO * ~Overloading [] operator~ * ~Add code injection~ -* Add macro +* ~Add macro~ +* ~Fix scope bug in shape shifters~ +* Add \u and \x to char +* Add vararg * Add enum * Compile AST to BBA * Compile BBA to ASM diff --git a/code/basic.felan b/code/basic.felan index 1e4ce2f..8f9adb0 100644 --- a/code/basic.felan +++ b/code/basic.felan @@ -3,3 +3,4 @@ @import("lib/io.felan"); @import("lib/memory.felan"); @import("lib/string.felan"); +@import("lib/vector.felan"); diff --git a/code/lib/io.felan b/code/lib/io.felan index c486902..d470331 100644 --- a/code/lib/io.felan +++ b/code/lib/io.felan @@ -14,14 +14,6 @@ println :: (value:anytype) -> void { print_char('\n'); }; -print :: (value:string) -> void { - i := 0; - while i < @cast(value.length,i64) { - print_char(value[i]); - i += 1; - } -}; - print_char :: (value:u8) -> void { putchar(@cast(value,i32)); }; @@ -80,7 +72,7 @@ _print_unsigned :: (comptime t:type, value:t) -> void { } {} while i < NUMBERS_SIZE - 1 { - @putc(numbers[i]); + print_char(numbers[i]); i += 1; } return; diff --git a/code/lib/memory.felan b/code/lib/memory.felan index f1f9898..0082a1e 100644 --- a/code/lib/memory.felan +++ b/code/lib/memory.felan @@ -1,11 +1,29 @@ +@import("operator.felan"); + libc :: @c_library("/usr/lib/libc.so.6"); malloc :: @c_function(libc,"malloc",(i64)->(*void)); +realloc :: @c_function(libc,"realloc",(*void,i64)->(*void)); free :: @c_function(libc,"free",(*void)->void); +memcpy :: @c_function(libc,"memcpy",(*void,*void,i64)->(*void)); + +malloc :: (size:u64,comptime t:type) -> (*t) { + return @cast(malloc(@cast(size*@size_of(t),i64)),*t); +}; + +realloc :: (ptr:*anytype,size:u64) -> (@type_of(ptr)) { + return @cast( + realloc( + @cast(ptr,*void), + @cast(size*@size_of(@type_of(ptr.*)),i64), + ), + @type_of(ptr) + ); +}; -malloc :: (size:i64,comptime t:type) -> (*t) { - return @cast(malloc(size*@cast(@size_of(t),i64)),*t); +free :: (ptr:*anytype) -> void { + free(@cast(ptr,*void)); }; -free :: (a:*anytype) -> void { - free(@cast(a,*void)); +memcpy :: (dest:*anytype,src:@type_of(dest),n:u64) -> void { + memcpy(@cast(dest,*void),@cast(src,*void),@cast(n,i64)); }; diff --git a/code/lib/operator.felan b/code/lib/operator.felan index b7ac63a..5536343 100644 --- a/code/lib/operator.felan +++ b/code/lib/operator.felan @@ -578,7 +578,7 @@ __logical_not__ :: (value:bool) -> bool { return value == false; }; -__logical_and__ :: (left:bool,lazy right:bool) -> bool { +__logical_and__ :: (left:bool,right:bool) macro -> bool { if left == false { return false; } else if right == false { @@ -588,7 +588,7 @@ __logical_and__ :: (left:bool,lazy right:bool) -> bool { } }; -__logical_or__ :: (left:bool,lazy right:bool) -> bool { +__logical_or__ :: (left:bool,right:bool) macro -> bool { if left == true { return true; } else if right == true { @@ -800,28 +800,48 @@ __sub__ :: (left:*anytype,right:i64) -> (@type_of(left)) { return @sub(left,right); }; -__get_item__ :: (left:*anytype,index:i64) -> (@type_of(left.*)) { - return (left + index).*; +__sum__ :: (left:*anytype,right:u64) -> (@type_of(left)) { + return @add(left,right); +}; + +__sub__ :: (left:*anytype,right:u64) -> (@type_of(left)) { + return @sub(left,right); +}; + +__get_item__ :: (left:**anytype,index:i64) -> (@type_of(left.*.*)) { + return (left.* + index).*; }; -__set_item__ :: (left:*anytype,index:i64,item:@type_of(left.*)) -> (@type_of(left.*)) { - return (left + index).* = item; +__set_item__ :: (left:**anytype,index:i64,item:@type_of(left.*.*)) -> (@type_of(left.*.*)) { + return (left.* + index).* = item; }; -__get_item_address__ :: (left:*anytype,index:i64) -> (@type_of(left)) { - return (left + index); +__get_item_address__ :: (left:**anytype,index:i64) -> (@type_of(left.*)) { + return (left.* + index); }; //---------------------- Array ------------------------ -__get_item__ :: (left:[]anytype,index:i64) -> (@type_of(left.ptr.*)) { - return (left.ptr + index).*; +__get_item__ :: (left:*[]anytype,index:i64) -> (@type_of(left.*.ptr.*)) { + return (left.*.ptr + index).*; +}; + +__set_item__ :: (left:*[]anytype,index:i64,item:@type_of(left.*.ptr.*)) -> (@type_of(left.*.ptr.*)) { + return (left.*.ptr + index).* = item; +}; + +__get_item_address__ :: (left:*[]anytype,index:i64) -> (@type_of(left.*.ptr)) { + return (left.*.ptr + index); +}; + +__get_item__ :: (left:*[]anytype,index:u64) -> (@type_of(left.*.ptr.*)) { + return (left.*.ptr + index).*; }; -__set_item__ :: (left:[]anytype,index:i64,item:@type_of(left.ptr.*)) -> (@type_of(left.ptr.*)) { - return (left.ptr + index).* = item; +__set_item__ :: (left:*[]anytype,index:u64,item:@type_of(left.*.ptr.*)) -> (@type_of(left.*.ptr.*)) { + return (left.*.ptr + index).* = item; }; -__get_item_address__ :: (left:[]anytype,index:i64) -> (@type_of(left.ptr)) { - return (left.ptr + index); +__get_item_address__ :: (left:*[]anytype,index:u64) -> (@type_of(left.*.ptr)) { + return (left.*.ptr + index); }; diff --git a/code/lib/print.felan b/code/lib/print.felan deleted file mode 100644 index 2680921..0000000 --- a/code/lib/print.felan +++ /dev/null @@ -1,172 +0,0 @@ -print :: (value:bool)->void{ - if value print("true"); - else print("false"); -}; - -print :: (value:u8)->void{ - putc value; -}; - -print :: (value:[]u8)->void{ - i :u64= 0; - while i < value.length { - putc value[i]; - i += 1; - } -}; - -print_reverse :: (value:[]u8, size:u8)->void{ - size := size; - while size != 0 { - size -= 1; - putc value[size]; - } -}; - -print :: (value:i8)->void { - value := value; - if (value < 0) { - putc '-'; - if (value == -128) { - print("128"); - return; - } - value = -value; - } - - output :[3]u8= undefined; - i :u8= 0; - while { - output[i] = '0' + @cast(value % 10, u8); - i += 1; - value /= 10; - value != 0; - } {} - - print_reverse(output, i - 1); -}; - -print :: (value:i16)->void { - value := value; - if (value < 0) { - putc '-'; - if (value == -32768) { - print("32768"); - return; - } - value = -value; - } - - output :[5]u8= undefined; - i :u8= 0; - while { - output[i] = '0' + @cast(value % 10, u8); - i += 1; - value /= 10; - value != 0; - } {} - - print_reverse(output, i); -}; - -print :: (value:i32)->void { - value := value; - if (value < 0) { - putc '-'; - if (value == -2147483648) { - print("2147483648"); - return; - } - value = -value; - } - - output :[10]u8= undefined; - i :u8= 0; - while { - output[i] = '0' + @cast(value % 10, u8); - i += 1; - value /= 10; - value != 0; - } {} - - print_reverse(output, i - 1); -}; - -print :: (value:i64)->void { - value := value; - if (value < 0) { - putc '-'; - if (value == -9223372036854775808) { - print("9223372036854775808"); - return; - } - value = -value; - } - - output :[19]u8= undefined; - i :u8= 0; - while { - output[i] = '0' + @cast(value % 10, u8); - i += 1; - value /= 10; - value != 0; - } {} - - print_reverse(output, i - 1); -}; - -print :: (value:u8)->void{ - value := value; - result :[3]u8 = undefined; - i :u8= 0; - while { - result[i] = '0' + @cast(value % 10,u8); - i += 1; - value /= 10; - value != 0; - } {} - - print_reverse(result, i - 1); -}; - -print :: (value:u16)->void{ - value := value; - result :[5]u8 = undefined; - i :u8= 0; - while { - result[i] = '0' + @cast(value % 10,u8); - i += 1; - value /= 10; - value != 0; - } {} - - print_reverse(result, i - 1); -}; - -print :: (value:u32)->void{ - value := value; - result :[10]u8 = undefined; - i :u8= 0; - while { - result[i] = '0' + @cast(value % 10,u8); - i += 1; - value /= 10; - value != 0; - } {} - - print_reverse(result, i - 1); -}; - -print :: (value:u64)->void{ - value := value; - result :[20]u8 = undefined; - i :u8= 0; - while { - result[i] = '0' + @cast(value % 10,u8); - i += 1; - value /= 10; - value != 0; - } {} - - print_reverse(result, i - 1); -}; diff --git a/code/lib/string.felan b/code/lib/string.felan index c7047b3..789b0fb 100644 --- a/code/lib/string.felan +++ b/code/lib/string.felan @@ -1,9 +1,114 @@ @import("operator.felan"); +@import("io.felan"); @import("types.felan"); +@import("memory.felan"); + +String :: struct { + ptr : *u8; + size : u64; + capacity : u64; +}; + +string_new :: () -> String { + str : String = undefined; + + str.ptr = malloc(0u64,u8); + str.size = 0u64; + str.capacity = 0u64; + + return str; +}; + +string_from :: (str:[]u8) -> String { + result : String = undefined; + + result.ptr = malloc(str.length,u8); + result.size = str.length; + result.capacity = str.length; + + memcpy(result.ptr,str.ptr,str.length); + + return result; +}; + +append :: (this:*String, str:String) -> void { + _grow_if_needed(this, str.size); + + memcpy(this.*.ptr+this.*.size,str.ptr,str.size); + + this.*.size += str.size; +}; + +append :: (this:*String, str:[]u8) -> void { + _grow_if_needed(this, str.length); + + memcpy(this.*.ptr+this.*.size,str.ptr,str.length); + + this.*.size += str.length; +}; + +append :: (this:*String, char:u8) -> void { + _grow_if_needed(this, 1u64); + + this.*[this.*.size] = char; + + this.*.size += 1u64; +}; + +_grow_if_needed :: (this:*String, count:u64) -> void { + new_size := this.*.size + count; + if new_size >= this.*.capacity { + cap := this.*.capacity + this.*.capacity / 2u64 + 1u64; + if new_size >= cap { + cap = new_size; + } + this.*.capacity = cap; + this.*.ptr = realloc(this.*.ptr,this.*.capacity); + } +}; + +slice :: (this:String, begin:i64, end:i64) -> String { + result:String = undefined; + + result.ptr = this.ptr + begin; + result.size = @cast(end-begin,u64); + result.capacity = 0u64; -sub_string :: (str:string, begin:i64, end:i64) -> string { - result :[0]u8 = undefined; - result.ptr = str.ptr + begin; - result.length = @cast(end-begin,u64); return result; }; + +delete :: (this:String) -> void { + free(this.ptr); +}; + +print :: (this:String) -> void { + i := 0u64; + while i < this.size { + print_char(this[i]); + i += 1u64; + } +}; + +__get_item__ :: (left:*String,index:i64) -> u8 { + return (left.*.ptr + index).*; +}; + +__set_item__ :: (left:*String,index:i64,item:u8) -> u8 { + return (left.*.ptr + index).* = item; +}; + +__get_item_address__ :: (left:*String,index:i64) -> (*u8) { + return (left.*.ptr + index); +}; + +__get_item__ :: (left:*String,index:u64) -> u8 { + return (left.*.ptr + index).*; +}; + +__set_item__ :: (left:*String,index:u64,item:u8) -> u8 { + return (left.*.ptr + index).* = item; +}; + +__get_item_address__ :: (left:*String,index:u64) -> (*u8) { + return (left.*.ptr + index); +}; diff --git a/code/lib/types.felan b/code/lib/types.felan index df7f5c3..087f884 100644 --- a/code/lib/types.felan +++ b/code/lib/types.felan @@ -1,5 +1,3 @@ -string :: []u8; - array :: (comptime size:u64, comptime t:type) -> type { return struct { ptr : *t; diff --git a/code/lib/vector.felan b/code/lib/vector.felan new file mode 100644 index 0000000..61fe77c --- /dev/null +++ b/code/lib/vector.felan @@ -0,0 +1,47 @@ +@import("operator.felan"); +@import("memory.felan"); + +vector :: (comptime t:type)->type{ + return struct { + ptr : *t; + size : u64; + capacity : u64; + }; +}; + +vector_new :: (comptime t:type) -> (vector(t)) { + v : vector(t) = undefined; + v.ptr = malloc(0u64,@type_of(v.ptr.*)); + v.size = 0u64; + v.capacity = 0u64; + return v; +}; + +__get_item__ :: (left:*vector(anytype),index:i64) -> (@type_of(left.*.ptr.*)) { + return (left.*.ptr + index).*; +}; + +__set_item__ :: (left:*vector(anytype),index:i64,item:@type_of(left.*.ptr.*)) -> (@type_of(left.*.ptr.*)) { + return (left.*.ptr + index).* = item; +}; + +__get_item_address__ :: (left:*vector(anytype),index:i64) -> (@type_of(left.*.ptr)) { + return (left.*.ptr + index); +}; + +push_back :: (vec:*vector(anytype),value:@type_of(vec.*[0])) -> void { + _grow_if_needed(vec); + vec.*[@cast(vec.*.size,i64)] = value; + vec.*.size += 1u64; +}; + +_grow_if_needed :: (vec:*vector(anytype)) -> void { + if vec.*.size == vec.*.capacity { + vec.*.capacity = vec.*.capacity + vec.*.capacity/2u64 + 1u64; + vec.*.ptr = realloc(vec.*.ptr,vec.*.capacity); + } +}; + +delete :: (vec:vector(anytype)) -> void { + free(vec.ptr); +}; diff --git a/code/main.felan b/code/main.felan index e80b7fc..b8b41ec 100644 --- a/code/main.felan +++ b/code/main.felan @@ -1,33 +1,169 @@ @import("basic.felan"); -file :: @import("file.felan"); - -t :: (comptime formatter : string) macro -> string { - i := 0; - in := 0; - opening := 0; - while @cast(i,u64) < formatter.length { - c := formatter[i]; - if c == '{' { - if in == 0 { - opening = i+1; + +raylib :: @c_library("/usr/lib/libraylib.so.5.5.0"); +InitWindow :: @c_function(raylib,"InitWindow",(i32,i32,*u8)->void); +SetTargetFPS :: @c_function(raylib,"SetTargetFPS",(i32)->void); +WindowShouldClose :: @c_function(raylib,"WindowShouldClose",()->bool); +CloseWindow :: @c_function(raylib,"CloseWindow",()->void); +BeginDrawing :: @c_function(raylib,"BeginDrawing",()->void); +ClearBackground :: @c_function(raylib,"ClearBackground",(Color)->void); +EndDrawing :: @c_function(raylib,"EndDrawing",()->void); +IsKeyPressed :: @c_function(raylib,"IsKeyPressed",(i32)->bool); +IsGestureDetected :: @c_function(raylib,"IsGestureDetected",(u32)->bool); +DrawText :: @c_function(raylib,"DrawText",(*u8,i32,i32,i32,Color)->void); +DrawRectangle :: @c_function(raylib,"DrawRectangle",(i32,i32,i32,i32,Color)->void); +GetFPS :: @c_function(raylib,"GetFPS",()->i32); +DrawLine :: @c_function(raylib,"DrawLine",(startPosX:i32,startPosY:i32,endPosX:i32,endPosY:i32,color:Color)->void); + +Color :: struct { + r:u8; + g:u8; + b:u8; + a:u8; +}; + +KEY_ENTER :: 257i32; + +GESTURE_TAP :: 1u32; + +LOGO :: 0; +TITLE :: 1; +GAMEPLAY :: 2; +ENDING :: 3; + +SCREEN_WIDTH :: 800i32; +SCREEN_HEIGHT :: 450i32; + +RAYWHITE :: color(245u8,245u8,245u8,255u8); +LIGHTGRAY :: color(200u8,200u8,200u8,255u8); +GRAY :: color(130u8,130u8,130u8,255u8); +GREEN :: color(0u8,228u8,48u8,255u8); +DARKGREEN :: color(0u8,117u8,44u8,255u8); +BLUE :: color(0u8,121u8,241u8,255u8); +DARKBLUE :: color(0u8,82u8,172u8,255u8); +PURPLE :: color(200u8,122u8,255u8,255u8); +MAROON :: color(100u8,33u8,55u8,255u8); + +main :: () -> void { + title := "Hello\0"; + + InitWindow(SCREEN_WIDTH,SCREEN_HEIGHT,title.ptr); + + currentScreen := LOGO; + + framesCounter := 0i32; + + TARGET_FPS :: 144i32; + SetTargetFPS(TARGET_FPS); + + while(!WindowShouldClose()){ + if currentScreen == LOGO { + framesCounter += 1i32; + if framesCounter > TARGET_FPS * 2i32 { + currentScreen = TITLE; } - in += 1; - } else if c == '}' { - in -= 1; - if in == 0 { - return sub_string(formatter,opening,i); - } else if in < 0 { - in = 0; + } else if currentScreen == TITLE { + if IsKeyPressed(KEY_ENTER) || IsGestureDetected(GESTURE_TAP) { + currentScreen = GAMEPLAY; } + } else if currentScreen == GAMEPLAY { + if IsKeyPressed(KEY_ENTER) || IsGestureDetected(GESTURE_TAP) { + currentScreen = ENDING; + } + } else if currentScreen == ENDING { + if IsKeyPressed(KEY_ENTER) || IsGestureDetected(GESTURE_TAP) { + currentScreen = TITLE; + } + } + + BeginDrawing(); + + if currentScreen == LOGO { + drawLogo(); + } else if currentScreen == TITLE { + ClearBackground(GREEN); + title := "TITLE SCREEN\0"; + DrawText(title.ptr,20i32,20i32,40i32,DARKGREEN); + text := "PRESS ENTER or TAP to JUMP to GAMEPLAY SCREEN\0"; + DrawText(text.ptr,120i32,220i32,20i32,DARKGREEN); + } else if currentScreen == GAMEPLAY { + drawGamePlay(); + } else if currentScreen == ENDING { + ClearBackground(BLUE); + title := "ENDING SCREEN\0"; + DrawText(title.ptr,20i32,20i32,40i32,DARKBLUE); + text := "PRESS ENTER or TAP to RETURN to TITLE SCREEN\0"; + DrawText(text.ptr,120i32,220i32,20i32,DARKBLUE); + } else { + println(-1); + return; } - i += 1; + + EndDrawing(); } - return ""; + + CloseWindow(); }; -main :: () -> void { - arr :[10][]u8 = undefined; - arr[0] = "Hello"; - print(arr[0]); +drawLogo :: () -> void { + ClearBackground(RAYWHITE); + title := "LOGO SCREEN\0"; + DrawText(title.ptr,20i32,20i32,40i32,LIGHTGRAY); + text := "WAIT for 2 SECONDS...\0"; + DrawText(text.ptr,290i32,220i32,20i32,LIGHTGRAY); +}; + +x := 0i32; +y := 0i32; + +dx := 1i32; +dy := 1i32; + +RECT_SIZE :: 40i32; + +drawGamePlay :: () -> void { + ClearBackground(PURPLE); + title := "GAMEPLAY SCREEN\0"; + DrawText(title.ptr,20i32,20i32,40i32,MAROON); + text := "PRESS ENTER or TAP to JUMP to ENDING SCREEN\0"; + DrawText(text.ptr,130i32,220i32,20i32,MAROON); + DrawRectangle(x,y,RECT_SIZE,RECT_SIZE,MAROON); + DrawLine(SCREEN_WIDTH/2i32,0i32,SCREEN_WIDTH/2i32,SCREEN_HEIGHT,MAROON); + + x += dx; + y += dy; + if x <= 0i32 { + dx = 1i32; + } else if x+RECT_SIZE >= SCREEN_WIDTH { + dx = -1i32; + } + + if y <= 0i32 { + dy = 1i32; + } else if y+RECT_SIZE >= SCREEN_HEIGHT { + dy = -1i32; + } +}; + +color :: (r:u8,g:u8,b:u8,a:u8)->Color { + result:Color = undefined; + + result.r = r; + result.g = g; + result.b = b; + result.a = a; + + return result; }; + +color :: (value : u32) -> Color { + result:Color = undefined; + + result.r = @cast(value >> @cast(3*8,u32),u8); + result.g = @cast(value >> @cast(2*8,u32),u8); + result.b = @cast(value >> @cast(1*8,u32),u8); + result.a = @cast(value >> @cast(0*8,u32),u8); + + return result; +}; diff --git a/src/backend/bba.c b/src/backend/bba.c index e69de29..fe156c6 100644 --- a/src/backend/bba.c +++ b/src/backend/bba.c @@ -0,0 +1 @@ +#include "bba.h" diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c index acbf8ed..057e96d 100644 --- a/src/compiler/ast-tree.c +++ b/src/compiler/ast-tree.c @@ -175,6 +175,14 @@ AstTree AST_TREE_C_LIBRARY_TYPE = { .str_end = NULL, }; +AstTree AST_TREE_MACRO_TYPE = { + .token = AST_TREE_TOKEN_TYPE_MACRO, + .metadata = NULL, + .type = &AST_TREE_TYPE_TYPE, + .str_begin = NULL, + .str_end = NULL, +}; + AstTree AST_TREE_VOID_VALUE = { .token = AST_TREE_TOKEN_VALUE_VOID, .metadata = NULL, @@ -248,6 +256,7 @@ const char *AST_TREE_TOKEN_STRINGS[] = { "AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER", "AST_TREE_TOKEN_TYPE_C_LIBRARY", "AST_TREE_TOKEN_TYPE_C_FUNCTION", + "AST_TREE_TOKEN_TYPE_MACRO", "AST_TREE_TOKEN_TYPE_BOOL", "AST_TREE_TOKEN_VALUE_VOID", @@ -260,6 +269,7 @@ const char *AST_TREE_TOKEN_STRINGS[] = { "AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER", "AST_TREE_TOKEN_VALUE_C_LIBRARY", "AST_TREE_TOKEN_VALUE_C_FUNCTION", + "AST_TREE_TOKEN_VALUE_MACRO", "AST_TREE_TOKEN_VALUE_INT", "AST_TREE_TOKEN_VALUE_FLOAT", "AST_TREE_TOKEN_VALUE_BOOL", @@ -411,7 +421,7 @@ void astTreePrint(const AstTree *tree, int indent) { case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED: goto RETURN_SUCCESS; case AST_TREE_TOKEN_TYPE_C_FUNCTION: - NOT_IMPLEMENTED; + goto RETURN_SUCCESS; case AST_TREE_TOKEN_KEYWORD_BREAK: case AST_TREE_TOKEN_KEYWORD_CONTINUE: { AstTreeLoopControl *meatadata = tree->metadata; @@ -544,8 +554,8 @@ void astTreePrint(const AstTree *tree, int indent) { for (int i = 0; i < indent; ++i) printf(" "); printf("paramters=[\n"); - for (size_t i = 0; i < metadata->parameters_size; ++i) { - AstTreeFunctionCallParam param = metadata->parameters[i]; + for (size_t i = 0; i < metadata->parameters.size; ++i) { + AstTreeFunctionCallParam param = metadata->parameters.data[i]; for (int i = 0; i < indent + 1; ++i) printf(" "); printf("{name:\"%.*s\",\n", (int)(param.nameEnd - param.nameBegin), @@ -601,7 +611,11 @@ void astTreePrint(const AstTree *tree, int indent) { for (int i = 0; i < indent; ++i) printf(" "); printf("elseBody=\n"); - astTreePrint(metadata->elseBody, indent + 1); + if (metadata->elseBody != NULL) { + astTreePrint(metadata->elseBody, indent + 1); + } else { + printf("null"); + } printf("\n"); for (int i = 0; i < indent; ++i) printf(" "); @@ -699,6 +713,8 @@ void astTreePrint(const AstTree *tree, int indent) { case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: + case AST_TREE_TOKEN_VALUE_MACRO: goto RETURN_SUCCESS; case AST_TREE_TOKEN_NONE: } @@ -769,6 +785,15 @@ void astTreeRootPrint(const AstTreeRoot *root) { } #endif +void astTreeTypeFunctionDestroy(AstTreeTypeFunction functionType) { + for (size_t i = 0; i < functionType.arguments_size; ++i) { + AstTreeTypeFunctionArgument arg = functionType.arguments[i]; + astTreeDelete(arg.type); + } + astTreeDelete(functionType.returnType); + free(functionType.arguments); +} + void astTreeScopeDestroy(AstTreeScope scope) { for (size_t i = 0; i < scope.expressions_size; ++i) { astTreeDelete(scope.expressions[i]); @@ -797,10 +822,10 @@ void astTreeDeleteFunctionCall(AstTreeFunctionCall *functionCall) { if (functionCall->function != NULL) { astTreeDelete(functionCall->function); } - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - astTreeDelete(functionCall->parameters[i].value); + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + astTreeDelete(functionCall->parameters.data[i].value); } - free(functionCall->parameters); + free(functionCall->parameters.data); free(functionCall); } @@ -865,6 +890,7 @@ void astTreeDestroy(AstTree tree) { case AST_TREE_TOKEN_TYPE_NAMESPACE: case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_TYPE_BOOL: case AST_TREE_TOKEN_VALUE_NULL: case AST_TREE_TOKEN_VALUE_UNDEFINED: @@ -890,12 +916,23 @@ void astTreeDestroy(AstTree tree) { for (size_t i = 0; i < metadata->generateds.size; ++i) { astTreeFunctionDestroy(*metadata->generateds.functions[i]); free(metadata->generateds.functions[i]); + for (size_t j = 0; j < metadata->generateds.calls[i].size; ++j) { + astTreeDelete(metadata->generateds.calls[i].data[j].value); + } + free(metadata->generateds.calls[i].data); } free(metadata->generateds.functions); free(metadata->generateds.calls); free(metadata); return; } + case AST_TREE_TOKEN_VALUE_MACRO: { + AstTreeMacro *metadata = tree.metadata; + astTreeFunctionDestroy(*metadata->function); + free(metadata->function); + free(metadata); + return; + } case AST_TREE_TOKEN_VALUE_BOOL: { AstTreeBool *metadata = tree.metadata; free(metadata); @@ -944,12 +981,7 @@ void astTreeDestroy(AstTree tree) { return; case AST_TREE_TOKEN_TYPE_FUNCTION: { AstTreeTypeFunction *metadata = tree.metadata; - for (size_t i = 0; i < metadata->arguments_size; ++i) { - AstTreeTypeFunctionArgument arg = metadata->arguments[i]; - astTreeDelete(arg.type); - } - astTreeDelete(metadata->returnType); - free(metadata->arguments); + astTreeTypeFunctionDestroy(*metadata); free(metadata); } return; @@ -1111,7 +1143,8 @@ bool astTreeShouldDelete(AstTree *tree) { tree != &AST_TREE_F128_TYPE && tree != &AST_TREE_CODE_TYPE && tree != &AST_TREE_NAMESPACE_TYPE && tree != &AST_TREE_SHAPE_SHIFTER_TYPE && - tree != &AST_TREE_C_LIBRARY_TYPE && tree != &AST_TREE_VOID_VALUE; + tree != &AST_TREE_C_LIBRARY_TYPE && tree != &AST_TREE_MACRO_TYPE && + tree != &AST_TREE_VOID_VALUE; } void astTreeRootDelete(AstTreeRoot *root) { @@ -1185,6 +1218,7 @@ AstTree *copyAstTreeBack(AstTree *tree, AstTreeVariables oldVariables[], case AST_TREE_TOKEN_TYPE_NAMESPACE: case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: + case AST_TREE_TOKEN_TYPE_MACRO: return tree; case AST_TREE_TOKEN_VALUE_VOID: if (tree == &AST_TREE_VOID_VALUE) { @@ -1264,7 +1298,19 @@ AstTree *copyAstTreeBack(AstTree *tree, AstTreeVariables oldVariables[], new_metadata->generateds.functions[i] = copyAstTreeFunction(metadata->generateds.functions[i], oldVariables, newVariables, variables_size, false); - new_metadata->generateds.calls[i] = metadata->generateds.calls[i]; + + new_metadata->generateds.calls[i].size = + metadata->generateds.calls[i].size; + + new_metadata->generateds.calls[i].data = + a404m_malloc(sizeof(*new_metadata->generateds.calls[i].data) * + new_metadata->generateds.calls[i].size); + + for (size_t j = 0; j < new_metadata->generateds.calls[i].size; ++j) { + new_metadata->generateds.calls[i].data[j].value = + copyAstTreeBack(metadata->generateds.calls[i].data[j].value, + oldVariables, newVariables, variables_size, false); + } } return newAstTree(tree->token, new_metadata, @@ -1682,10 +1728,23 @@ AstTree *copyAstTreeBack(AstTree *tree, AstTreeVariables oldVariables[], variables_size, safetyCheck), tree->str_begin, tree->str_end); } + case AST_TREE_TOKEN_VALUE_MACRO: { + AstTreeMacro *metadata = tree->metadata; + AstTreeMacro *new_metadata = a404m_malloc(sizeof(*new_metadata)); + + new_metadata->function = copyAstTreeFunction( + metadata->function, oldVariables, newVariables, variables_size, true); + + return newAstTree(tree->token, new_metadata, + copyAstTreeBack(tree->type, oldVariables, newVariables, + variables_size, safetyCheck), + tree->str_begin, tree->str_end); + } case AST_TREE_TOKEN_NONE: } printLog("Bad token %d", tree->token); UNREACHABLE; + return NULL; } AstTreeVariable *copyAstTreeBackFindVariable(AstTreeVariable *variable, @@ -1726,7 +1785,6 @@ AstTreeVariables copyAstTreeVariables(AstTreeVariables variables, result.data[i]->name_begin = variables.data[i]->name_begin; result.data[i]->name_end = variables.data[i]->name_end; result.data[i]->isConst = variables.data[i]->isConst; - result.data[i]->isLazy = variables.data[i]->isLazy; result.data[i]->type = copyAstTreeBack(variables.data[i]->type, new_oldVariables, new_newVariables, new_variables_size, safetyCheck); @@ -1811,14 +1869,16 @@ AstTreeFunctionCall *copyAstTreeFunctionCall(AstTreeFunctionCall *metadata, copyAstTreeBack(metadata->function, oldVariables, newVariables, variables_size, safetyCheck); - new_metadata->parameters_size = metadata->parameters_size; - new_metadata->parameters = a404m_malloc(metadata->parameters_size * - sizeof(*new_metadata->parameters)); - for (size_t i = 0; i < metadata->parameters_size; ++i) { - new_metadata->parameters[i].nameBegin = metadata->parameters[i].nameBegin; - new_metadata->parameters[i].nameEnd = metadata->parameters[i].nameEnd; - new_metadata->parameters[i].value = - copyAstTreeBack(metadata->parameters[i].value, oldVariables, + new_metadata->parameters.size = metadata->parameters.size; + new_metadata->parameters.data = a404m_malloc( + metadata->parameters.size * sizeof(*new_metadata->parameters.data)); + for (size_t i = 0; i < metadata->parameters.size; ++i) { + new_metadata->parameters.data[i].nameBegin = + metadata->parameters.data[i].nameBegin; + new_metadata->parameters.data[i].nameEnd = + metadata->parameters.data[i].nameEnd; + new_metadata->parameters.data[i].value = + copyAstTreeBack(metadata->parameters.data[i].value, oldVariables, newVariables, variables_size, safetyCheck); } @@ -1952,7 +2012,8 @@ bool astTreeDoImport(AstTreeRoots *roots, AstTreeRoot *root, AstTree *tree, .lookingType = NULL, .dependencies.data = NULL, .dependencies.size = 0, - .variables = root->variables, + .variables = &root->variables, + .variables_size = 1, .root = root, .loops = NULL, .loops_size = 0, @@ -1962,7 +2023,7 @@ bool astTreeDoImport(AstTreeRoots *roots, AstTreeRoot *root, AstTree *tree, if (!setAllTypes(tree, helper, NULL, NULL)) { return false; } - AstTree *parameter = tree_metadata->parameters[0].value; + AstTree *parameter = tree_metadata->parameters.data[0].value; if (!isConst(parameter)) { printError(parameter->str_begin, parameter->str_end, "Is not constant"); return false; @@ -2055,7 +2116,6 @@ AstTreeRoot *makeAstRoot(const ParserNode *parsedRoot, char *filePath) { variable->name_begin = node_metadata->name->str_begin; variable->name_end = node_metadata->name->str_end; variable->isConst = node->token == PARSER_TOKEN_CONSTANT; - variable->isLazy = node_metadata->isLazy; if (node_metadata->isComptime && !variable->isConst) { printError(node->str_begin, node->str_end, "Bad comptime %s", @@ -2105,7 +2165,7 @@ AstTreeRoot *makeAstRoot(const ParserNode *parsedRoot, char *filePath) { AstTreeFunctionCall *tree_metadata = tree->metadata; AstTree *operand = tree_metadata->function; if (operand->token == AST_TREE_TOKEN_BUILTIN_IMPORT) { - if (tree_metadata->parameters_size == 1) { + if (tree_metadata->parameters.size == 1) { goto PUSH; } } @@ -2618,7 +2678,6 @@ AstTree *astTreeParseFunction(const ParserNode *parserNode) { argument->name_begin = arg_metadata->name->str_begin; argument->name_end = arg_metadata->name->str_end; argument->isConst = arg_metadata->isComptime; - argument->isLazy = arg_metadata->isLazy; if (!pushVariable(&function->arguments, argument)) { astTreeVariableDelete(argument); @@ -2890,11 +2949,11 @@ AstTree *astTreeParseFunctionCall(const ParserNode *parserNode) { AstTreeFunctionCall *metadata = a404m_malloc(sizeof(*metadata)); metadata->function = function; - metadata->parameters = - a404m_malloc(sizeof(*metadata->parameters) * node_metadata->params->size); - metadata->parameters_size = node_metadata->params->size; + metadata->parameters.data = a404m_malloc(sizeof(*metadata->parameters.data) * + node_metadata->params->size); + metadata->parameters.size = node_metadata->params->size; - for (size_t i = 0; i < metadata->parameters_size; ++i) { + for (size_t i = 0; i < metadata->parameters.size; ++i) { const ParserNode *node_param = node_metadata->params->data[i]; if (node_param->token == PARSER_TOKEN_SYMBOL_COMMA) { node_param = (ParserNodeSingleChildMetadata *)node_param->metadata; @@ -2912,7 +2971,7 @@ AstTree *astTreeParseFunctionCall(const ParserNode *parserNode) { param.nameBegin = param.nameEnd = NULL; param.value = astTreeParse(node_param); PUSH_PARAM: - metadata->parameters[i] = param; + metadata->parameters.data[i] = param; } return newAstTree(AST_TREE_TOKEN_FUNCTION_CALL, metadata, NULL, @@ -2992,6 +3051,7 @@ AstTree *astTreeParseIntValue(const ParserNode *parserNode) { } } UNREACHABLE; + return NULL; } AstTree *astTreeParseString(const ParserNode *parserNode) { @@ -3078,15 +3138,15 @@ AstTree *astTreeParseAssignOperator(const ParserNode *parserNode, left->token = AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ASSIGN; AstTreeFunctionCall *metadata = left->metadata; - metadata->parameters = - a404m_realloc(metadata->parameters, (metadata->parameters_size + 1) * - sizeof(*metadata->parameters)); + metadata->parameters.data = a404m_realloc( + metadata->parameters.data, + (metadata->parameters.size + 1) * sizeof(*metadata->parameters.data)); - metadata->parameters[metadata->parameters_size].value = right; - metadata->parameters[metadata->parameters_size].nameBegin = NULL; - metadata->parameters[metadata->parameters_size].nameEnd = NULL; + metadata->parameters.data[metadata->parameters.size].value = right; + metadata->parameters.data[metadata->parameters.size].nameBegin = NULL; + metadata->parameters.data[metadata->parameters.size].nameEnd = NULL; - metadata->parameters_size += 1; + metadata->parameters.size += 1; return left; } else { @@ -3116,15 +3176,15 @@ AstTree *astTreeParseBinaryOperator(const ParserNode *parserNode, AstTreeFunctionCall *metadata = a404m_malloc(sizeof(*metadata)); - metadata->parameters_size = 2; - metadata->parameters = - a404m_malloc(metadata->parameters_size * sizeof(*metadata->parameters)); - metadata->parameters[0] = (AstTreeFunctionCallParam){ + metadata->parameters.size = 2; + metadata->parameters.data = a404m_malloc(metadata->parameters.size * + sizeof(*metadata->parameters.data)); + metadata->parameters.data[0] = (AstTreeFunctionCallParam){ .value = left, .nameBegin = NULL, .nameEnd = NULL, }; - metadata->parameters[1] = (AstTreeFunctionCallParam){ + metadata->parameters.data[1] = (AstTreeFunctionCallParam){ .value = right, .nameBegin = NULL, .nameEnd = NULL, @@ -3140,18 +3200,18 @@ AstTree *astTreeParseUnaryOperator(const ParserNode *parserNode, ParserNodeSingleChildMetadata *node_metadata = parserNode->metadata; AstTreeFunctionCall *metadata = a404m_malloc(sizeof(*metadata)); - metadata->parameters_size = 1; - metadata->parameters = - a404m_malloc(metadata->parameters_size * sizeof(*metadata->parameters)); + metadata->parameters.size = 1; + metadata->parameters.data = a404m_malloc(metadata->parameters.size * + sizeof(*metadata->parameters.data)); AstTree *operand = astTreeParse(node_metadata); if (operand == NULL) { - free(metadata->parameters); + free(metadata->parameters.data); free(metadata); return NULL; } - metadata->parameters[0] = (AstTreeFunctionCallParam){ + metadata->parameters.data[0] = (AstTreeFunctionCallParam){ .value = operand, .nameBegin = NULL, .nameEnd = NULL, @@ -3208,15 +3268,15 @@ AstTree *astTreeParseOperateAssignOperator(const ParserNode *parserNode, AstTreeFunctionCall *metadata = a404m_malloc(sizeof(*metadata)); - metadata->parameters_size = 2; - metadata->parameters = - a404m_malloc(metadata->parameters_size * sizeof(*metadata->parameters)); - metadata->parameters[0] = (AstTreeFunctionCallParam){ + metadata->parameters.size = 2; + metadata->parameters.data = a404m_malloc(metadata->parameters.size * + sizeof(*metadata->parameters.data)); + metadata->parameters.data[0] = (AstTreeFunctionCallParam){ .value = left, .nameBegin = NULL, .nameEnd = NULL, }; - metadata->parameters[1] = (AstTreeFunctionCallParam){ + metadata->parameters.data[1] = (AstTreeFunctionCallParam){ .value = right, .nameBegin = NULL, .nameEnd = NULL, @@ -3268,7 +3328,6 @@ bool astTreeParseConstant(const ParserNode *parserNode, variable->name_begin = node_metadata->name->str_begin; variable->name_end = node_metadata->name->str_end; variable->isConst = true; - variable->isLazy = node_metadata->isLazy; if (!pushVariable(variables, variable)) { astTreeVariableDelete(variable); @@ -3320,7 +3379,6 @@ AstTree *astTreeParseVariable(const ParserNode *parserNode, variable->name_begin = node_metadata->name->str_begin; variable->name_end = node_metadata->name->str_end; variable->isConst = false; - variable->isLazy = node_metadata->isLazy; if (!pushVariable(variables, variable)) { astTreeVariableDelete(variable); @@ -3642,7 +3700,6 @@ AstTree *astTreeParseStruct(const ParserNode *parserNode) { variable->initValue = NULL; variable->isConst = false; } - variable->isLazy = node_variable->isLazy; variables.data[i] = variable; } @@ -3689,6 +3746,11 @@ AstTree *astTreeParseBracket(const ParserNode *parserNode, AstTreeToken token) { metadata->operand = astTreeParse(node_metadata->operand); + if (metadata->operand == NULL) { + free(metadata); + return NULL; + } + metadata->parameters.size = node_metadata->params->size; metadata->parameters.data = a404m_malloc(sizeof(*metadata->parameters.data) * metadata->parameters.size); @@ -3701,6 +3763,11 @@ AstTree *astTreeParseBracket(const ParserNode *parserNode, AstTreeToken token) { } metadata->parameters.data[i] = astTreeParse(node_param); + + if (metadata->parameters.data[i] == NULL) { + free(metadata); + return NULL; + } } return newAstTree(token, metadata, NULL, parserNode->str_begin, @@ -3714,16 +3781,19 @@ AstTree *astTreeParseArrayAccessOperator(const ParserNode *parserNode) { metadata->function = NULL; - metadata->parameters_size = node_metadata->params->size + 1; - metadata->parameters = - a404m_malloc(metadata->parameters_size * sizeof(*metadata->parameters)); + metadata->parameters.size = node_metadata->params->size + 1; + metadata->parameters.data = a404m_malloc(metadata->parameters.size * + sizeof(*metadata->parameters.data)); - metadata->parameters[0].value = astTreeParse(node_metadata->operand); - metadata->parameters[0].nameBegin = NULL; - metadata->parameters[0].nameEnd = NULL; + AstTree *value = astTreeParse(node_metadata->operand); + metadata->parameters.data[0].value = + newAstTree(AST_TREE_TOKEN_OPERATOR_ADDRESS, value, NULL, value->str_begin, + value->str_end); + metadata->parameters.data[0].nameBegin = NULL; + metadata->parameters.data[0].nameEnd = NULL; - if (metadata->parameters[0].value == NULL) { - free(metadata->parameters); + if (metadata->parameters.data[0].value == NULL) { + free(metadata->parameters.data); free(metadata); return NULL; } @@ -3735,10 +3805,10 @@ AstTree *astTreeParseArrayAccessOperator(const ParserNode *parserNode) { node_param = (ParserNodeSingleChildMetadata *)node_param->metadata; } - metadata->parameters[i + 1].value = astTreeParse(node_param); - metadata->parameters[i + 1].nameBegin = NULL; - metadata->parameters[i + 1].nameEnd = NULL; - if (metadata->parameters[i + 1].value == NULL) { + metadata->parameters.data[i + 1].value = astTreeParse(node_param); + metadata->parameters.data[i + 1].nameBegin = NULL; + metadata->parameters.data[i + 1].nameEnd = NULL; + if (metadata->parameters.data[i + 1].value == NULL) { return NULL; } } @@ -3750,7 +3820,8 @@ AstTree *astTreeParseArrayAccessOperator(const ParserNode *parserNode) { bool isFunction(AstTree *value) { return value->type->token == AST_TREE_TOKEN_TYPE_FUNCTION || value->type->token == AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER || - value->type->token == AST_TREE_TOKEN_TYPE_C_FUNCTION; + value->type->token == AST_TREE_TOKEN_TYPE_C_FUNCTION || + value->type->token == AST_TREE_TOKEN_TYPE_MACRO; } bool isShapeShifter(AstTreeFunction *function) { @@ -3819,6 +3890,7 @@ bool hasAnyTypeInside(AstTree *type) { case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: case AST_TREE_TOKEN_TYPE_BOOL: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_VALUE_NULL: case AST_TREE_TOKEN_VALUE_UNDEFINED: case AST_TREE_TOKEN_VALUE_VOID: @@ -3838,8 +3910,30 @@ bool hasAnyTypeInside(AstTree *type) { AstTreeBracket *metadata = type->metadata; return hasAnyTypeInside(metadata->operand); } + case AST_TREE_TOKEN_KEYWORD_STRUCT: { + AstTreeStruct *metadata = type->metadata; + for (size_t i = 0; i < metadata->variables.size; ++i) { + if (hasAnyTypeInside(metadata->variables.data[i]->type)) { + return true; + } + } + return false; + } + case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS: + case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ASSIGN: + case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ADDRESS: + case AST_TREE_TOKEN_FUNCTION_CALL: { + AstTreeFunctionCall *metadata = type->metadata; + for (size_t i = 0; i < metadata->parameters.size; ++i) { + if (hasAnyTypeInside(metadata->parameters.data[i].value)) { + return true; + } + } + return false; + } case AST_TREE_TOKEN_VARIABLE: - case AST_TREE_TOKEN_FUNCTION_CALL: + case AST_TREE_TOKEN_OPERATOR_ADDRESS: + case AST_TREE_TOKEN_OPERATOR_DEREFERENCE: return false; case AST_TREE_TOKEN_FUNCTION: case AST_TREE_TOKEN_KEYWORD_RETURN: @@ -3848,11 +3942,11 @@ bool hasAnyTypeInside(AstTree *type) { case AST_TREE_TOKEN_KEYWORD_IF: case AST_TREE_TOKEN_KEYWORD_WHILE: case AST_TREE_TOKEN_KEYWORD_COMPTIME: - case AST_TREE_TOKEN_KEYWORD_STRUCT: case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT: case AST_TREE_TOKEN_OPERATOR_ASSIGN: case AST_TREE_TOKEN_OPERATOR_PLUS: @@ -3868,15 +3962,10 @@ bool hasAnyTypeInside(AstTree *type) { case AST_TREE_TOKEN_OPERATOR_SMALLER: case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL: case AST_TREE_TOKEN_OPERATOR_SMALLER_OR_EQUAL: - case AST_TREE_TOKEN_OPERATOR_ADDRESS: - case AST_TREE_TOKEN_OPERATOR_DEREFERENCE: case AST_TREE_TOKEN_OPERATOR_ACCESS: case AST_TREE_TOKEN_OPERATOR_LOGICAL_NOT: case AST_TREE_TOKEN_OPERATOR_LOGICAL_AND: case AST_TREE_TOKEN_OPERATOR_LOGICAL_OR: - case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS: - case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ASSIGN: - case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ADDRESS: case AST_TREE_TOKEN_OPERATOR_BITWISE_NOT: case AST_TREE_TOKEN_OPERATOR_BITWISE_AND: case AST_TREE_TOKEN_OPERATOR_BITWISE_XOR: @@ -3947,6 +4036,7 @@ bool isConst(AstTree *tree) { case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_TYPE_BOOL: case AST_TREE_TOKEN_VALUE_NULL: case AST_TREE_TOKEN_VALUE_UNDEFINED: @@ -4010,8 +4100,8 @@ bool isConst(AstTree *tree) { return true; } - for (size_t i = 0; i < metadata->parameters_size; ++i) { - if (!isConst(metadata->parameters[i].value)) { + for (size_t i = 0; i < metadata->parameters.size; ++i) { + if (!isConst(metadata->parameters.data[i].value)) { return false; } } @@ -4020,6 +4110,7 @@ bool isConst(AstTree *tree) { case AST_TREE_TOKEN_FUNCTION: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT: { return true; @@ -4058,6 +4149,7 @@ bool isConst(AstTree *tree) { } printLog("Unknown token '%d'", tree->token); UNREACHABLE; + return NULL; } bool isLeftValue(AstTree *tree) { @@ -4116,7 +4208,9 @@ bool isLeftValue(AstTree *tree) { case AST_TREE_TOKEN_TYPE_U32: case AST_TREE_TOKEN_TYPE_I64: case AST_TREE_TOKEN_TYPE_U64: +#ifdef FLOAT_16_SUPPORT case AST_TREE_TOKEN_TYPE_F16: +#endif case AST_TREE_TOKEN_TYPE_F32: case AST_TREE_TOKEN_TYPE_F64: case AST_TREE_TOKEN_TYPE_F128: @@ -4125,6 +4219,7 @@ bool isLeftValue(AstTree *tree) { case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_TYPE_BOOL: case AST_TREE_TOKEN_VALUE_VOID: case AST_TREE_TOKEN_FUNCTION_CALL: @@ -4135,6 +4230,7 @@ bool isLeftValue(AstTree *tree) { case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_VALUE_INT: case AST_TREE_TOKEN_VALUE_FLOAT: case AST_TREE_TOKEN_VALUE_BOOL: @@ -4202,6 +4298,7 @@ AstTree *makeTypeOf(AstTree *value) { case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_TYPE_BOOL: case AST_TREE_TOKEN_OPERATOR_POINTER: case AST_TREE_TOKEN_KEYWORD_STRUCT: @@ -4354,6 +4451,7 @@ AstTree *makeTypeOf(AstTree *value) { case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_RAW_VALUE: case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED: case AST_TREE_TOKEN_NONE: @@ -4450,6 +4548,7 @@ bool typeIsEqualBack(const AstTree *type0, const AstTree *type1, case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_VALUE_INT: case AST_TREE_TOKEN_VALUE_FLOAT: case AST_TREE_TOKEN_VALUE_BOOL: @@ -4513,6 +4612,7 @@ bool typeIsEqualBack(const AstTree *type0, const AstTree *type1, case AST_TREE_TOKEN_TYPE_NAMESPACE: case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: + case AST_TREE_TOKEN_TYPE_MACRO: return type1->token == type0->token; case AST_TREE_TOKEN_TYPE_C_FUNCTION: { if (type1->token != type0->token) { @@ -4662,6 +4762,7 @@ AstTree *getValue(AstTree *tree, bool copy, AstTreeScope *scope) { case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_TYPE_BOOL: case AST_TREE_TOKEN_VALUE_NULL: case AST_TREE_TOKEN_VALUE_UNDEFINED: @@ -4731,6 +4832,7 @@ AstTree *getValue(AstTree *tree, bool copy, AstTreeScope *scope) { case AST_TREE_TOKEN_FUNCTION: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: { if (copy) { return copyAstTree(tree); @@ -4811,12 +4913,14 @@ bool isIntType(AstTree *type) { case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_TYPE_BOOL: case AST_TREE_TOKEN_VALUE_VOID: case AST_TREE_TOKEN_VALUE_NAMESPACE: case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_FUNCTION_CALL: case AST_TREE_TOKEN_VARIABLE: case AST_TREE_TOKEN_VARIABLE_DEFINE: @@ -4930,12 +5034,14 @@ bool isFloatType(AstTree *type) { case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_TYPE_BOOL: case AST_TREE_TOKEN_VALUE_VOID: case AST_TREE_TOKEN_VALUE_NAMESPACE: case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_FUNCTION_CALL: case AST_TREE_TOKEN_VARIABLE: case AST_TREE_TOKEN_VARIABLE_DEFINE: @@ -5015,6 +5121,7 @@ bool isEqual(AstTree *left, AstTree *right, AstTreeScope *scope) { case AST_TREE_TOKEN_VALUE_VOID: case AST_TREE_TOKEN_VALUE_NULL: case AST_TREE_TOKEN_VALUE_UNDEFINED: + case AST_TREE_TOKEN_TYPE_MACRO: return true; case AST_TREE_TOKEN_TYPE_C_FUNCTION: { NOT_IMPLEMENTED; @@ -5044,6 +5151,23 @@ bool isEqual(AstTree *left, AstTree *right, AstTreeScope *scope) { return memcmp(left_metadata, right_metadata, getSizeOfType(left->type)) == 0; } + case AST_TREE_TOKEN_TYPE_ARRAY: { + AstTreeBracket *left_metadata = left->metadata; + AstTreeBracket *right_metadata = right->metadata; + + if (left_metadata->parameters.size != right_metadata->parameters.size) { + return false; + } + + for (size_t i = 0; i < left_metadata->parameters.size; ++i) { + if (!isEqual(left_metadata->parameters.data[i], + right_metadata->parameters.data[i], scope)) { + return false; + } + } + + return isEqual(left_metadata->operand, right_metadata->operand, scope); + } case AST_TREE_TOKEN_FUNCTION: case AST_TREE_TOKEN_BUILTIN_CAST: case AST_TREE_TOKEN_BUILTIN_TYPE_OF: @@ -5082,12 +5206,12 @@ bool isEqual(AstTree *left, AstTree *right, AstTreeScope *scope) { case AST_TREE_TOKEN_KEYWORD_COMPTIME: case AST_TREE_TOKEN_KEYWORD_STRUCT: case AST_TREE_TOKEN_TYPE_FUNCTION: - case AST_TREE_TOKEN_TYPE_ARRAY: case AST_TREE_TOKEN_FUNCTION_CALL: case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_VALUE_FLOAT: case AST_TREE_TOKEN_VALUE_BOOL: case AST_TREE_TOKEN_VALUE_OBJECT: @@ -5200,7 +5324,8 @@ bool setAllTypesRoot(AstTreeRoot *root) { .data = NULL, .size = 0, }, - .variables = variables, + .variables = &variables, + .variables_size = 1, .root = root, .loops = NULL, .loops_size = 0, @@ -5346,6 +5471,7 @@ bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper, case AST_TREE_TOKEN_TYPE_NAMESPACE: case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_VALUE_VOID: return true; case AST_TREE_TOKEN_TYPE_C_FUNCTION: @@ -5515,6 +5641,7 @@ bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper, case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT: case AST_TREE_TOKEN_RAW_VALUE: case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED: @@ -5748,7 +5875,14 @@ bool setTypesValueObject(AstTree *tree, AstTreeSetTypesHelper helper) { bool setTypesFunction(AstTree *tree, AstTreeSetTypesHelper _helper) { AstTreeFunction *metadata = tree->metadata; - if (isShapeShifter(metadata)) { + if (metadata->isMacro) { + AstTreeMacro *new_metadata = a404m_malloc(sizeof(*new_metadata)); + new_metadata->function = metadata; + tree->metadata = new_metadata; + tree->token = AST_TREE_TOKEN_VALUE_MACRO; + tree->type = copyAstTree(&AST_TREE_MACRO_TYPE); + return true; + } else if (isShapeShifter(metadata)) { AstTreeShapeShifter *new_metadata = a404m_malloc(sizeof(*new_metadata)); new_metadata->function = metadata; new_metadata->generateds.size = 0; @@ -5760,91 +5894,7 @@ bool setTypesFunction(AstTree *tree, AstTreeSetTypesHelper _helper) { return true; } - // TODO: do something about macros - - AstTreeSetTypesHelper helper = { - .lookingType = NULL, - .dependencies = _helper.dependencies, - .variables.data = - a404m_malloc((_helper.variables.size + metadata->arguments.size + - metadata->scope.variables.size) * - sizeof(*helper.variables.data)), - .variables.size = _helper.variables.size, - .root = _helper.root, - .loops = NULL, - .loops_size = 0, - .scope = &metadata->scope, - .isInScope = true, - }; - - for (size_t i = 0; i < _helper.variables.size; ++i) { - helper.variables.data[i] = _helper.variables.data[i]; - } - - AstTreeVariable *deps[helper.dependencies.size]; - size_t deps_size = 0; - - for (size_t i = 0; i < metadata->arguments.size; ++i) { - AstTreeVariable *variable = metadata->arguments.data[i]; - if (!setTypesAstVariable(variable, helper)) { - return false; - } - helper.variables.data[helper.variables.size++] = variable; - } - - if (!setAllTypes(metadata->returnType, helper, NULL, NULL)) { - return false; - } - - tree->type = makeTypeOf(tree); - - for (size_t i = 0; i < helper.dependencies.size; ++i) { - AstTreeVariable *var = helper.dependencies.data[i]; - if (var->value == tree || var->initValue == tree) { - continue; - } - deps[deps_size] = helper.dependencies.data[i]; - deps_size += 1; - } - - helper.dependencies.data = deps; - helper.dependencies.size = deps_size; - - for (size_t i = 0; i < metadata->scope.variables.size; ++i) { - AstTreeVariable *variable = metadata->scope.variables.data[i]; - if (variable->isConst) { - if (!setTypesAstVariable(variable, helper)) { - return false; - } - helper.variables.data[helper.variables.size++] = variable; - } - } - - for (size_t i = 0; i < metadata->scope.expressions_size; ++i) { - AstTree *expr = metadata->scope.expressions[i]; - if (expr->token == AST_TREE_TOKEN_VARIABLE_DEFINE) { - AstTreeVariable *variable = expr->metadata; - if (!setTypesAstVariable(variable, helper)) { - return false; - } - size_t variables_capacity = - a404m_malloc_usable_size(helper.variables.data) / - sizeof(*helper.variables.data); - if (variables_capacity == helper.variables.size) { - variables_capacity += variables_capacity / 2 + 1; - helper.variables.data = - a404m_realloc(helper.variables.data, - variables_capacity * sizeof(*helper.variables.data)); - } - helper.variables.data[helper.variables.size++] = variable; - } - if (!setAllTypes(expr, helper, metadata, NULL)) { - return false; - } - } - - free(helper.variables.data); - return true; + return setTypesAstFunction(metadata, tree, _helper); } bool setTypesReturn(AstTree *tree, AstTreeSetTypesHelper _helper, @@ -5860,6 +5910,7 @@ bool setTypesReturn(AstTree *tree, AstTreeSetTypesHelper _helper, .lookingType = getValue(function->returnType, true, _helper.scope), .dependencies = _helper.dependencies, .variables = _helper.variables, + .variables_size = _helper.variables_size, .root = _helper.root, .loops = _helper.loops, .loops_size = _helper.loops_size, @@ -5946,6 +5997,7 @@ bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper _helper) { .lookingType = NULL, .dependencies = _helper.dependencies, .variables = _helper.variables, + .variables_size = _helper.variables_size, .root = _helper.root, .loops = _helper.loops, .loops_size = _helper.loops_size, @@ -5953,8 +6005,8 @@ bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper _helper) { .isInScope = false, }; - for (size_t i = 0; i < metadata->parameters_size; ++i) { - AstTreeFunctionCallParam param = metadata->parameters[i]; + for (size_t i = 0; i < metadata->parameters.size; ++i) { + AstTreeFunctionCallParam param = metadata->parameters.data[i]; if (!setAllTypes(param.value, helper, NULL, NULL)) { return false; } @@ -5971,10 +6023,10 @@ bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper _helper) { if (metadata->function->type->token == AST_TREE_TOKEN_TYPE_FUNCTION) { AstTreeTypeFunction *function = metadata->function->type->metadata; if (function == NULL || - function->arguments_size != metadata->parameters_size) { + function->arguments_size != metadata->parameters.size) { printError(tree->str_begin, tree->str_end, "Arguments doesn't match %ld != %ld", function->arguments_size, - metadata->parameters_size); + metadata->parameters.size); return NULL; } @@ -6008,12 +6060,42 @@ bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper _helper) { } tree->type = copyAstTree(function->returnType); + } else if (metadata->function->type->token == AST_TREE_TOKEN_TYPE_MACRO) { + metadata->function = getValue(metadata->function, false, helper.scope); + if (metadata->function->token != AST_TREE_TOKEN_VALUE_MACRO) { + UNREACHABLE; + } + AstTreeMacro *macro = metadata->function->metadata; + AstTreeFunction *function = + copyAstTreeFunction(macro->function, NULL, NULL, 0, true); + + if (!setTypesAstFunction(function, NULL, helper)) { + astTreeFunctionDestroy(*function); + free(function); + return false; + } + + AstTree *functionType = makeTypeOfFunction(function, NULL, NULL); + + if (!doesFunctionMatch(functionType->metadata, metadata, helper)) { + printError(tree->str_begin, tree->str_end, "Function call doesn't match"); + return NULL; + } + + const char *str_begin = metadata->function->str_begin; + const char *str_end = metadata->function->str_end; + astTreeDelete(metadata->function); + + metadata->function = newAstTree(AST_TREE_TOKEN_FUNCTION, function, + functionType, str_begin, str_end); + + tree->type = copyAstTree(function->returnType); } else { UNREACHABLE; } if (metadata->function->token == AST_TREE_TOKEN_BUILTIN_INSERT) { - char *code = u8ArrayToCString(metadata->parameters[0].value); + char *code = u8ArrayToCString(metadata->parameters.data[0].value); filePush("", code); LexerNodeArray lexerArray = lexer(code); if (lexerNodeArrayIsError(lexerArray)) { @@ -6151,6 +6233,7 @@ bool setTypesOperatorGeneral(AstTree *tree, AstTreeSetTypesHelper _helper, .lookingType = NULL, .dependencies = _helper.dependencies, .variables = _helper.variables, + .variables_size = _helper.variables_size, .root = _helper.root, .loops = _helper.loops, .loops_size = _helper.loops_size, @@ -6158,8 +6241,8 @@ bool setTypesOperatorGeneral(AstTree *tree, AstTreeSetTypesHelper _helper, .isInScope = false, }; - for (size_t i = 0; i < metadata->parameters_size; ++i) { - if (!setAllTypes(metadata->parameters[i].value, helper, NULL, NULL)) { + for (size_t i = 0; i < metadata->parameters.size; ++i) { + if (!setAllTypes(metadata->parameters.data[i].value, helper, NULL, NULL)) { return false; } } @@ -6180,6 +6263,36 @@ bool setTypesOperatorGeneral(AstTree *tree, AstTreeSetTypesHelper _helper, if (metadata->function->type->token == AST_TREE_TOKEN_TYPE_FUNCTION) { AstTreeTypeFunction *function = metadata->function->type->metadata; tree->type = copyAstTree(function->returnType); + } else if (metadata->function->type->token == AST_TREE_TOKEN_TYPE_MACRO) { + metadata->function = getValue(metadata->function, false, helper.scope); + if (metadata->function->token != AST_TREE_TOKEN_VALUE_MACRO) { + UNREACHABLE; + } + AstTreeMacro *macro = metadata->function->metadata; + AstTreeFunction *function = + copyAstTreeFunction(macro->function, NULL, NULL, 0, true); + + if (!setTypesAstFunction(function, NULL, helper)) { + astTreeFunctionDestroy(*function); + free(function); + return false; + } + + AstTree *functionType = makeTypeOfFunction(function, NULL, NULL); + + if (!doesFunctionMatch(functionType->metadata, metadata, helper)) { + printError(tree->str_begin, tree->str_end, "Function call doesn't match"); + return NULL; + } + + const char *str_begin = metadata->function->str_begin; + const char *str_end = metadata->function->str_end; + astTreeDelete(metadata->function); + + metadata->function = newAstTree(AST_TREE_TOKEN_FUNCTION, function, + functionType, str_begin, str_end); + + tree->type = copyAstTree(function->returnType); } else if (metadata->function->type->token == AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER) { AstTree *function = getShapeShifterElement(metadata, helper); @@ -6190,6 +6303,7 @@ bool setTypesOperatorGeneral(AstTree *tree, AstTreeSetTypesHelper _helper, AstTreeTypeFunction *functionType = metadata->function->type->metadata; tree->type = copyAstTree(functionType->returnType); } else { + printLog("%s", AST_TREE_TOKEN_STRINGS[metadata->function->type->token]); UNREACHABLE; } @@ -6245,6 +6359,23 @@ bool setTypesVariableDefine(AstTree *tree, AstTreeSetTypesHelper helper) { bool setTypesAstVariable(AstTreeVariable *variable, AstTreeSetTypesHelper _helper) { + for (size_t i = 0; i < _helper.variables[0].size; ++i) { // TODO: change this + if (variable == _helper.variables[0].data[i]) { + _helper = (AstTreeSetTypesHelper){ + .root = _helper.root, + .variables = _helper.variables, + .variables_size = 1, + .dependencies = _helper.dependencies, + .lookingType = _helper.lookingType, + .loops = _helper.loops, + .loops_size = _helper.loops_size, + .scope = _helper.scope, + .isInScope = false, + }; + break; + } + } + AstTreeVariable *deps[_helper.dependencies.size + 1]; for (size_t i = 0; i < _helper.dependencies.size; ++i) { @@ -6263,6 +6394,7 @@ bool setTypesAstVariable(AstTreeVariable *variable, .dependencies.data = deps, .dependencies.size = _helper.dependencies.size + 1, .variables = _helper.variables, + .variables_size = _helper.variables_size, .root = _helper.root, .loops = _helper.loops, .loops_size = _helper.loops_size, @@ -6390,6 +6522,7 @@ bool setTypesIf(AstTree *tree, AstTreeSetTypesHelper helper, if (!setAllTypes(metadata->ifBody, helper, function, NULL) || (metadata->elseBody != NULL && !setAllTypes(metadata->elseBody, helper, function, NULL))) { + return false; } if (metadata->elseBody != NULL && @@ -6420,6 +6553,7 @@ bool setTypesWhile(AstTree *tree, AstTreeSetTypesHelper _helper, .lookingType = NULL, .dependencies = _helper.dependencies, .variables = _helper.variables, + .variables_size = _helper.variables_size, .root = _helper.root, .loops = loops, .loops_size = loops_size, @@ -6459,13 +6593,22 @@ bool setTypesScope(AstTree *tree, AstTreeSetTypesHelper _helper, AstTreeFunction *function) { AstTreeScope *metadata = tree->metadata; + AstTreeVariables variables[_helper.variables_size + 1]; + + for (size_t i = 0; i < _helper.variables_size; ++i) { + variables[i] = _helper.variables[i]; + } + + variables[_helper.variables_size].data = + a404m_malloc(metadata->variables.size * + sizeof(*variables[_helper.variables_size].data)); + variables[_helper.variables_size].size = 0; + AstTreeSetTypesHelper helper = { .lookingType = NULL, .dependencies = _helper.dependencies, - .variables.data = - a404m_malloc((_helper.variables.size + metadata->variables.size) * - sizeof(*helper.variables.data)), - .variables.size = _helper.variables.size, + .variables = variables, + .variables_size = _helper.variables_size + 1, .root = _helper.root, .loops = _helper.loops, .loops_size = _helper.loops_size, @@ -6473,17 +6616,14 @@ bool setTypesScope(AstTree *tree, AstTreeSetTypesHelper _helper, .isInScope = true, }; - for (size_t i = 0; i < _helper.variables.size; ++i) { - helper.variables.data[i] = _helper.variables.data[i]; - } - for (size_t i = 0; i < metadata->variables.size; ++i) { AstTreeVariable *variable = metadata->variables.data[i]; if (variable->isConst) { if (!setTypesAstVariable(variable, helper)) { return false; } - helper.variables.data[helper.variables.size++] = variable; + helper.variables[helper.variables_size - 1] + .data[helper.variables[helper.variables_size - 1].size++] = variable; } } @@ -6495,15 +6635,19 @@ bool setTypesScope(AstTree *tree, AstTreeSetTypesHelper _helper, return false; } size_t variables_capacity = - a404m_malloc_usable_size(helper.variables.data) / - sizeof(*helper.variables.data); - if (variables_capacity == helper.variables.size) { + a404m_malloc_usable_size( + helper.variables[helper.variables_size - 1].data) / + sizeof(*helper.variables[helper.variables_size - 1].data); + if (variables_capacity == + helper.variables[helper.variables_size - 1].size) { variables_capacity += variables_capacity / 2 + 1; - helper.variables.data = - a404m_realloc(helper.variables.data, - variables_capacity * sizeof(*helper.variables.data)); + helper.variables[helper.variables_size - 1].data = a404m_realloc( + helper.variables[helper.variables_size - 1].data, + variables_capacity * + sizeof(*helper.variables[helper.variables_size - 1].data)); } - helper.variables.data[helper.variables.size++] = variable; + helper.variables[helper.variables_size - 1] + .data[helper.variables[helper.variables_size - 1].size++] = variable; } if (!setAllTypes(expr, helper, function, NULL)) { return false; @@ -6517,7 +6661,7 @@ bool setTypesScope(AstTree *tree, AstTreeSetTypesHelper _helper, metadata->expressions[metadata->expressions_size - 1]->type); } - free(helper.variables.data); + free(helper.variables[helper.variables_size - 1].data); return true; } @@ -6607,7 +6751,8 @@ bool setTypesOperatorAccess(AstTree *tree, AstTreeSetTypesHelper helper) { AstTreeSetTypesHelper newHelper = { .root = helper.root->imports[namespace->importedIndex].root, .variables = - helper.root->imports[namespace->importedIndex].root->variables, + &helper.root->imports[namespace->importedIndex].root->variables, + .variables_size = 1, .dependencies = helper.dependencies, .lookingType = helper.lookingType, .loops = helper.loops, @@ -6645,7 +6790,7 @@ bool setTypesOperatorAccess(AstTree *tree, AstTreeSetTypesHelper helper) { bool setTypesBuiltinCast(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall) { (void)helper; - if (functionCall->parameters_size == 2) { + if (functionCall->parameters.size == 2) { AstTree *from = NULL; AstTree *to = NULL; @@ -6656,8 +6801,8 @@ bool setTypesBuiltinCast(AstTree *tree, AstTreeSetTypesHelper helper, static const size_t TO_STR_SIZE = sizeof(TO_STR) / sizeof(*TO_STR) - sizeof(*TO_STR); - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; const size_t param_name_size = param.nameEnd - param.nameBegin; if (param_name_size == 0) { @@ -6727,15 +6872,15 @@ bool setTypesBuiltinCast(AstTree *tree, AstTreeSetTypesHelper helper, bool setTypesBuiltinTypeOf(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall) { (void)helper; - if (functionCall->parameters_size == 1) { + if (functionCall->parameters.size == 1) { AstTree *variable = NULL; static const char VARIABLE_STR[] = "variable"; static const size_t VARIABLE_STR_SIZE = sizeof(VARIABLE_STR) / sizeof(*VARIABLE_STR) - sizeof(*VARIABLE_STR); - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; const size_t param_name_size = param.nameEnd - param.nameBegin; if (param_name_size == 0) { @@ -6790,15 +6935,15 @@ bool setTypesBuiltinTypeOf(AstTree *tree, AstTreeSetTypesHelper helper, bool setTypesBuiltinSizeOf(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall) { (void)helper; - if (functionCall->parameters_size == 1) { + if (functionCall->parameters.size == 1) { AstTree *type = NULL; static const char TYPE_STR[] = "type"; static const size_t TYPE_STR_SIZE = sizeof(TYPE_STR) / sizeof(*TYPE_STR) - sizeof(*TYPE_STR); - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; const size_t param_name_size = param.nameEnd - param.nameBegin; if (param_name_size == 0) { @@ -6857,15 +7002,15 @@ bool setTypesBuiltinSizeOf(AstTree *tree, AstTreeSetTypesHelper helper, bool setTypesBuiltinImport(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall) { (void)helper; - if (functionCall->parameters_size == 1) { + if (functionCall->parameters.size == 1) { AstTree *file = NULL; static const char PATH_STR[] = "path"; static const size_t PATH_STR_SIZE = sizeof(PATH_STR) / sizeof(*PATH_STR) - sizeof(*PATH_STR); - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; const size_t param_name_size = param.nameEnd - param.nameBegin; if (param_name_size == 0) { @@ -6935,7 +7080,7 @@ bool setTypesBuiltinIsComptime(AstTree *tree, AstTreeSetTypesHelper helper) { bool setTypesBuiltinStackAlloc(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall) { (void)helper; - if (functionCall->parameters_size == 2) { + if (functionCall->parameters.size == 2) { AstTree *count = NULL; AstTree *type = NULL; @@ -6946,8 +7091,8 @@ bool setTypesBuiltinStackAlloc(AstTree *tree, AstTreeSetTypesHelper helper, static const size_t COUNT_STR_SIZE = sizeof(COUNT_STR) / sizeof(*COUNT_STR) - sizeof(*COUNT_STR); - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; const size_t param_name_size = param.nameEnd - param.nameBegin; if (param_name_size == 0) { @@ -7036,14 +7181,14 @@ bool setTypesBuiltinHeapAlloc(AstTree *tree, AstTreeSetTypesHelper helper, bool setTypesBuiltinUnary(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall) { (void)helper; - if (functionCall->parameters_size != 1) { + if (functionCall->parameters.size != 1) { printError(tree->str_begin, tree->str_end, "Too many or too few arguments"); return false; } - const char *str = functionCall->parameters[0].nameBegin; - const size_t str_size = functionCall->parameters[0].nameEnd - - functionCall->parameters[0].nameBegin; + const char *str = functionCall->parameters.data[0].nameBegin; + const size_t str_size = functionCall->parameters.data[0].nameEnd - + functionCall->parameters.data[0].nameBegin; static char VALUE_STR[] = "value"; static size_t VALUE_STR_SIZE = @@ -7051,12 +7196,12 @@ bool setTypesBuiltinUnary(AstTree *tree, AstTreeSetTypesHelper helper, if (str_size != 0 && (str_size != VALUE_STR_SIZE || !strnEquals(str, VALUE_STR, VALUE_STR_SIZE))) { - printError(functionCall->parameters[0].nameBegin, - functionCall->parameters[0].nameEnd, "Unknown parameter"); + printError(functionCall->parameters.data[0].nameBegin, + functionCall->parameters.data[0].nameEnd, "Unknown parameter"); return false; } - AstTree *type = functionCall->parameters[0].value->type; + AstTree *type = functionCall->parameters.data[0].value->type; switch (type->token) { case AST_TREE_TOKEN_TYPE_I8: case AST_TREE_TOKEN_TYPE_U8: @@ -7066,7 +7211,9 @@ bool setTypesBuiltinUnary(AstTree *tree, AstTreeSetTypesHelper helper, case AST_TREE_TOKEN_TYPE_U32: case AST_TREE_TOKEN_TYPE_I64: case AST_TREE_TOKEN_TYPE_U64: +#ifdef FLOAT_16_SUPPORT case AST_TREE_TOKEN_TYPE_F16: +#endif case AST_TREE_TOKEN_TYPE_F32: case AST_TREE_TOKEN_TYPE_F64: case AST_TREE_TOKEN_TYPE_F128: @@ -7075,6 +7222,7 @@ bool setTypesBuiltinUnary(AstTree *tree, AstTreeSetTypesHelper helper, case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_BUILTIN_CAST: case AST_TREE_TOKEN_BUILTIN_TYPE_OF: case AST_TREE_TOKEN_BUILTIN_SIZE_OF: @@ -7122,6 +7270,7 @@ bool setTypesBuiltinUnary(AstTree *tree, AstTreeSetTypesHelper helper, case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: case AST_TREE_TOKEN_TYPE_BOOL: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_VALUE_VOID: case AST_TREE_TOKEN_VALUE_NAMESPACE: case AST_TREE_TOKEN_FUNCTION_CALL: @@ -7169,8 +7318,8 @@ bool setTypesBuiltinUnary(AstTree *tree, AstTreeSetTypesHelper helper, case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT: case AST_TREE_TOKEN_NONE: } - printError(functionCall->parameters[0].nameBegin, - functionCall->parameters[0].nameEnd, "Bad argument"); + printError(functionCall->parameters.data[0].nameBegin, + functionCall->parameters.data[0].nameEnd, "Bad argument"); return false; AFTER_SWITCH: @@ -7199,8 +7348,7 @@ AFTER_SWITCH: bool setTypesBuiltinBinaryAlsoPointer(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall) { - (void)helper; - if (functionCall->parameters_size != 2) { + if (functionCall->parameters.size != 2) { printError(tree->str_begin, tree->str_end, "Too many or too few arguments"); return false; } @@ -7214,8 +7362,8 @@ bool setTypesBuiltinBinaryAlsoPointer(AstTree *tree, static const size_t RIGHT_STR_SIZE = sizeof(RIGHT_STR) / sizeof(*RIGHT_STR) - sizeof(*RIGHT_STR); - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; const size_t param_name_size = param.nameEnd - param.nameBegin; if (param_name_size == 0) { @@ -7289,8 +7437,7 @@ bool setTypesBuiltinBinaryAlsoPointer(AstTree *tree, bool setTypesBuiltinBinary(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall) { - (void)helper; - if (functionCall->parameters_size != 2) { + if (functionCall->parameters.size != 2) { printError(tree->str_begin, tree->str_end, "Too many or too few arguments"); return false; } @@ -7304,8 +7451,8 @@ bool setTypesBuiltinBinary(AstTree *tree, AstTreeSetTypesHelper helper, static const size_t RIGHT_STR_SIZE = sizeof(RIGHT_STR) / sizeof(*RIGHT_STR) - sizeof(*RIGHT_STR); - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; const size_t param_name_size = param.nameEnd - param.nameBegin; if (param_name_size == 0) { @@ -7374,7 +7521,7 @@ bool setTypesBuiltinBinaryWithRet(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall, AstTree *retType) { (void)helper; - if (functionCall->parameters_size != 2) { + if (functionCall->parameters.size != 2) { printError(tree->str_begin, tree->str_end, "Too many or too few arguments"); return false; } @@ -7388,8 +7535,8 @@ bool setTypesBuiltinBinaryWithRet(AstTree *tree, AstTreeSetTypesHelper helper, static const size_t RIGHT_STR_SIZE = sizeof(RIGHT_STR) / sizeof(*RIGHT_STR) - sizeof(*RIGHT_STR); - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; const size_t param_name_size = param.nameEnd - param.nameBegin; if (param_name_size == 0) { @@ -7453,15 +7600,14 @@ bool setTypesBuiltinBinaryWithRet(AstTree *tree, AstTreeSetTypesHelper helper, bool setTypesBuiltinPutc(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall) { - (void)helper; - if (functionCall->parameters_size != 1) { + if (functionCall->parameters.size != 1) { printError(tree->str_begin, tree->str_end, "Too many or too few arguments"); return false; } - const char *str = functionCall->parameters[0].nameBegin; - const size_t str_size = functionCall->parameters[0].nameEnd - - functionCall->parameters[0].nameBegin; + const char *str = functionCall->parameters.data[0].nameBegin; + const size_t str_size = functionCall->parameters.data[0].nameEnd - + functionCall->parameters.data[0].nameBegin; static char VALUE_STR[] = "value"; static size_t VALUE_STR_SIZE = @@ -7469,15 +7615,15 @@ bool setTypesBuiltinPutc(AstTree *tree, AstTreeSetTypesHelper helper, if (str_size != 0 && (str_size != VALUE_STR_SIZE || !strnEquals(str, VALUE_STR, VALUE_STR_SIZE))) { - printError(functionCall->parameters[0].nameBegin, - functionCall->parameters[0].nameEnd, "Unknown parameter"); + printError(functionCall->parameters.data[0].nameBegin, + functionCall->parameters.data[0].nameEnd, "Unknown parameter"); return false; } - if (!typeIsEqual(functionCall->parameters[0].value->type, &AST_TREE_U8_TYPE, - helper.scope)) { - printError(functionCall->parameters[0].nameBegin, - functionCall->parameters[0].nameEnd, + if (!typeIsEqual(functionCall->parameters.data[0].value->type, + &AST_TREE_U8_TYPE, helper.scope)) { + printError(functionCall->parameters.data[0].nameBegin, + functionCall->parameters.data[0].nameEnd, "Bad argument (must have a type of u8)"); return false; } @@ -7506,16 +7652,15 @@ bool setTypesBuiltinPutc(AstTree *tree, AstTreeSetTypesHelper helper, bool setTypesBuiltinCLibrary(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall) { - (void)helper; - if (functionCall->parameters_size == 1) { + if (functionCall->parameters.size == 1) { AstTree *path = NULL; static const char PATH_STR[] = "path"; static const size_t PATH_STR_SIZE = sizeof(PATH_STR) / sizeof(*PATH_STR) - sizeof(*PATH_STR); - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; const size_t param_name_size = param.nameEnd - param.nameBegin; if (param_name_size == 0) { @@ -7576,8 +7721,7 @@ bool setTypesBuiltinCLibrary(AstTree *tree, AstTreeSetTypesHelper helper, bool setTypesBuiltinCFunction(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall) { - (void)helper; - if (functionCall->parameters_size != 3) { + if (functionCall->parameters.size != 3) { printError(tree->str_begin, tree->str_end, "Too many or too few arguments"); return false; } @@ -7595,8 +7739,8 @@ bool setTypesBuiltinCFunction(AstTree *tree, AstTreeSetTypesHelper helper, static const size_t FUNC_TYPE_STR_SIZE = sizeof(FUNC_TYPE_STR) / sizeof(*FUNC_TYPE_STR) - sizeof(*FUNC_TYPE_STR); - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; const size_t param_name_size = param.nameEnd - param.nameBegin; if (param_name_size == 0) { @@ -7697,15 +7841,14 @@ bool setTypesBuiltinCFunction(AstTree *tree, AstTreeSetTypesHelper helper, bool setTypesBuiltinInsert(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall) { - (void)helper; - if (functionCall->parameters_size != 1) { + if (functionCall->parameters.size != 1) { printError(tree->str_begin, tree->str_end, "Too many or too few arguments"); return false; } - const char *str = functionCall->parameters[0].nameBegin; - const size_t str_size = functionCall->parameters[0].nameEnd - - functionCall->parameters[0].nameBegin; + const char *str = functionCall->parameters.data[0].nameBegin; + const size_t str_size = functionCall->parameters.data[0].nameEnd - + functionCall->parameters.data[0].nameBegin; static char CODE_STR[] = "code"; static size_t CODE_STR_SIZE = @@ -7713,22 +7856,22 @@ bool setTypesBuiltinInsert(AstTree *tree, AstTreeSetTypesHelper helper, if (str_size != 0 && (str_size != CODE_STR_SIZE || !strnEquals(str, CODE_STR, CODE_STR_SIZE))) { - printError(functionCall->parameters[0].nameBegin, - functionCall->parameters[0].nameEnd, "Unknown parameter"); + printError(functionCall->parameters.data[0].nameBegin, + functionCall->parameters.data[0].nameEnd, "Unknown parameter"); return false; } - AstTree *type = functionCall->parameters[0].value->type; + AstTree *type = functionCall->parameters.data[0].value->type; AstTree *stringType = makeStringType(); if (typeIsEqual(type->type, stringType, helper.scope)) { astTreeDelete(stringType); - printError(functionCall->parameters[0].nameBegin, - functionCall->parameters[0].nameEnd, + printError(functionCall->parameters.data[0].nameBegin, + functionCall->parameters.data[0].nameEnd, "Type mismatch it must be `code`"); return false; - } else if (!isConst(functionCall->parameters[0].value)) { - printError(functionCall->parameters[0].nameBegin, - functionCall->parameters[0].nameEnd, "Must be const"); + } else if (!isConst(functionCall->parameters.data[0].value)) { + printError(functionCall->parameters.data[0].nameBegin, + functionCall->parameters.data[0].nameEnd, "Must be const"); return false; } astTreeDelete(stringType); @@ -7780,6 +7923,7 @@ bool setTypesTypeArray(AstTree *tree, AstTreeSetTypesHelper helper) { .lookingType = &AST_TREE_U64_TYPE, .dependencies = helper.dependencies, .variables = helper.variables, + .variables_size = helper.variables_size, .root = helper.root, .loops = helper.loops, .loops_size = helper.loops_size, @@ -7820,6 +7964,7 @@ bool setTypesAstInfix(AstTreePureInfix *infix, AstTreeSetTypesHelper _helper) { .lookingType = NULL, .dependencies = _helper.dependencies, .variables = _helper.variables, + .variables_size = _helper.variables_size, .root = _helper.root, .loops = _helper.loops, .loops_size = _helper.loops_size, @@ -7836,61 +7981,70 @@ bool setTypesAstInfix(AstTreePureInfix *infix, AstTreeSetTypesHelper _helper) { return setAllTypes(infix->right, helper, NULL, NULL); } -bool setTypesAstFunction(AstTreeFunction *metadata, +bool setTypesAstFunction(AstTreeFunction *metadata, AstTree *tree, AstTreeSetTypesHelper _helper) { + AstTreeVariables variables[_helper.variables_size + 1]; + + for (size_t i = 0; i < _helper.variables_size; ++i) { + variables[i] = _helper.variables[i]; + } + + variables[_helper.variables_size].data = + a404m_malloc((metadata->arguments.size + metadata->scope.variables.size) * + sizeof(*variables[_helper.variables_size].data)); + variables[_helper.variables_size].size = 0; + AstTreeSetTypesHelper helper = { .lookingType = NULL, .dependencies = _helper.dependencies, - .variables.data = - a404m_malloc((_helper.variables.size + metadata->arguments.size + - metadata->scope.variables.size) * - sizeof(*_helper.variables.data)), - .variables.size = _helper.variables.size, + .variables = variables, + .variables_size = _helper.variables_size + 1, .root = _helper.root, - .loops = _helper.loops, - .loops_size = _helper.loops_size, + .loops = NULL, + .loops_size = 0, .scope = &metadata->scope, .isInScope = true, }; - for (size_t i = 0; i < _helper.variables.size; ++i) { - helper.variables.data[i] = _helper.variables.data[i]; - } - - AstTreeVariable *deps[helper.dependencies.size]; - size_t deps_size = 0; - for (size_t i = 0; i < metadata->arguments.size; ++i) { AstTreeVariable *variable = metadata->arguments.data[i]; if (!setTypesAstVariable(variable, helper)) { return false; } - helper.variables.data[helper.variables.size++] = variable; + helper.variables[helper.variables_size - 1] + .data[helper.variables[helper.variables_size - 1].size++] = variable; } if (!setAllTypes(metadata->returnType, helper, NULL, NULL)) { return false; } + metadata->returnType = getValue(metadata->returnType, false, helper.scope); - if (isConst(metadata->returnType)) { - metadata->returnType = getValue(metadata->returnType, false, helper.scope); - } + AstTreeVariable *deps[helper.dependencies.size]; + size_t deps_size = 0; + if (tree != NULL) { + tree->type = makeTypeOf(tree); - for (size_t i = 0; i < helper.dependencies.size; ++i) { - deps[deps_size] = helper.dependencies.data[i]; - deps_size += 1; + for (size_t i = 0; i < helper.dependencies.size; ++i) { + AstTreeVariable *var = helper.dependencies.data[i]; + if (var->value == tree || var->initValue == tree) { + continue; + } + deps[deps_size] = helper.dependencies.data[i]; + deps_size += 1; + } + helper.dependencies.data = deps; + helper.dependencies.size = deps_size; } - helper.dependencies.data = deps; - helper.dependencies.size = deps_size; - for (size_t i = 0; i < metadata->scope.variables.size; ++i) { AstTreeVariable *variable = metadata->scope.variables.data[i]; if (variable->isConst) { if (!setTypesAstVariable(variable, helper)) { return false; } - helper.variables.data[helper.variables.size++] = variable; + helper.variables[helper.variables_size - 1] + .data[helper.variables[helper.variables_size - 1].size++] = variable; } } @@ -7902,22 +8056,26 @@ bool setTypesAstFunction(AstTreeFunction *metadata, return false; } size_t variables_capacity = - a404m_malloc_usable_size(helper.variables.data) / - sizeof(*helper.variables.data); - if (variables_capacity == helper.variables.size) { + a404m_malloc_usable_size( + helper.variables[helper.variables_size - 1].data) / + sizeof(*helper.variables[helper.variables_size - 1].data); + if (variables_capacity == + helper.variables[helper.variables_size - 1].size) { variables_capacity += variables_capacity / 2 + 1; - helper.variables.data = - a404m_realloc(helper.variables.data, - variables_capacity * sizeof(*helper.variables.data)); + helper.variables[helper.variables_size - 1].data = a404m_realloc( + helper.variables[helper.variables_size - 1].data, + variables_capacity * + sizeof(*helper.variables[helper.variables_size - 1].data)); } - helper.variables.data[helper.variables.size++] = variable; + helper.variables[helper.variables_size - 1] + .data[helper.variables[helper.variables_size - 1].size++] = variable; } if (!setAllTypes(expr, helper, metadata, NULL)) { return false; } } - free(helper.variables.data); + free(helper.variables[helper.variables_size - 1].data); return true; } @@ -7937,93 +8095,140 @@ AstTreeVariable *setTypesFindVariable(const char *name_begin, const size_t str_size = name_end - name_begin; if (functionCall == NULL) { - for (size_t i = helper.variables.size - 1; i != -1ULL; --i) { - AstTreeVariable *var = helper.variables.data[i]; + for (size_t i = helper.variables_size - 1; i != -1ULL; --i) { + AstTreeVariables variables = helper.variables[i]; + for (size_t j = variables.size - 1; j != -1ULL; --j) { + AstTreeVariable *var = variables.data[j]; - const char *var_str = var->name_begin; - const size_t var_str_size = var->name_end - var->name_begin; + const char *var_str = var->name_begin; + const size_t var_str_size = var->name_end - var->name_begin; - if (var_str_size != str_size || !strnEquals(var_str, str, str_size)) { - continue; - } - - if (!setTypesAstVariable(var, helper)) { - return NULL; - } - - variable.var = var; - variable.op = 0; - break; - } - } else { - for (size_t i = helper.variables.size - 1; i != -1ULL; --i) { - AstTreeVariable *var = helper.variables.data[i]; - - const char *var_str = var->name_begin; - const size_t var_str_size = var->name_end - var->name_begin; - - if (var_str_size != str_size || !strnEquals(var_str, str, str_size)) { - continue; - } - - if (!setTypesAstVariable(var, helper)) { - return NULL; - } - - if (var->type->token == AST_TREE_TOKEN_TYPE_FUNCTION) { - AstTreeTypeFunction *function = var->type->metadata; - - if (!doesFunctionMatch(function, functionCall, helper)) { + if (var_str_size != str_size || !strnEquals(var_str, str, str_size)) { continue; } - if (variable.var != NULL && variable.op == 0) { - printError(name_begin, name_end, "Multiple candidates found for %.*s", - (int)(name_end - name_begin), name_begin); + if (!setTypesAstVariable(var, helper)) { return NULL; } + variable.var = var; variable.op = 0; - } else if (var->type->token == AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER) { - if (variable.op < 1) { - continue; - } - AstTreeShapeShifter *shapeShifter = var->value->metadata; + goto END; + break; + } + } + } else { + for (size_t i = helper.variables_size - 1; i != -1ULL; --i) { + AstTreeVariables variables = helper.variables[i]; + for (size_t j = variables.size - 1; j != -1ULL; --j) { + AstTreeVariable *var = variables.data[j]; + + const char *var_str = var->name_begin; + const size_t var_str_size = var->name_end - var->name_begin; - if (!doesShapeShifterMatch(shapeShifter, functionCall, helper)) { + if (var_str_size != str_size || !strnEquals(var_str, str, str_size)) { continue; } - if (variable.var != NULL) { - printError(name_begin, name_end, "Multiple candidates found for %.*s", - (int)(name_end - name_begin), name_begin); + if (!setTypesAstVariable(var, helper)) { return NULL; } - variable.var = var; - variable.op = 1; - } else if (var->type->token == AST_TREE_TOKEN_TYPE_C_FUNCTION) { - AstTreeCFunctionType *cFunction = var->type->metadata; - AstTreeTypeFunction *function = cFunction->funcType->metadata; - if (!doesFunctionMatch(function, functionCall, helper)) { - continue; - } + if (var->type->token == AST_TREE_TOKEN_TYPE_FUNCTION) { + AstTreeTypeFunction *function = var->type->metadata; - if (variable.var != NULL && variable.op == 0) { - printError(name_begin, name_end, "Multiple candidates found for %.*s", - (int)(name_end - name_begin), name_begin); - return NULL; + if (!doesFunctionMatch(function, functionCall, helper)) { + continue; + } + + if (variable.var != NULL && variable.op == 0) { + printError(name_begin, name_end, + "Multiple candidates found for %.*s", + (int)(name_end - name_begin), name_begin); + return NULL; + } + variable.var = var; + variable.op = 0; + } else if (var->type->token == AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER) { + if (variable.op < 1) { + continue; + } + AstTreeShapeShifter *shapeShifter = var->value->metadata; + + if (!doesShapeShifterMatch(shapeShifter, functionCall, helper)) { + continue; + } + + if (variable.var != NULL) { + printError(name_begin, name_end, + "Multiple candidates found for %.*s", + (int)(name_end - name_begin), name_begin); + return NULL; + } + variable.var = var; + variable.op = 1; + } else if (var->type->token == AST_TREE_TOKEN_TYPE_C_FUNCTION) { + AstTreeCFunctionType *cFunction = var->type->metadata; + AstTreeTypeFunction *function = cFunction->funcType->metadata; + + if (!doesFunctionMatch(function, functionCall, helper)) { + continue; + } + + if (variable.var != NULL && variable.op == 0) { + printError(name_begin, name_end, + "Multiple candidates found for %.*s", + (int)(name_end - name_begin), name_begin); + return NULL; + } + variable.var = var; + variable.op = 0; + } else if (var->type->token == AST_TREE_TOKEN_TYPE_MACRO) { + AstTreeMacro *macro = var->value->metadata; + AstTreeFunction *function = + copyAstTreeFunction(macro->function, NULL, NULL, 0, true); + + if (!setTypesAstFunction(function, NULL, helper)) { + astTreeFunctionDestroy(*function); + free(function); + return NULL; + } + + AstTree *functionType = makeTypeOfFunction(function, NULL, NULL); + + bool match = + doesFunctionMatch(functionType->metadata, functionCall, helper); + + astTreeDelete(functionType); + astTreeFunctionDestroy(*function); + free(function); + + if (!match) { + continue; + } + + if (variable.var != NULL && variable.op == 0) { + printError(name_begin, name_end, + "Multiple candidates found for %.*s", + (int)(name_end - name_begin), name_begin); + return NULL; + } + variable.var = var; + variable.op = 0; } - variable.var = var; - variable.op = 0; } } } if (variable.var == NULL) { + printLog("%ld", helper.variables_size); + for (size_t i = 0; i < helper.variables_size; ++i) { + printLog("is %ld", helper.variables[i].size); + } printError(name_begin, name_end, "No candidates found for %.*s", (int)(name_end - name_begin), name_begin); return NULL; } +END: return variable.var; } @@ -8046,8 +8251,6 @@ AstTree *getShapeShifterElement(AstTreeFunctionCall *metadata, AstTreeFunction *newFunction = copyAstTreeFunction(shapeShifter->function, NULL, NULL, 0, true); - newFunction->isMacro = shapeShifter->function->isMacro; - AstTreeFunctionCallParam initedArguments[newFunction->arguments.size]; size_t initedArguments_size = newFunction->arguments.size; @@ -8055,8 +8258,8 @@ AstTree *getShapeShifterElement(AstTreeFunctionCall *metadata, initedArguments[i].value = NULL; } - for (size_t i = 0; i < metadata->parameters_size; ++i) { - AstTreeFunctionCallParam param = metadata->parameters[i]; + for (size_t i = 0; i < metadata->parameters.size; ++i) { + AstTreeFunctionCallParam param = metadata->parameters.data[i]; if (param.nameBegin != param.nameEnd) { const size_t param_name_size = param.nameEnd - param.nameBegin; for (size_t j = 0; j < newFunction->arguments.size; ++j) { @@ -8081,8 +8284,8 @@ AstTree *getShapeShifterElement(AstTreeFunctionCall *metadata, END_OF_NAMED_FOR1: } - for (size_t i = 0; i < metadata->parameters_size; ++i) { - AstTreeFunctionCallParam param = metadata->parameters[i]; + for (size_t i = 0; i < metadata->parameters.size; ++i) { + AstTreeFunctionCallParam param = metadata->parameters.data[i]; if (param.nameBegin == param.nameEnd) { for (size_t j = 0; j < newFunction->arguments.size; ++j) { AstTreeVariable *arg = newFunction->arguments.data[j]; @@ -8114,20 +8317,21 @@ AstTree *getShapeShifterElement(AstTreeFunctionCall *metadata, } for (size_t i = 0; i < initedArguments_size; ++i) { - metadata->parameters[i] = initedArguments[i]; + metadata->parameters.data[i] = initedArguments[i]; } bool found = false; size_t element_index; for (size_t i = 0; i < shapeShifter->generateds.size; ++i) { - AstTreeFunctionCall *call = shapeShifter->generateds.calls[i]; - if (metadata->parameters_size != call->parameters_size) + AstTreeFunctionCallParams call = shapeShifter->generateds.calls[i]; + if (metadata->parameters.size != call.size) { continue; + } - for (size_t i = 0; i < metadata->parameters_size; ++i) { - AstTreeFunctionCallParam p0 = metadata->parameters[i]; - AstTreeFunctionCallParam p1 = call->parameters[i]; + for (size_t i = 0; i < metadata->parameters.size; ++i) { + AstTreeFunctionCallParam p0 = metadata->parameters.data[i]; + AstTreeFunctionCallParam p1 = call.data[i]; if (!typeIsEqual(p0.value->type, p1.value->type, helper.scope)) { goto SEARCH_LOOP_CONTINUE; } @@ -8154,21 +8358,19 @@ AstTree *getShapeShifterElement(AstTreeFunctionCall *metadata, } if (!found) { - AstTreeVariable - *variables[helper.variables.size + newFunction->arguments.size]; + AstTreeVariables variables[helper.variables_size + 1]; - for (size_t i = 0; i < helper.variables.size; ++i) { - variables[i] = helper.variables.data[i]; + for (size_t i = 0; i < helper.variables_size; ++i) { + variables[i] = helper.variables[i]; } - for (size_t i = 0; i < newFunction->arguments.size; ++i) { - variables[helper.variables.size + i] = newFunction->arguments.data[i]; - } + variables[helper.variables_size].data = newFunction->arguments.data; + variables[helper.variables_size].size = 0; AstTreeSetTypesHelper newHelper = { .root = helper.root, - .variables.data = variables, - .variables.size = helper.variables.size, + .variables = variables, + .variables_size = helper.variables_size + 1, .lookingType = NULL, .dependencies = helper.dependencies, .loops = helper.loops, @@ -8182,16 +8384,16 @@ AstTree *getShapeShifterElement(AstTreeFunctionCall *metadata, if (!setTypesAstVariable(var, newHelper)) { return NULL; } - newHelper.variables.size += 1; + newHelper.variables[newHelper.variables_size - 1].size += 1; } - if (!setTypesAstFunction(newFunction, helper)) { + if (!setTypesAstFunction(newFunction, NULL, helper)) { return NULL; } size_t generateds_size = - a404m_malloc_usable_size(shapeShifter->generateds.functions) / - sizeof(*shapeShifter->generateds.functions); + a404m_malloc_usable_size(shapeShifter->generateds.calls) / + sizeof(*shapeShifter->generateds.calls); if (generateds_size == shapeShifter->generateds.size) { generateds_size += generateds_size / 2 + 1; shapeShifter->generateds.functions = a404m_realloc( @@ -8203,7 +8405,29 @@ AstTree *getShapeShifterElement(AstTreeFunctionCall *metadata, } shapeShifter->generateds.functions[shapeShifter->generateds.size] = newFunction; - shapeShifter->generateds.calls[shapeShifter->generateds.size] = metadata; + + shapeShifter->generateds.calls[shapeShifter->generateds.size].size = + metadata->parameters.size; + shapeShifter->generateds.calls[shapeShifter->generateds.size].data = + a404m_malloc( + sizeof( + *shapeShifter->generateds.calls[shapeShifter->generateds.size] + .data) * + shapeShifter->generateds.calls[shapeShifter->generateds.size].size); + + for (size_t i = 0; + i < shapeShifter->generateds.calls[shapeShifter->generateds.size].size; + ++i) { + shapeShifter->generateds.calls[shapeShifter->generateds.size] + .data[i] + .value = copyAstTree(metadata->parameters.data[i].value); + shapeShifter->generateds.calls[shapeShifter->generateds.size] + .data[i] + .nameBegin = metadata->parameters.data[i].nameBegin; + shapeShifter->generateds.calls[shapeShifter->generateds.size] + .data[i] + .nameEnd = metadata->parameters.data[i].nameEnd; + } element_index = shapeShifter->generateds.size; shapeShifter->generateds.size += 1; @@ -8222,7 +8446,7 @@ AstTree *getShapeShifterElement(AstTreeFunctionCall *metadata, bool doesFunctionMatch(AstTreeTypeFunction *function, AstTreeFunctionCall *functionCall, AstTreeSetTypesHelper helper) { - if (function->arguments_size != functionCall->parameters_size) { + if (function->arguments_size != functionCall->parameters.size) { return false; } @@ -8233,8 +8457,8 @@ bool doesFunctionMatch(AstTreeTypeFunction *function, initedArguments[i].value = NULL; } - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; if (param.nameBegin != param.nameEnd) { const size_t param_name_size = param.nameEnd - param.nameBegin; for (size_t j = 0; j < function->arguments_size; ++j) { @@ -8254,8 +8478,8 @@ bool doesFunctionMatch(AstTreeTypeFunction *function, END_OF_NAMED_FOR: } - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; if (param.nameBegin == param.nameEnd) { for (size_t j = 0; j < function->arguments_size; ++j) { AstTreeTypeFunctionArgument arg = function->arguments[j]; @@ -8287,7 +8511,7 @@ bool doesShapeShifterMatch(AstTreeShapeShifter *shapeShifter, AstTreeSetTypesHelper helper) { AstTreeFunction *function = shapeShifter->function; - if (function->arguments.size != functionCall->parameters_size) { + if (function->arguments.size != functionCall->parameters.size) { return false; } @@ -8301,19 +8525,17 @@ bool doesShapeShifterMatch(AstTreeShapeShifter *shapeShifter, initedArguments[i].value = NULL; } - AstTreeVariable *variableArguments[helper.variables.size + arguments.size]; + AstTreeVariables variables[helper.variables_size + 1]; - for (size_t i = 0; i < helper.variables.size; ++i) { - variableArguments[i] = helper.variables.data[i]; + for (size_t i = 0; i < helper.variables_size; ++i) { + variables[i] = helper.variables[i]; } - for (size_t i = 0; i < arguments.size; ++i) { - variableArguments[helper.variables.size + i] = arguments.data[i]; - } + variables[helper.variables_size] = arguments; AstTreeSetTypesHelper newHelper = { - .variables.data = variableArguments, - .variables.size = helper.variables.size + arguments.size, + .variables = variables, + .variables_size = helper.variables_size + 1, .dependencies = helper.dependencies, .lookingType = NULL, .root = helper.root, @@ -8323,8 +8545,8 @@ bool doesShapeShifterMatch(AstTreeShapeShifter *shapeShifter, .isInScope = false, }; - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; if (param.nameBegin != param.nameEnd) { const size_t param_name_size = param.nameEnd - param.nameBegin; for (size_t j = 0; j < arguments.size; ++j) { @@ -8340,6 +8562,8 @@ bool doesShapeShifterMatch(AstTreeShapeShifter *shapeShifter, goto RETURN_FALSE; } arg->value = copyAstTree(param.value); + astTreeDelete(arg->type); + arg->type = copyAstTree(param.value->type); initedArguments[j] = param; goto END_OF_NAMED_FOR1; } else { @@ -8354,8 +8578,8 @@ bool doesShapeShifterMatch(AstTreeShapeShifter *shapeShifter, END_OF_NAMED_FOR1: } - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; + for (size_t i = 0; i < functionCall->parameters.size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters.data[i]; if (param.nameBegin == param.nameEnd) { for (size_t j = 0; j < arguments.size; ++j) { AstTreeVariable *arg = arguments.data[j]; @@ -8369,6 +8593,8 @@ bool doesShapeShifterMatch(AstTreeShapeShifter *shapeShifter, goto RETURN_FALSE; } arg->value = copyAstTree(param.value); + astTreeDelete(arg->type); + arg->type = copyAstTree(param.value->type); initedArguments[j] = param; goto END_OF_UNNAMED_FOR1; } @@ -8462,7 +8688,9 @@ size_t getSizeOfType(AstTree *type) { return 1; case AST_TREE_TOKEN_TYPE_I16: case AST_TREE_TOKEN_TYPE_U16: +#ifdef FLOAT_16_SUPPORT case AST_TREE_TOKEN_TYPE_F16: +#endif return 2; case AST_TREE_TOKEN_TYPE_I32: case AST_TREE_TOKEN_TYPE_U32: @@ -8497,6 +8725,7 @@ size_t getSizeOfType(AstTree *type) { case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_FUNCTION: case AST_TREE_TOKEN_BUILTIN_CAST: case AST_TREE_TOKEN_BUILTIN_TYPE_OF: @@ -8543,6 +8772,7 @@ size_t getSizeOfType(AstTree *type) { case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_VALUE_INT: case AST_TREE_TOKEN_VALUE_FLOAT: case AST_TREE_TOKEN_VALUE_BOOL: diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h index 0d63252..d95435b 100644 --- a/src/compiler/ast-tree.h +++ b/src/compiler/ast-tree.h @@ -71,6 +71,7 @@ typedef enum AstTreeToken { AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER, AST_TREE_TOKEN_TYPE_C_LIBRARY, AST_TREE_TOKEN_TYPE_C_FUNCTION, + AST_TREE_TOKEN_TYPE_MACRO, AST_TREE_TOKEN_TYPE_BOOL, AST_TREE_TOKEN_VALUE_VOID, AST_TREE_TOKEN_STATIC_VARS_END = AST_TREE_TOKEN_VALUE_VOID, @@ -84,6 +85,7 @@ typedef enum AstTreeToken { AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER, AST_TREE_TOKEN_VALUE_C_LIBRARY, AST_TREE_TOKEN_VALUE_C_FUNCTION, + AST_TREE_TOKEN_VALUE_MACRO, AST_TREE_TOKEN_VALUE_INT, AST_TREE_TOKEN_VALUE_FLOAT, AST_TREE_TOKEN_VALUE_BOOL, @@ -161,6 +163,7 @@ extern AstTree AST_TREE_CODE_TYPE; extern AstTree AST_TREE_NAMESPACE_TYPE; extern AstTree AST_TREE_SHAPE_SHIFTER_TYPE; extern AstTree AST_TREE_C_LIBRARY_TYPE; +extern AstTree AST_TREE_MACRO_TYPE; extern AstTree AST_TREE_VOID_VALUE; typedef struct AstTreeVariable { @@ -170,7 +173,6 @@ typedef struct AstTreeVariable { AstTree *value; AstTree *initValue; bool isConst; - bool isLazy; } AstTreeVariable; typedef struct AstTreeVariables { @@ -238,10 +240,14 @@ typedef struct AstTreeFunctionCallParam { AstTree *value; } AstTreeFunctionCallParam; +typedef struct AstTreeFunctionCallParams { + AstTreeFunctionCallParam *data; + size_t size; +} AstTreeFunctionCallParams; + typedef struct AstTreeFunctionCall { AstTree *function; - AstTreeFunctionCallParam *parameters; - size_t parameters_size; + AstTreeFunctionCallParams parameters; } AstTreeFunctionCall; typedef u64 AstTreeInt; @@ -284,7 +290,8 @@ typedef struct AstTreeWhile { typedef struct AstTreeSetTypesHelper { AstTree *lookingType; AstTreeVariables dependencies; - AstTreeVariables variables; + AstTreeVariables *variables; + size_t variables_size; AstTreeRoot *root; AstTreeWhile **loops; size_t loops_size; @@ -322,7 +329,7 @@ typedef struct AstTreeNamespace { typedef struct AstTreeShapeShifter { AstTreeFunction *function; struct { - AstTreeFunctionCall **calls; + AstTreeFunctionCallParams *calls; AstTreeFunction **functions; size_t size; } generateds; @@ -354,12 +361,17 @@ typedef struct AstTreeCFunction { AstTree *funcType; } AstTreeCFunction; +typedef struct AstTreeMacro { + AstTreeFunction *function; +} AstTreeMacro; + #ifdef PRINT_COMPILE_TREE void astTreePrint(const AstTree *tree, int indent); void astTreeVariablePrint(const AstTreeVariable *variable, int indent); void astTreeRootPrint(const AstTreeRoot *root); #endif +void astTreeTypeFunctionDestroy(AstTreeTypeFunction functionType); void astTreeScopeDestroy(AstTreeScope scope); void astTreeFunctionDestroy(AstTreeFunction function); void astTreeDeleteFunctionCall(AstTreeFunctionCall *functionCall); @@ -544,7 +556,7 @@ bool setTypesBuiltinCFunction(AstTree *tree, AstTreeSetTypesHelper helper, bool setTypesBuiltinInsert(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall); bool setTypesTypeArray(AstTree *tree, AstTreeSetTypesHelper helper); -bool setTypesAstFunction(AstTreeFunction *function, +bool setTypesAstFunction(AstTreeFunction *function, AstTree *tree, AstTreeSetTypesHelper helper); bool setTypesAstVariable(AstTreeVariable *variable, diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c index 43a0850..d6d4c55 100644 --- a/src/compiler/lexer.c +++ b/src/compiler/lexer.c @@ -9,7 +9,6 @@ const char *LEXER_TOKEN_STRINGS[] = { "LEXER_TOKEN_SYMBOL_CLOSE_CURLY_BRACKET", "LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS", - "LEXER_TOKEN_SYMBOL_CLOSE_BRACKET", "LEXER_TOKEN_IDENTIFIER", "LEXER_TOKEN_BUILTIN", "LEXER_TOKEN_BUILTIN_CAST", @@ -73,15 +72,16 @@ const char *LEXER_TOKEN_STRINGS[] = { "LEXER_TOKEN_KEYWORD_UNDEFINED", "LEXER_TOKEN_SYMBOL_FUNCTION_ARROW", - "LEXER_TOKEN_SYMBOL_POINTER", "LEXER_TOKEN_KEYWORD_STRUCT", - "LEXER_TOKEN_SYMBOL_CLOSE_BRACKET_LEFT", "LEXER_TOKEN_SYMBOL_DEREFERENCE", + "LEXER_TOKEN_SYMBOL_CLOSE_BRACKET", "LEXER_TOKEN_SYMBOL_ACCESS", "LEXER_TOKEN_SYMBOL_FUNCTION_CALL", "LEXER_TOKEN_SYMBOL_PLUS", + "LEXER_TOKEN_SYMBOL_CLOSE_BRACKET_LEFT", + "LEXER_TOKEN_SYMBOL_POINTER", "LEXER_TOKEN_SYMBOL_MINUS", "LEXER_TOKEN_SYMBOL_ADDRESS", "LEXER_TOKEN_SYMBOL_LOGICAL_NOT", @@ -137,7 +137,6 @@ const char *LEXER_TOKEN_STRINGS[] = { "LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS", "LEXER_TOKEN_SYMBOL_OPEN_BRACKET", "LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET", - "LEXER_TOKEN_KEYWORD_LAZY", "LEXER_TOKEN_KEYWORD_MACRO", "LEXER_TOKEN_NONE", @@ -192,40 +191,54 @@ static const size_t LEXER_SYMBOL_SIZE = sizeof(LEXER_SYMBOL_TOKENS) / sizeof(*LEXER_SYMBOL_TOKENS); static const char *LEXER_KEYWORD_STRINGS[] = { - "type", "anytype", "void", "i8", - "u8", "i16", "u16", "i32", - "u32", "i64", "u64", + "type", "anytype", "void", "i8", "u8", + "i16", "u16", "i32", "u32", "i64", + "u64", #ifdef FLOAT_16_SUPPORT "f16", #endif - "f32", "f64", "f128", "bool", - "return", "true", "false", "if", - "else", "while", "comptime", "null", - "struct", "undefined", "code", "lazy", - "namespace", "shape_shifter", "break", "continue", - "c_library", "c_function", "macro", + "f32", "f64", "f128", "bool", "return", + "true", "false", "if", "else", "while", + "comptime", "null", "struct", "undefined", "code", + "namespace", "shape_shifter", "break", "continue", "c_library", + "c_function", "macro", }; static const LexerToken LEXER_KEYWORD_TOKENS[] = { - LEXER_TOKEN_KEYWORD_TYPE, LEXER_TOKEN_KEYWORD_ANY_TYPE, - LEXER_TOKEN_KEYWORD_VOID, LEXER_TOKEN_KEYWORD_I8, - LEXER_TOKEN_KEYWORD_U8, LEXER_TOKEN_KEYWORD_I16, - LEXER_TOKEN_KEYWORD_U16, LEXER_TOKEN_KEYWORD_I32, - LEXER_TOKEN_KEYWORD_U32, LEXER_TOKEN_KEYWORD_I64, + LEXER_TOKEN_KEYWORD_TYPE, + LEXER_TOKEN_KEYWORD_ANY_TYPE, + LEXER_TOKEN_KEYWORD_VOID, + LEXER_TOKEN_KEYWORD_I8, + LEXER_TOKEN_KEYWORD_U8, + LEXER_TOKEN_KEYWORD_I16, + LEXER_TOKEN_KEYWORD_U16, + LEXER_TOKEN_KEYWORD_I32, + LEXER_TOKEN_KEYWORD_U32, + LEXER_TOKEN_KEYWORD_I64, LEXER_TOKEN_KEYWORD_U64, #ifdef FLOAT_16_SUPPORT LEXER_TOKEN_KEYWORD_F16, #endif - LEXER_TOKEN_KEYWORD_F32, LEXER_TOKEN_KEYWORD_F64, - LEXER_TOKEN_KEYWORD_F128, LEXER_TOKEN_KEYWORD_BOOL, - LEXER_TOKEN_KEYWORD_RETURN, LEXER_TOKEN_KEYWORD_TRUE, - LEXER_TOKEN_KEYWORD_FALSE, LEXER_TOKEN_KEYWORD_IF, - LEXER_TOKEN_KEYWORD_ELSE, LEXER_TOKEN_KEYWORD_WHILE, - LEXER_TOKEN_KEYWORD_COMPTIME, LEXER_TOKEN_KEYWORD_NULL, - LEXER_TOKEN_KEYWORD_STRUCT, LEXER_TOKEN_KEYWORD_UNDEFINED, - LEXER_TOKEN_KEYWORD_CODE, LEXER_TOKEN_KEYWORD_LAZY, - LEXER_TOKEN_KEYWORD_NAMESPACE, LEXER_TOKEN_KEYWORD_SHAPE_SHIFTER, - LEXER_TOKEN_KEYWORD_BREAK, LEXER_TOKEN_KEYWORD_CONTINUE, - LEXER_TOKEN_KEYWORD_C_LIBRARY, LEXER_TOKEN_KEYWORD_C_FUNCTION, + LEXER_TOKEN_KEYWORD_F32, + LEXER_TOKEN_KEYWORD_F64, + LEXER_TOKEN_KEYWORD_F128, + LEXER_TOKEN_KEYWORD_BOOL, + LEXER_TOKEN_KEYWORD_RETURN, + LEXER_TOKEN_KEYWORD_TRUE, + LEXER_TOKEN_KEYWORD_FALSE, + LEXER_TOKEN_KEYWORD_IF, + LEXER_TOKEN_KEYWORD_ELSE, + LEXER_TOKEN_KEYWORD_WHILE, + LEXER_TOKEN_KEYWORD_COMPTIME, + LEXER_TOKEN_KEYWORD_NULL, + LEXER_TOKEN_KEYWORD_STRUCT, + LEXER_TOKEN_KEYWORD_UNDEFINED, + LEXER_TOKEN_KEYWORD_CODE, + LEXER_TOKEN_KEYWORD_NAMESPACE, + LEXER_TOKEN_KEYWORD_SHAPE_SHIFTER, + LEXER_TOKEN_KEYWORD_BREAK, + LEXER_TOKEN_KEYWORD_CONTINUE, + LEXER_TOKEN_KEYWORD_C_LIBRARY, + LEXER_TOKEN_KEYWORD_C_FUNCTION, LEXER_TOKEN_KEYWORD_MACRO, }; static const size_t LEXER_KEYWORD_SIZE = @@ -502,7 +515,6 @@ lexerPushClear(LexerNodeArray *array, size_t *array_size, char const *iter, case LEXER_TOKEN_KEYWORD_UNDEFINED: case LEXER_TOKEN_KEYWORD_CODE: case LEXER_TOKEN_KEYWORD_NAMESPACE: - case LEXER_TOKEN_KEYWORD_LAZY: case LEXER_TOKEN_KEYWORD_MACRO: case LEXER_TOKEN_NUMBER: case LEXER_TOKEN_CHAR: diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h index e868900..bf53b75 100644 --- a/src/compiler/lexer.h +++ b/src/compiler/lexer.h @@ -9,7 +9,6 @@ typedef enum LexerToken { LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS, LEXER_TOKEN_ORDER1 = LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS, - LEXER_TOKEN_SYMBOL_CLOSE_BRACKET, LEXER_TOKEN_IDENTIFIER, LEXER_TOKEN_BUILTIN, LEXER_TOKEN_BUILTIN_CAST, @@ -75,15 +74,16 @@ typedef enum LexerToken { LEXER_TOKEN_SYMBOL_FUNCTION_ARROW, LEXER_TOKEN_ORDER2 = LEXER_TOKEN_SYMBOL_FUNCTION_ARROW, LEXER_TOKEN_KEYWORD_STRUCT, - LEXER_TOKEN_SYMBOL_CLOSE_BRACKET_LEFT, LEXER_TOKEN_SYMBOL_DEREFERENCE, LEXER_TOKEN_ORDER3 = LEXER_TOKEN_SYMBOL_DEREFERENCE, + LEXER_TOKEN_SYMBOL_CLOSE_BRACKET, LEXER_TOKEN_SYMBOL_ACCESS, LEXER_TOKEN_SYMBOL_FUNCTION_CALL, LEXER_TOKEN_SYMBOL_PLUS, LEXER_TOKEN_ORDER4 = LEXER_TOKEN_SYMBOL_PLUS, + LEXER_TOKEN_SYMBOL_CLOSE_BRACKET_LEFT, LEXER_TOKEN_SYMBOL_POINTER, LEXER_TOKEN_SYMBOL_MINUS, LEXER_TOKEN_SYMBOL_ADDRESS, @@ -136,23 +136,19 @@ typedef enum LexerToken { LEXER_TOKEN_KEYWORD_BREAK, LEXER_TOKEN_KEYWORD_CONTINUE, LEXER_TOKEN_KEYWORD_COMPTIME, - LEXER_TOKEN_SYMBOL_EOL, - LEXER_TOKEN_ORDER14 = LEXER_TOKEN_SYMBOL_EOL, LEXER_TOKEN_SYMBOL_COMMA, LEXER_TOKEN_KEYWORD_IF, - LEXER_TOKEN_ORDER15 = LEXER_TOKEN_KEYWORD_IF, + LEXER_TOKEN_ORDER14 = LEXER_TOKEN_KEYWORD_IF, LEXER_TOKEN_KEYWORD_WHILE, LEXER_TOKEN_KEYWORD_ELSE, LEXER_TOKEN_END_ORDERS = LEXER_TOKEN_KEYWORD_ELSE, - LEXER_TOKEN_SYMBOL, LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS, LEXER_TOKEN_SYMBOL_OPEN_BRACKET, LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET, - LEXER_TOKEN_KEYWORD_LAZY, LEXER_TOKEN_KEYWORD_MACRO, LEXER_TOKEN_NONE, diff --git a/src/compiler/parser.c b/src/compiler/parser.c index a35800c..a58b19c 100644 --- a/src/compiler/parser.c +++ b/src/compiler/parser.c @@ -201,18 +201,13 @@ static const ParserOrder PARSER_ORDER[] = { .end = LEXER_TOKEN_ORDER13, }, { - .ltr = false, + .ltr = true, .begin = LEXER_TOKEN_ORDER13, .end = LEXER_TOKEN_ORDER14, }, { - .ltr = true, - .begin = LEXER_TOKEN_ORDER14, - .end = LEXER_TOKEN_ORDER15, - }, - { .ltr = false, - .begin = LEXER_TOKEN_ORDER15, + .begin = LEXER_TOKEN_ORDER14, .end = LEXER_TOKEN_END_ORDERS, }, }; @@ -358,7 +353,6 @@ void parserNodePrint(const ParserNode *node, int indent) { case PARSER_TOKEN_CONSTANT: case PARSER_TOKEN_VARIABLE: { const ParserNodeVariableMetadata *metadata = node->metadata; - printf("isLazy=%b,\n", metadata->isLazy); for (int i = 0; i < indent; ++i) printf(" "); printf("name=\n"); @@ -1182,7 +1176,6 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end, return parserComptime(node, end, parent); case LEXER_TOKEN_KEYWORD_STRUCT: return parserStruct(node, end, parent); - case LEXER_TOKEN_KEYWORD_LAZY: case LEXER_TOKEN_KEYWORD_ELSE: case LEXER_TOKEN_KEYWORD_MACRO: case LEXER_TOKEN_BUILTIN: @@ -1522,7 +1515,7 @@ ParserNode *parserParenthesis(LexerNode *closing, LexerNode *begin, ParserNode *pNode = getUntilCommonParents(iter->parserNode, parent, parserNode); if (pNode == NULL) { - printLog(pNode->str_begin, pNode->str_end, "Bad node"); + printError(pNode->str_begin, pNode->str_end, "Bad node"); return NULL; } else { pNode->parent = parserNode; @@ -1557,7 +1550,7 @@ ParserNode *parserFunctionCall(LexerNode *closing, LexerNode *begin, ParserNode *pNode = getUntilCommonParents(iter->parserNode, parent, parserNode); if (pNode == NULL) { - printLog(pNode->str_begin, pNode->str_end, "Bad node"); + printError(pNode->str_begin, pNode->str_end, "Bad node"); return NULL; } else { pNode->parent = parserNode; @@ -1640,7 +1633,7 @@ ParserNode *parserBracketsRight(LexerNode *closing, LexerNode *begin, ParserNode *pNode = getUntilCommonParents(iter->parserNode, parent, parserNode); if (pNode == NULL) { - printLog(pNode->str_begin, pNode->str_end, "Bad node"); + printError(pNode->str_begin, pNode->str_end, "Bad node"); return NULL; } else { pNode->parent = parserNode; @@ -1676,8 +1669,8 @@ ParserNode *parserBracketsLeft(LexerNode *closing, LexerNode *begin, if (afterNode >= end || afterNode->parserNode == NULL || (after = getUntilCommonParent(afterNode->parserNode, parent)) == NULL || !isExpression(after)) { - printLog(closing->str_begin, closing->str_end, - "Bad bracket can't be parsed"); + printError(closing->str_begin, closing->str_end, + "Bad bracket can't be parsed"); return NULL; } @@ -1694,7 +1687,7 @@ ParserNode *parserBracketsLeft(LexerNode *closing, LexerNode *begin, ParserNode *pNode = getUntilCommonParents(iter->parserNode, parent, parserNode); if (pNode == NULL) { - printLog(pNode->str_begin, pNode->str_end, "Bad node"); + printError(pNode->str_begin, pNode->str_end, "Bad node"); return NULL; } else { pNode->parent = parserNode; @@ -2076,14 +2069,10 @@ ParserNode *parserVariable(LexerNode *node, LexerNode *begin, LexerNode *end, metadata->name = name; metadata->type = type; metadata->isComptime = false; - metadata->isLazy = false; LexerNode *flagNode = nameNode - 1; while (flagNode >= begin && flagNode->parserNode == NULL) { switch (flagNode->token) { - case LEXER_TOKEN_KEYWORD_LAZY: - metadata->isLazy = true; - break; case LEXER_TOKEN_KEYWORD_COMPTIME: metadata->isComptime = true; break; diff --git a/src/compiler/parser.h b/src/compiler/parser.h index 3db1d3d..9a7ac74 100644 --- a/src/compiler/parser.h +++ b/src/compiler/parser.h @@ -156,7 +156,6 @@ typedef struct ParserNodeVariableMetadata { ParserNode *name; ParserNode *type; ParserNode *value; - bool isLazy; bool isComptime; } ParserNodeVariableMetadata; diff --git a/src/runner/runner.c b/src/runner/runner.c index e6dc2b8..a1251a2 100644 --- a/src/runner/runner.c +++ b/src/runner/runner.c @@ -7,11 +7,8 @@ #include "utils/type.h" #include <dlfcn.h> #include <ffi.h> -#include <iso646.h> -#include <stdatomic.h> +#include <memory.h> #include <stdio.h> -#include <stdlib.h> -#include <string.h> #define doOperation(op0, op1, operator, originalType, type) \ *((originalType *)(op0)->metadata) = \ @@ -77,7 +74,7 @@ } \ } #else -#define doCastAll(left, left_type, type, to) \ +#define doCastAll(left, left_type, to) \ { \ const left_type value = *(left_type *)left->metadata; \ switch (to->token) { \ @@ -142,8 +139,7 @@ bool runAstTree(AstTreeRoots roots) { AstTreeVariable *mainVariable = NULL; - AstTreeScope *scope = a404m_malloc(sizeof(*scope)); - *scope = (AstTreeScope){ + AstTreeScope scope = { .expressions = a404m_malloc(0), .expressions_size = 0, .variables.data = a404m_malloc(0), @@ -168,7 +164,8 @@ bool runAstTree(AstTreeRoots roots) { } if (!variable->isConst) { runnerVariableSetValueWihtoutConstCheck(variable, variable->initValue, - scope); + &scope); + variable->initValue = NULL; } } } @@ -186,12 +183,11 @@ bool runAstTree(AstTreeRoots roots) { return false; } - AstTree *res = runAstTreeFunction(main, NULL, 0, scope, false); + AstTree *res = runAstTreeFunction(main, NULL, 0, &scope, false); const bool ret = res == &AST_TREE_VOID_VALUE; astTreeDelete(res); astTreeDelete(main); - astTreeDelete( - newAstTree(AST_TREE_TOKEN_SCOPE, scope, &AST_TREE_VOID_TYPE, NULL, NULL)); + astTreeScopeDestroy(scope); return ret; } @@ -210,10 +206,17 @@ AstTree *runAstTreeFunction(AstTree *tree, AstTree **arguments, u32 breakCount = 0; bool shouldContinue = false; + AstTreeScope *currentScope; + if (function->isMacro) { + currentScope = scope; + } else { + currentScope = &function->scope; + } + for (size_t i = 0; i < function->scope.expressions_size; ++i) { - AstTree *ret = runExpression(function->scope.expressions[i], - &function->scope, &shouldRet, false, - isComptime, &breakCount, &shouldContinue); + AstTree *ret = + runExpression(function->scope.expressions[i], currentScope, &shouldRet, + false, isComptime, &breakCount, &shouldContinue); if (shouldRet) { return ret; } else { @@ -1272,8 +1275,17 @@ AstTree *runAstTreeCFunction(AstTree *tree, AstTree **arguments, if (!typeIsEqual(arg.type, arguments[i]->type, scope)) { printLog("%s %s", AST_TREE_TOKEN_STRINGS[arg.type->token], AST_TREE_TOKEN_STRINGS[arguments[i]->type->token]); + printLog( + "%s %s", + AST_TREE_TOKEN_STRINGS[((AstTreeSingleChild *)arg.type->metadata) + ->token], + AST_TREE_TOKEN_STRINGS + [((AstTreeSingleChild *)arguments[i]->type->metadata)->token]); UNREACHABLE; - } else if (arguments[i]->token != AST_TREE_TOKEN_RAW_VALUE) { + } else if (arguments[i]->token != AST_TREE_TOKEN_RAW_VALUE && + arguments[i]->token != AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED) { + printLog("%s %p", AST_TREE_TOKEN_STRINGS[arguments[i]->token], + arguments[i]); UNREACHABLE; } values[i] = arguments[i]->metadata; @@ -1345,7 +1357,7 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, return function; } - const size_t args_size = metadata->parameters_size; + const size_t args_size = metadata->parameters.size; AstTree *args[args_size]; AstTree *result; @@ -1353,28 +1365,29 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, AstTreeFunction *fun = function->metadata; for (size_t i = 0; i < args_size; ++i) { - AstTreeVariable *function_arg = fun->arguments.data[i]; - AstTreeFunctionCallParam param = metadata->parameters[i]; - args[i] = - getForVariable(param.value, scope, shouldRet, false, isComptime, - breakCount, shouldContinue, function_arg->isLazy); - if (discontinue(*shouldRet, *breakCount)) { - astTreeDelete(function); - for (size_t j = 0; j < i; ++j) { - astTreeDelete(args[i]); + AstTreeFunctionCallParam param = metadata->parameters.data[i]; + if (fun->isMacro) { + args[i] = copyAstTree(param.value); + } else { + args[i] = runExpression(param.value, scope, shouldRet, false, + isComptime, breakCount, shouldContinue); + if (discontinue(*shouldRet, *breakCount)) { + astTreeDelete(function); + for (size_t j = 0; j < i; ++j) { + astTreeDelete(args[i]); + } + return args[i]; } - return args[i]; } } result = runAstTreeFunction(function, args, args_size, scope, isComptime); } else if (function->token >= AST_TREE_TOKEN_BUILTIN_BEGIN && function->token <= AST_TREE_TOKEN_BUILTIN_END) { for (size_t i = 0; i < args_size; ++i) { - AstTreeFunctionCallParam param = metadata->parameters[i]; + AstTreeFunctionCallParam param = metadata->parameters.data[i]; if (function->token != AST_TREE_TOKEN_BUILTIN_TYPE_OF) { - args[i] = - getForVariable(param.value, scope, shouldRet, false, isComptime, - breakCount, shouldContinue, false); + args[i] = runExpression(param.value, scope, shouldRet, false, + isComptime, breakCount, shouldContinue); if (discontinue(*shouldRet, *breakCount)) { astTreeDelete(function); for (size_t j = 0; j < i; ++j) { @@ -1394,9 +1407,9 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, } } else if (function->token == AST_TREE_TOKEN_VALUE_C_FUNCTION) { for (size_t i = 0; i < args_size; ++i) { - AstTreeFunctionCallParam param = metadata->parameters[i]; - args[i] = getForVariable(param.value, scope, shouldRet, false, - isComptime, breakCount, shouldContinue, false); + AstTreeFunctionCallParam param = metadata->parameters.data[i]; + args[i] = runExpression(param.value, scope, shouldRet, false, + isComptime, breakCount, shouldContinue); if (discontinue(*shouldRet, *breakCount)) { astTreeDelete(function); for (size_t j = 0; j < i; ++j) { @@ -1492,15 +1505,10 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, } case AST_TREE_TOKEN_VARIABLE_DEFINE: { AstTreeVariable *variable = expr->metadata; - AstTree *value; - if (variable->isLazy) { - value = copyAstTree(variable->initValue); - } else { - value = runExpression(variable->initValue, scope, shouldRet, false, - isComptime, breakCount, shouldContinue); - if (discontinue(*shouldRet, *breakCount)) { - return value; - } + AstTree *value = runExpression(variable->initValue, scope, shouldRet, false, + isComptime, breakCount, shouldContinue); + if (discontinue(*shouldRet, *breakCount)) { + return value; } runnerVariableSetValue(variable, value, scope); return &AST_TREE_VOID_VALUE; @@ -1601,6 +1609,7 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_VALUE_NULL: case AST_TREE_TOKEN_VALUE_UNDEFINED: case AST_TREE_TOKEN_VALUE_VOID: @@ -1671,13 +1680,12 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, } case AST_TREE_TOKEN_OPERATOR_DEREFERENCE: { AstTreeSingleChild *metadata = expr->metadata; - AstTree *operand = runExpression(metadata, scope, shouldRet, false, + AstTree *operand = runExpression(metadata, scope, shouldRet, true, isComptime, breakCount, shouldContinue); if (discontinue(*shouldRet, *breakCount)) { return operand; } - if (operand->token == AST_TREE_TOKEN_RAW_VALUE || - operand->token == AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED) { + if (operand->token == AST_TREE_TOKEN_RAW_VALUE) { if (operand->type->token != AST_TREE_TOKEN_OPERATOR_POINTER) { printLog("%s", AST_TREE_TOKEN_STRINGS[operand->type->token]); UNREACHABLE; @@ -1689,6 +1697,17 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, memcpy(value, *(void **)operand->metadata, size); astTreeDelete(operand); return newAstTree(AST_TREE_TOKEN_RAW_VALUE, value, type, NULL, NULL); + } else if (operand->token == AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED) { + if (operand->type->token != AST_TREE_TOKEN_OPERATOR_POINTER) { + printLog("%s", AST_TREE_TOKEN_STRINGS[operand->type->token]); + UNREACHABLE; + } + AstTree *type = + copyAstTree((AstTreeSingleChild *)operand->type->metadata); + AstTreeRawValue *value = *(void **)operand->metadata; + astTreeDelete(operand); + return newAstTree(AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED, value, type, NULL, + NULL); } else if (operand->token == AST_TREE_TOKEN_VARIABLE) { AstTree *ret; if (isLeft) { @@ -1707,12 +1726,6 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, case AST_TREE_TOKEN_VARIABLE: { AstTreeVariable *variable = expr->metadata; - if (variable->isLazy) { - AstTree *value = runExpression(variable->value, scope, shouldRet, false, - isComptime, breakCount, shouldContinue); - runnerVariableSetValue(variable, value, scope); - } - if (variable->value->token == AST_TREE_TOKEN_RAW_VALUE) { if (isLeft) { return newAstTree(AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED, @@ -1734,7 +1747,12 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, if (variable->value == NULL) { UNREACHABLE; } - return copyAstTree(variable->value); + if (canBeRaw(variable->type)) { + return runExpression(variable->value, scope, shouldRet, isLeft, + isComptime, breakCount, shouldContinue); + } else { + return copyAstTree(variable->value); + } } } case AST_TREE_TOKEN_OPERATOR_ACCESS: { @@ -1824,6 +1842,7 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, } case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: { UNREACHABLE; } @@ -1864,17 +1883,6 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, UNREACHABLE; } -AstTree *getForVariable(AstTree *expr, AstTreeScope *scope, bool *shouldRet, - bool isLeft, bool isComptime, u32 *breakCount, - bool *shouldContinue, bool isLazy) { - if (isLazy) { - return copyAstTree(expr); - } else { - return runExpression(expr, scope, shouldRet, isLeft, isComptime, breakCount, - shouldContinue); - } -} - bool discontinue(bool shouldRet, u32 breakCount) { return shouldRet || breakCount > 0; } @@ -1932,9 +1940,11 @@ AstTree *toRawValue(AstTree *value, AstTreeScope *scope) { const size_t size = getSizeOfType(value->type); AstTreeRawValue *rawValue = a404m_malloc(size); switch (value->token) { +#ifdef FLOAT_16_SUPPORT case AST_TREE_TOKEN_TYPE_F16: *(f16 *)rawValue = *(f128 *)value->metadata; break; +#endif case AST_TREE_TOKEN_TYPE_F32: *(f32 *)rawValue = *(f128 *)value->metadata; break; @@ -2009,6 +2019,7 @@ AstTree *toRawValue(AstTree *value, AstTreeScope *scope) { case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_VALUE_NAMESPACE: case AST_TREE_TOKEN_TYPE_FUNCTION: case AST_TREE_TOKEN_TYPE_ARRAY: @@ -2022,7 +2033,9 @@ AstTree *toRawValue(AstTree *value, AstTreeScope *scope) { case AST_TREE_TOKEN_TYPE_U32: case AST_TREE_TOKEN_TYPE_I64: case AST_TREE_TOKEN_TYPE_U64: +#ifdef FLOAT_16_SUPPORT case AST_TREE_TOKEN_TYPE_F16: +#endif case AST_TREE_TOKEN_TYPE_F32: case AST_TREE_TOKEN_TYPE_F64: case AST_TREE_TOKEN_TYPE_F128: @@ -2100,15 +2113,138 @@ AstTree *toRawValue(AstTree *value, AstTreeScope *scope) { case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ASSIGN: case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ADDRESS: case AST_TREE_TOKEN_SCOPE: + case AST_TREE_TOKEN_TYPE_ANY_TYPE: + case AST_TREE_TOKEN_BUILTIN_SIZE_OF: + case AST_TREE_TOKEN_BUILTIN_C_LIBRARY: + case AST_TREE_TOKEN_BUILTIN_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_C_LIBRARY: + case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: + return NULL; case AST_TREE_TOKEN_NONE: + } + UNREACHABLE; +} + +bool canBeRaw(AstTree *type) { + switch (type->token) { + case AST_TREE_TOKEN_TYPE_ARRAY: + case AST_TREE_TOKEN_TYPE_TYPE: + case AST_TREE_TOKEN_TYPE_VOID: + case AST_TREE_TOKEN_TYPE_I8: + case AST_TREE_TOKEN_TYPE_U8: + case AST_TREE_TOKEN_TYPE_I16: + case AST_TREE_TOKEN_TYPE_U16: + case AST_TREE_TOKEN_TYPE_I32: + case AST_TREE_TOKEN_TYPE_U32: + case AST_TREE_TOKEN_TYPE_I64: + case AST_TREE_TOKEN_TYPE_U64: +#ifdef FLOAT_16_SUPPORT + case AST_TREE_TOKEN_TYPE_F16: +#endif + case AST_TREE_TOKEN_TYPE_F32: + case AST_TREE_TOKEN_TYPE_F64: + case AST_TREE_TOKEN_TYPE_F128: + case AST_TREE_TOKEN_TYPE_BOOL: + return true; + case AST_TREE_TOKEN_VALUE_VOID: + case AST_TREE_TOKEN_VALUE_NULL: + case AST_TREE_TOKEN_VALUE_UNDEFINED: + case AST_TREE_TOKEN_VALUE_BOOL: + case AST_TREE_TOKEN_VALUE_INT: + case AST_TREE_TOKEN_VALUE_FLOAT: + case AST_TREE_TOKEN_VALUE_OBJECT: + case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED: + case AST_TREE_TOKEN_VALUE_C_LIBRARY: + case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: + case AST_TREE_TOKEN_VALUE_MACRO: + case AST_TREE_TOKEN_VALUE_NAMESPACE: + case AST_TREE_TOKEN_TYPE_FUNCTION: + case AST_TREE_TOKEN_TYPE_CODE: + case AST_TREE_TOKEN_TYPE_NAMESPACE: + case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: + case AST_TREE_TOKEN_FUNCTION: + case AST_TREE_TOKEN_BUILTIN_CAST: + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + case AST_TREE_TOKEN_BUILTIN_IMPORT: + case AST_TREE_TOKEN_BUILTIN_IS_COMPTIME: + case AST_TREE_TOKEN_BUILTIN_STACK_ALLOC: + case AST_TREE_TOKEN_BUILTIN_HEAP_ALLOC: + case AST_TREE_TOKEN_BUILTIN_NEG: + case AST_TREE_TOKEN_BUILTIN_ADD: + case AST_TREE_TOKEN_BUILTIN_SUB: + case AST_TREE_TOKEN_BUILTIN_MUL: + case AST_TREE_TOKEN_BUILTIN_DIV: + case AST_TREE_TOKEN_BUILTIN_MOD: + case AST_TREE_TOKEN_BUILTIN_EQUAL: + case AST_TREE_TOKEN_BUILTIN_NOT_EQUAL: + case AST_TREE_TOKEN_BUILTIN_GREATER: + case AST_TREE_TOKEN_BUILTIN_SMALLER: + case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL: + case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL: + case AST_TREE_TOKEN_BUILTIN_PUTC: + case AST_TREE_TOKEN_BUILTIN_BITWISE_NOT: + case AST_TREE_TOKEN_BUILTIN_BITWISE_AND: + case AST_TREE_TOKEN_BUILTIN_BITWISE_XOR: + case AST_TREE_TOKEN_BUILTIN_BITWISE_OR: + case AST_TREE_TOKEN_BUILTIN_SHIFT_LEFT: + case AST_TREE_TOKEN_BUILTIN_SHIFT_RIGHT: + case AST_TREE_TOKEN_BUILTIN_INSERT: + case AST_TREE_TOKEN_KEYWORD_RETURN: + case AST_TREE_TOKEN_KEYWORD_BREAK: + case AST_TREE_TOKEN_KEYWORD_CONTINUE: + case AST_TREE_TOKEN_KEYWORD_IF: + case AST_TREE_TOKEN_KEYWORD_WHILE: + case AST_TREE_TOKEN_KEYWORD_COMPTIME: + case AST_TREE_TOKEN_KEYWORD_STRUCT: + case AST_TREE_TOKEN_FUNCTION_CALL: + case AST_TREE_TOKEN_VARIABLE: + case AST_TREE_TOKEN_VARIABLE_DEFINE: + case AST_TREE_TOKEN_RAW_VALUE: + case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT: + case AST_TREE_TOKEN_OPERATOR_ASSIGN: + case AST_TREE_TOKEN_OPERATOR_PLUS: + case AST_TREE_TOKEN_OPERATOR_MINUS: + case AST_TREE_TOKEN_OPERATOR_SUM: + case AST_TREE_TOKEN_OPERATOR_SUB: + case AST_TREE_TOKEN_OPERATOR_MULTIPLY: + case AST_TREE_TOKEN_OPERATOR_DIVIDE: + case AST_TREE_TOKEN_OPERATOR_MODULO: + case AST_TREE_TOKEN_OPERATOR_EQUAL: + case AST_TREE_TOKEN_OPERATOR_NOT_EQUAL: + case AST_TREE_TOKEN_OPERATOR_GREATER: + case AST_TREE_TOKEN_OPERATOR_SMALLER: + case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL: + case AST_TREE_TOKEN_OPERATOR_SMALLER_OR_EQUAL: + case AST_TREE_TOKEN_OPERATOR_POINTER: + case AST_TREE_TOKEN_OPERATOR_ADDRESS: + case AST_TREE_TOKEN_OPERATOR_DEREFERENCE: + case AST_TREE_TOKEN_OPERATOR_ACCESS: + case AST_TREE_TOKEN_OPERATOR_LOGICAL_NOT: + case AST_TREE_TOKEN_OPERATOR_LOGICAL_AND: + case AST_TREE_TOKEN_OPERATOR_LOGICAL_OR: + case AST_TREE_TOKEN_OPERATOR_BITWISE_NOT: + case AST_TREE_TOKEN_OPERATOR_BITWISE_AND: + case AST_TREE_TOKEN_OPERATOR_BITWISE_XOR: + case AST_TREE_TOKEN_OPERATOR_BITWISE_OR: + case AST_TREE_TOKEN_OPERATOR_SHIFT_LEFT: + case AST_TREE_TOKEN_OPERATOR_SHIFT_RIGHT: + case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS: + case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ASSIGN: + case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ADDRESS: + case AST_TREE_TOKEN_SCOPE: case AST_TREE_TOKEN_TYPE_ANY_TYPE: case AST_TREE_TOKEN_BUILTIN_SIZE_OF: case AST_TREE_TOKEN_BUILTIN_C_LIBRARY: case AST_TREE_TOKEN_BUILTIN_C_FUNCTION: case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: + return false; + case AST_TREE_TOKEN_NONE: } - return NULL; + UNREACHABLE; } AstTree *fromRawValue(AstTree *value) { @@ -2154,7 +2290,9 @@ AstTree *fromRawValue(AstTree *value) { case AST_TREE_TOKEN_TYPE_U32: case AST_TREE_TOKEN_TYPE_I64: case AST_TREE_TOKEN_TYPE_U64: +#ifdef FLOAT_16_SUPPORT case AST_TREE_TOKEN_TYPE_F16: +#endif case AST_TREE_TOKEN_TYPE_F32: case AST_TREE_TOKEN_TYPE_F64: case AST_TREE_TOKEN_TYPE_F128: @@ -2163,6 +2301,7 @@ AstTree *fromRawValue(AstTree *value) { case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_TYPE_BOOL: case AST_TREE_TOKEN_TYPE_FUNCTION: case AST_TREE_TOKEN_TYPE_TYPE: @@ -2215,6 +2354,7 @@ AstTree *fromRawValue(AstTree *value) { case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_VALUE_INT: case AST_TREE_TOKEN_VALUE_FLOAT: case AST_TREE_TOKEN_VALUE_BOOL: @@ -2420,6 +2560,7 @@ AstTree *castTo(AstTree *tree, AstTree *to) { case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_VALUE_INT: case AST_TREE_TOKEN_VALUE_FLOAT: case AST_TREE_TOKEN_VALUE_BOOL: @@ -2464,6 +2605,7 @@ AstTree *castTo(AstTree *tree, AstTree *to) { case AST_TREE_TOKEN_BUILTIN_C_FUNCTION: case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: } printLog("%s", AST_TREE_TOKEN_STRINGS[tree->type->token]); UNREACHABLE; @@ -2490,8 +2632,10 @@ ffi_type *toFFIType(AstTree *type) { return &ffi_type_sint64; case AST_TREE_TOKEN_TYPE_U64: return &ffi_type_uint64; +#ifdef FLOAT_16_SUPPORT case AST_TREE_TOKEN_TYPE_F16: NOT_IMPLEMENTED; +#endif case AST_TREE_TOKEN_TYPE_F32: return &ffi_type_float; case AST_TREE_TOKEN_TYPE_F64: @@ -2527,6 +2671,7 @@ ffi_type *toFFIType(AstTree *type) { case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: case AST_TREE_TOKEN_FUNCTION: case AST_TREE_TOKEN_BUILTIN_CAST: case AST_TREE_TOKEN_BUILTIN_TYPE_OF: @@ -2573,6 +2718,7 @@ ffi_type *toFFIType(AstTree *type) { case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: case AST_TREE_TOKEN_VALUE_C_LIBRARY: case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_MACRO: case AST_TREE_TOKEN_VALUE_INT: case AST_TREE_TOKEN_VALUE_FLOAT: case AST_TREE_TOKEN_VALUE_BOOL: diff --git a/src/runner/runner.h b/src/runner/runner.h index 3175ece..815cb0a 100644 --- a/src/runner/runner.h +++ b/src/runner/runner.h @@ -31,13 +31,10 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, bool isLeft, bool isComptime, u32 *breakCount, bool *shouldContinue); -AstTree *getForVariable(AstTree *expr, AstTreeScope *scope, bool *shouldRet, - bool isLeft, bool isComptime, u32 *breakCount, - bool *shouldContinue, bool isLazy); - bool discontinue(bool shouldRet, u32 breakCount); AstTree *toRawValue(AstTree *value, AstTreeScope *scope); +bool canBeRaw(AstTree *type); AstTree *fromRawValue(AstTree *value); AstTree *castTo(AstTree *value, AstTree *to); diff --git a/src/utils/dl.c b/src/utils/dl.c index 1a1c430..3ec6bc4 100644 --- a/src/utils/dl.c +++ b/src/utils/dl.c @@ -2,7 +2,6 @@ #include "utils/memory.h" #include "utils/string.h" #include <dlfcn.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> diff --git a/src/utils/dl.h b/src/utils/dl.h index 74cb865..79fc6b4 100644 --- a/src/utils/dl.h +++ b/src/utils/dl.h @@ -1,7 +1,5 @@ #pragma once -#include <stddef.h> - void dynamicLibraryInit(); void dynamicLibraryDestroy(); |