nielsbross/Ink-Shader-Language
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Change result to context for clarity. Fix a bunch of stuff in builtin functions and structs.

Browse Source
This commit is contained in:
Niels Bross
2025-09-10 23:21:34 +02:00
parent ceafd197f5
commit 9461fe626f
7 changed files with 374 additions and 361 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
Semantic_Analysis.jai
View File

@@ -143,7 +143,7 @@ Semantic_Checker :: struct {
current_scope : Scope_Handle;
result : *Compile_Result;
ctx : *Compiler_Context;
current_buffer_index : u32 = 0;
current_sampler_index : u32 = 0;
@@ -451,7 +451,7 @@ Attempting to access a field on a primitive type '%'.
init_string_builder(*builder,, temp);
variable := from_handle(checker, handle);
print_to_builder(*builder, "Attempting to access a field on a primitive type '%'.\n", proper_type_to_string(checker.result.type_variables, variable));
print_to_builder(*builder, "Attempting to access a field on a primitive type '%'.\n", proper_type_to_string(checker.ctx.type_variables, variable));
indent(*builder, 1);
cyan(*builder);
@@ -512,7 +512,7 @@ if_condition_has_to_be_boolean_type :: (checker : *Semantic_Checker, usage_site
usage_child := usage_site.children[0];
usage_loc := usage_child.source_location;
print_to_builder(*builder, "% has type %\n", print_from_source_location(*usage_loc), proper_type_to_string(checker.result.type_variables, var));
print_to_builder(*builder, "% has type %\n", print_from_source_location(*usage_loc), proper_type_to_string(checker.ctx.type_variables, var));
message := builder_to_string(*builder,, temp);
record_error(checker, message, usage_site.source_location, false);
@@ -554,7 +554,7 @@ type_mismatch :: (checker : *Semantic_Checker, usage_site : *AST_Node, expect_no
indent(*builder, 1);
print_to_builder(*builder, "expected:\n");
indent(*builder, 2);
proper_type_to_string(*builder, checker.result.type_variables, expect_var);
proper_type_to_string(*builder, checker.ctx.type_variables, expect_var);
append(*builder, "\n");
// indent(*builder, 2);
@@ -592,7 +592,7 @@ record_error :: (checker : *Semantic_Checker, error_string : string, locations :
error.message = error_string;
checker.had_error = true;
array_add(*checker.result.messages, error);
array_add(*checker.ctx.messages, error);
}
is_proper :: (var : Type_Variable) -> bool {
@@ -617,10 +617,10 @@ use_scope :: (checker : *Semantic_Checker, handle : Scope_Handle) -> Scope_Handl
push_scope :: (checker : *Semantic_Checker, name := "", kind : Scope_Kind = .Global) -> *Scope, Scope_Handle {
new_scope : Scope;
array_add(*checker.result.scope_stack.stack, new_scope);
array_add(*checker.ctx.scope_stack.stack, new_scope);
count := checker.result.scope_stack.stack.count;
scope := *checker.result.scope_stack.stack[count - 1];
count := checker.ctx.scope_stack.stack.count;
scope := *checker.ctx.scope_stack.stack[count - 1];
scope.allocator = make_arena(Kilobytes(512));
scope.table.allocator = scope.allocator;
scope.parent = checker.current_scope;
@@ -630,7 +630,7 @@ push_scope :: (checker : *Semantic_Checker, name := "", kind : Scope_Kind = .Glo
scope.builtin = true;
}
scope.children.allocator = checker.result.scope_stack.stack.allocator;
scope.children.allocator = checker.ctx.scope_stack.stack.allocator;
if checker.current_scope {
scope := get_current_scope(checker);
@@ -653,12 +653,12 @@ pop_scope :: (checker : *Semantic_Checker) -> Scope_Handle {
}
peek_scope :: (checker : *Semantic_Checker) -> *Scope, Scope_Handle {
if checker.result.scope_stack.stack.count == 0 {
if checker.ctx.scope_stack.stack.count == 0 {
return null, 0;
}
count := checker.result.scope_stack.stack.count;
scope := *checker.result.scope_stack.stack[count - 1];
count := checker.ctx.scope_stack.stack.count;
scope := *checker.ctx.scope_stack.stack[count - 1];
return scope, xx count;
}
@@ -675,7 +675,7 @@ get_scope :: (scope_stack : Scope_Stack, handle : Scope_Handle) -> *Scope {
}
get_scope :: (checker : *Semantic_Checker, handle : Scope_Handle) -> *Scope {
return get_scope(*checker.result.scope_stack, handle);
return get_scope(*checker.ctx.scope_stack, handle);
}
add_symbol_to_scope :: (state : Checker_State, scope_stack : *Scope_Stack, scope_handle : Scope_Handle, name : string, symbol : Defined_Symbol) -> *Defined_Symbol {
@@ -697,8 +697,8 @@ add_symbol_to_scope :: (state : Checker_State, scope_stack : *Scope_Stack, scope
new_type_variable :: (checker : *Semantic_Checker) -> *Type_Variable, Type_Variable_Handle {
variable : Type_Variable;
handle := cast(Type_Variable_Handle)checker.result.type_variables.count + 1;
array_add(*checker.result.type_variables, variable);
handle := cast(Type_Variable_Handle)checker.ctx.type_variables.count + 1;
array_add(*checker.ctx.type_variables, variable);
return from_handle(checker, handle), handle;
}
@@ -723,14 +723,14 @@ Arg :: struct {
new_builtin_struct :: (checker : *Semantic_Checker, name : string, members : []Arg) -> *Type_Variable, Type_Variable_Handle {
tv, handle := new_builtin_type_variable(checker, .Struct, .Declaration, name, name);
builtin_node := new_builtin_struct_node(checker.result, name, members, checker.result.allocator);
builtin_node := new_builtin_struct_node(checker.ctx, name, members, checker.ctx.allocator);
symbol : Defined_Symbol;
symbol.name = name;
symbol.source_node = builtin_node;
symbol.builtin = true;
symbol.type_variable = handle;
add_symbol_to_scope(checker.state, *checker.result.scope_stack, checker.current_scope, name, symbol);
add_symbol_to_scope(checker.state, *checker.ctx.scope_stack, checker.current_scope, name, symbol);
tv.source_node = builtin_node;
@@ -749,7 +749,7 @@ new_builtin_struct :: (checker : *Semantic_Checker, name : string, members : []A
member_symbol : Defined_Symbol;
member_symbol.name = member.name;
member_symbol.type_variable = member_handle;
add_symbol_to_scope(checker.state, *checker.result.scope_stack, checker.current_scope, member.name, member_symbol);
add_symbol_to_scope(checker.state, *checker.ctx.scope_stack, checker.current_scope, member.name, member_symbol);
field_list.children[it_index].type_variable = member_handle;
member_var.source_node = field_list.children[it_index];
@@ -765,7 +765,7 @@ new_builtin_struct :: (checker : *Semantic_Checker, name : string, members : []A
new_builtin_function :: (checker : *Semantic_Checker, name : string, args : []Arg, return_arg : Arg) -> *Type_Variable, Type_Variable_Handle {
tv, handle := new_builtin_type_variable(checker, .Function, .Declaration, name);
builtin_node := new_builtin_function_node(checker.result, name, args, return_arg, checker.result.allocator);
builtin_node := new_builtin_function_node(checker.ctx, name, args, return_arg, checker.ctx.allocator);
function : Defined_Symbol;
function.name = name;
@@ -782,7 +782,7 @@ new_builtin_function :: (checker : *Semantic_Checker, name : string, args : []Ar
symbol.type_variable = 0;
symbol.functions.allocator = get_current_scope(checker).allocator;
array_add(*symbol.functions, function);
add_symbol_to_scope(checker.state, *checker.result.scope_stack, checker.current_scope, name, symbol);
add_symbol_to_scope(checker.state, *checker.ctx.scope_stack, checker.current_scope, name, symbol);
} else {
array_add(*find_result.functions, function);
}
@@ -791,20 +791,14 @@ new_builtin_function :: (checker : *Semantic_Checker, name : string, args : []Ar
field_list := get_field_list(builtin_node);
scope, scope_handle := push_scope(checker, name, .Struct);
tv.scope = scope_handle;
for arg : args {
typename : string;
kind := lookup_type(checker, checker.current_scope, arg.typename, *typename);
arg_var, arg_handle := new_builtin_type_variable(checker, kind, .Expression, arg.name);
arg_var.scope = tv.scope;
arg_symbol : Defined_Symbol;
arg_symbol.name = arg.name;
arg_symbol.type_variable = arg_handle;
add_symbol_to_scope(checker.state, *checker.result.scope_stack, checker.current_scope, arg.name, arg_symbol);
arg_var.scope = tv.scope;
arg_var.type = kind;
arg_var.typename = typename;
field_list.children[it_index].type_variable = arg_handle;
arg_var.source_node = field_list.children[it_index];
@@ -812,7 +806,11 @@ new_builtin_function :: (checker : *Semantic_Checker, name : string, args : []Ar
add_child(checker, handle, arg_handle);
}
pop_scope(checker);
if return_arg.typename.count > 0 {
return_var, return_handle := new_type_variable(checker);
return_var.type = lookup_type(checker, checker.current_scope, return_arg.typename, *return_var.typename);
from_handle(checker, handle).return_type_variable = return_handle;
}
return from_handle(checker, handle), handle;
}
@@ -838,12 +836,12 @@ init_semantic_checker :: (checker : *Semantic_Checker, root : *AST_Node, path :
checker.program_root = root;
checker.path = path;
checker.result.type_variables.allocator = checker.result.allocator;
array_reserve(*checker.result.type_variables, 2048);
checker.ctx.type_variables.allocator = checker.ctx.allocator;
array_reserve(*checker.ctx.type_variables, 2048);
checker.result.scope_stack.allocator = make_arena(Megabytes(8));
checker.result.scope_stack.stack.allocator = checker.result.scope_stack.allocator;
array_reserve(*checker.result.scope_stack.stack, 256);
checker.ctx.scope_stack.allocator = make_arena(Megabytes(8));
checker.ctx.scope_stack.stack.allocator = checker.ctx.scope_stack.allocator;
array_reserve(*checker.ctx.scope_stack.stack, 256);
global_scope, global_handle := push_scope(checker, kind = .Global);
array_reserve(*global_scope.children, 2048);
@@ -869,7 +867,7 @@ find_symbol :: (scope_stack : Scope_Stack, name : string, current_scope : Scope_
}
find_symbol :: (checker : *Semantic_Checker, name : string, current_scope : Scope_Handle, containing_scope : *Scope_Handle = null) -> *Defined_Symbol {
return find_symbol(checker.result.scope_stack, name, current_scope, containing_scope);
return find_symbol(checker.ctx.scope_stack, name, current_scope, containing_scope);
}
find_symbol :: (name : string, checker : *Semantic_Checker, containing_scope : *Scope_Handle = null) -> *Defined_Symbol {
@@ -882,7 +880,7 @@ from_handle :: (variables : []Type_Variable, handle : Type_Variable_Handle) -> *
}
from_handle :: (checker : *Semantic_Checker, handle : Type_Variable_Handle) -> *Type_Variable {
return from_handle(checker.result.type_variables, handle);
return from_handle(checker.ctx.type_variables, handle);
}
proper_type_to_string :: (builder : *String_Builder, variables : []Type_Variable, var : Type_Variable) {
@@ -1011,7 +1009,7 @@ declare_struct :: (checker : *Semantic_Checker, node : *AST_Node, name : string)
symbol.name = name;
symbol.source_node = node;
symbol.type_variable = handle;
add_symbol_to_scope(checker.state, *checker.result.scope_stack, checker.current_scope, name, symbol);
add_symbol_to_scope(checker.state, *checker.ctx.scope_stack, checker.current_scope, name, symbol);
} else {
symbol_redeclaration(checker, node, find_result);
return 0;
@@ -1046,7 +1044,7 @@ declare_properties :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Va
name := ifx node.name.count == 0 then "properties" else node.name;
if node.name.count > 0 {
checker.result.property_name = name;
checker.ctx.property_name = name;
}
type_var := declare_struct(checker, node, name);
var := from_handle(checker, type_var);
@@ -1063,7 +1061,7 @@ declare_cbuffer :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Varia
var.type = .CBuffer;
var.resource_index = checker.current_buffer_index;
checker.current_buffer_index += 1;
array_add(*checker.result.constant_buffers, type_var);
array_add(*checker.ctx.constant_buffers, type_var);
return type_var;
}
@@ -1098,11 +1096,11 @@ declare_function :: (checker : *Semantic_Checker, node : *AST_Node, builtin : bo
name_to_check := get_actual_function_name(node);
if node.vertex_entry_point {
checker.result.vertex_entry_point.node = node;
checker.ctx.vertex_entry_point.node = node;
}
if node.pixel_entry_point {
checker.result.pixel_entry_point.node = node;
checker.ctx.pixel_entry_point.node = node;
}
find_result := find_symbol(checker, name_to_check, checker.current_scope);
@@ -1120,7 +1118,7 @@ declare_function :: (checker : *Semantic_Checker, node : *AST_Node, builtin : bo
array_reserve(*symbol.functions, 32);
array_add(*symbol.functions, function);
add_symbol_to_scope(checker.state, *checker.result.scope_stack, checker.current_scope, name_to_check, symbol);
add_symbol_to_scope(checker.state, *checker.ctx.scope_stack, checker.current_scope, name_to_check, symbol);
} else {
//@Note(niels): This is some ugly code, but it's probably fine for now.
field_list := node.children[0];
@@ -1357,7 +1355,7 @@ check_field :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_
symbol.name = node.name;
symbol.source_node = node;
symbol.type_variable = handle;
add_symbol_to_scope(checker.state, *checker.result.scope_stack, checker.current_scope, node.name, symbol);
add_symbol_to_scope(checker.state, *checker.ctx.scope_stack, checker.current_scope, node.name, symbol);
} else {
symbol_redeclaration(checker, node, find_result);
return 0;
@@ -1612,7 +1610,7 @@ check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_H
typename : string;
variable.type = .Int;
symbol.type_variable = handle;
add_symbol_to_scope(checker.state, *checker.result.scope_stack, checker.current_scope, symbol.name, symbol);
add_symbol_to_scope(checker.state, *checker.ctx.scope_stack, checker.current_scope, symbol.name, symbol);
begin_iter := check_node(checker, node.children[0]);
begin_var := from_handle(checker, begin_iter);
@@ -1807,15 +1805,19 @@ add_builtins_new :: (checker : *Semantic_Checker) {
float_name := Typenames[Type_Kind.Float];
int_name := Typenames[Type_Kind.Int];
arg :: (name : string, kind : Type_Kind) -> Arg {
arg :: (name : string = "", kind : Type_Kind) -> Arg {
return .{ name, Typenames[kind] };
}
farg :: (name : string) -> Arg {
targ :: (typename : string) -> Arg {
return .{ "", typename };
}
farg :: (name : string = "") -> Arg {
return arg(name, .Float);
}
iarg :: (name : string) -> Arg {
iarg :: (name : string = "") -> Arg {
return arg(name, .Int);
}
@@ -1827,7 +1829,7 @@ add_builtins_new :: (checker : *Semantic_Checker) {
i := 0;
for x : 0..3 {
for y : 0..3 {
float4x4_members[i] = farg(tprint("m%%", x + 1, y + 1));
float4x4_members[i] = farg(tprint("m%1%2", x + 1, y + 1));
i += 1;
}
}
@@ -1842,7 +1844,7 @@ add_builtins_new :: (checker : *Semantic_Checker) {
i = 0;
for x : 0..3 {
for y : 0..3 {
int4x4_members[i].name = tprint("m%%", x + 1, y + 1);
int4x4_members[i].name = tprint("m%1%2", x + 1, y + 1);
int4x4_members[i].typename = int_name;
i += 1;
}
@@ -1850,9 +1852,27 @@ add_builtins_new :: (checker : *Semantic_Checker) {
int4x4_tv, i4x4h := new_builtin_struct(checker, "int4x4", int4x4_members);
new_builtin_function(checker, "float2", .[farg("x"), farg("y")], .{ "res", "float2" });
new_builtin_function(checker, "float2", .[.{"v", "float2"}], .{ "res", "float2" });
new_builtin_function(checker, "float3", .[farg("x"), farg("y"), farg("z")], .{ "res", "float3" });
new_builtin_function(checker, "float2", .[farg(), farg()], targ("float2"));
new_builtin_function(checker, "float2", .[farg()], targ("float2"));
new_builtin_function(checker, "float2", .[targ("float2")], targ("float2"));
new_builtin_function(checker, "float3", .[farg(), farg(), farg()], targ("float3"));
new_builtin_function(checker, "float3", .[targ("float3")], targ("float3"));
new_builtin_function(checker, "float3", .[targ("float2"), farg()], targ("float3"));
new_builtin_function(checker, "float3", .[farg(), targ("float2")], targ("float3"));
new_builtin_function(checker, "float3", .[farg()], targ("float3"));
new_builtin_function(checker, "float4", .[farg(), farg(), farg(), farg()], targ("float4"));
new_builtin_function(checker, "float4", .[targ("float2"), targ("float2")], targ("float4"));
new_builtin_function(checker, "float4", .[targ("float2"), farg(), farg()], targ("float4"));
new_builtin_function(checker, "float4", .[farg(), targ("float2"), farg()], targ("float4"));
new_builtin_function(checker, "float4", .[farg(), farg(), targ("float2")], targ("float4"));
new_builtin_function(checker, "float4", .[farg(), targ("float3")], targ("float4"));
new_builtin_function(checker, "float4", .[targ("float3"), farg()], targ("float4"));
new_builtin_function(checker, "float4", .[targ("float4")], targ("float4"));
new_builtin_function(checker, "float4", .[farg()], targ("float4"));
checker.state = .Type_Checking;
}
@@ -1883,45 +1903,45 @@ add_builtins :: (checker : *Semantic_Checker) {
checker.state = .Adding_Builtins;
checker.result.file = make_file_from_string(BUILTIN);
checker.result.allocator = make_arena(Megabytes(128));
checker.ctx.file = make_file_from_string(BUILTIN);
checker.ctx.allocator = make_arena(Megabytes(128));
prev_file := checker.result.file;
prev_root := checker.result.root;
prev_tokens := checker.result.tokens;
prev_file := checker.ctx.file;
prev_root := checker.ctx.root;
prev_tokens := checker.ctx.tokens;
checker.result.root = null;
checker.ctx.root = null;
tokens : [..]Token;
scratch := get_scratch();
defer scratch_end(scratch);
tokens.allocator = scratch.allocator;
array_reserve(*tokens, 1024 * 1024);
checker.result.tokens = tokens;
checker.ctx.tokens = tokens;
checker.result.tokens.count = 0;
checker.ctx.tokens.count = 0;
lex(checker.result);
parse(checker.result);
type_check(checker, checker.result.root);
lex(checker.ctx);
parse(checker.ctx);
type_check(checker, checker.ctx.root);
for *type_var : checker.result.type_variables {
for *type_var : checker.ctx.type_variables {
type_var.builtin = true;
}
checker.state = .Type_Checking;
checker.result.file = prev_file;
checker.result.root = prev_root;
checker.result.tokens = prev_tokens;
checker.ctx.file = prev_file;
checker.ctx.root = prev_root;
checker.ctx.tokens = prev_tokens;
}
type_check :: (checker : *Semantic_Checker, root : *AST_Node) {
traverse(checker, root);
}
check :: (result : *Compile_Result, allocator : Allocator = temp) {
if result.had_error {
check :: (ctx : *Compiler_Context, allocator : Allocator = temp) {
if ctx.had_error {
return;
}
@@ -1936,16 +1956,16 @@ check :: (result : *Compile_Result, allocator : Allocator = temp) {
checker.current_buffer_index = 0;
checker.current_sampler_index = 0;
checker.current_texture_index = 0;
checker.result = result;
checker.ctx = ctx;
init_semantic_checker(*checker, result.root, result.file.path);
init_semantic_checker(*checker, ctx.root, ctx.file.path);
add_builtins_new(*checker);
// add_builtins(*checker);
type_check(*checker, result.root);
type_check(*checker, ctx.root);
result.had_error |= checker.had_error;
ctx.had_error |= checker.had_error;
}
@@ -2227,18 +2247,17 @@ pretty_print_symbol_table :: (checker : *Semantic_Checker, allocator : Allocator
builder : String_Builder;
init_string_builder(*builder,, allocator);
pretty_print_scope(xx checker.current_scope, checker.result.scope_stack, checker.result.type_variables, *checker.result.scope_stack.stack[0], *builder);
pretty_print_scope(xx checker.current_scope, checker.ctx.scope_stack, checker.ctx.type_variables, *checker.ctx.scope_stack.stack[0], *builder);
return builder_to_string(*builder,, allocator);
}
pretty_print_symbol_table :: (result : *Compile_Result, allocator : Allocator) -> string {
pretty_print_symbol_table :: (ctx : *Compiler_Context, allocator : Allocator) -> string {
builder : String_Builder;
init_string_builder(*builder,, allocator);
current_scope := cast(Scope_Handle)1;
pretty_print_scope(current_scope, result.scope_stack, result.type_variables, *result.scope_stack.stack[0], *builder);
pretty_print_scope(current_scope, ctx.scope_stack, ctx.type_variables, *ctx.scope_stack.stack[0], *builder);
return builder_to_string(*builder,, allocator);
}