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

Changed some naming in sem checker.

Browse Source
This commit is contained in:
Niels Bross
2025-08-23 22:01:25 +02:00
parent 45f67e16a8
commit b491a56409
2 changed files with 21 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
Semantic_Analysis.jai
View File

@@ -13,7 +13,7 @@ VERTEX_MAIN_FUNCTION_PREFIX :: "vertex";
PIXEL_MAIN_FUNCTION_PREFIX :: "pixel"; PIXEL_MAIN_FUNCTION_PREFIX :: "pixel";
PROPERTIES_PREFIX :: "properties"; PROPERTIES_PREFIX :: "properties";
Semantic_Type :: enum { Type_Kind :: enum {
Invalid :: 128; Invalid :: 128;
Int :: 0; Int :: 0;
@@ -56,7 +56,7 @@ Typenames :: string.[
]; ];
Type_Variable :: struct { Type_Variable :: struct {
type : Semantic_Type; type : Type_Kind;
kind : Type_Variable_Kind; kind : Type_Variable_Kind;
builtin : bool; builtin : bool;
@@ -844,16 +844,16 @@ proper_type_to_string :: (variables : []Type_Variable, var : Type_Variable, allo
} }
get_type_from_identifier :: (checker : *Semantic_Checker, scope : Scope_Handle, node : *AST_Node, typename : *string = null) -> Semantic_Type { get_type_from_identifier :: (checker : *Semantic_Checker, scope : Scope_Handle, node : *AST_Node, typename : *string = null) -> Type_Kind {
type_string := node.token.ident_value; type_string := node.token.ident_value;
if type_string == { if type_string == {
case Typenames[Semantic_Type.Int]; return .Int; case Typenames[Type_Kind.Int]; return .Int;
case Typenames[Semantic_Type.Half]; return .Half; case Typenames[Type_Kind.Half]; return .Half;
case Typenames[Semantic_Type.Float]; return .Float; case Typenames[Type_Kind.Float]; return .Float;
case Typenames[Semantic_Type.Double]; return .Double; case Typenames[Type_Kind.Double]; return .Double;
case Typenames[Semantic_Type.Sampler]; return .Sampler; case Typenames[Type_Kind.Sampler]; return .Sampler;
case Typenames[Semantic_Type.Texture2D]; return .Texture2D; case Typenames[Type_Kind.Texture2D]; return .Texture2D;
} }
symbol := find_symbol(checker, type_string, scope); symbol := find_symbol(checker, type_string, scope);
@@ -910,7 +910,7 @@ declare_struct :: (checker : *Semantic_Checker, node : *AST_Node, name : string)
for child : node.children { for child : node.children {
if child.kind == .FieldList { if child.kind == .FieldList {
for field : child.children { for field : child.children {
type_var := create_field(checker, field); type_var := check_field(checker, field);
if type_var > 0 { if type_var > 0 {
from_handle(checker, type_var).scope = scope_handle; from_handle(checker, type_var).scope = scope_handle;
@@ -1095,7 +1095,7 @@ declare_function :: (checker : *Semantic_Checker, node : *AST_Node, builtin : bo
return handle; return handle;
} }
create_function :: (checker : *Semantic_Checker, node : *AST_Node) { check_function :: (checker : *Semantic_Checker, node : *AST_Node) {
name_to_check := get_actual_function_name(node); name_to_check := get_actual_function_name(node);
find_result := find_symbol(checker, name_to_check, checker.current_scope); find_result := find_symbol(checker, name_to_check, checker.current_scope);
@@ -1142,7 +1142,7 @@ create_function :: (checker : *Semantic_Checker, node : *AST_Node) {
} }
} }
create_variable :: (checker : *Semantic_Checker, node : *AST_Node, struct_field_parent : *AST_Node = null) -> Type_Variable_Handle { check_variable :: (checker : *Semantic_Checker, node : *AST_Node, struct_field_parent : *AST_Node = null) -> Type_Variable_Handle {
find_result := find_symbol(checker, node.name, checker.current_scope); find_result := find_symbol(checker, node.name, checker.current_scope);
// x : int; // x : int;
// x.d = 5; // x.d = 5;
@@ -1175,7 +1175,7 @@ create_variable :: (checker : *Semantic_Checker, node : *AST_Node, struct_field_
field_not_defined_on_struct(checker, child, struct_symbol); field_not_defined_on_struct(checker, child, struct_symbol);
return 0; return 0;
} }
access := create_variable(checker, child, node); access := check_variable(checker, child, node);
use_scope(checker, previous_scope); use_scope(checker, previous_scope);
return access; return access;
} }
@@ -1188,10 +1188,10 @@ create_variable :: (checker : *Semantic_Checker, node : *AST_Node, struct_field_
} }
can_declare :: (checker : *Semantic_Checker, name : string) -> bool { can_declare :: (checker : *Semantic_Checker, name : string) -> bool {
max_value := Semantic_Type.Max_Builtin; max_value := Type_Kind.Max_Builtin;
for i : 0..max_value - 1 { for i : 0..max_value - 1 {
kind := cast(Semantic_Type)i; kind := cast(Type_Kind)i;
if name == Typenames[kind] { if name == Typenames[kind] {
return false; return false;
} }
@@ -1200,7 +1200,7 @@ can_declare :: (checker : *Semantic_Checker, name : string) -> bool {
} }
//@Incomplete(niels): Handle meta stuff here //@Incomplete(niels): Handle meta stuff here
create_field :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_Handle { check_field :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_Handle {
variable, handle := new_type_variable(checker); variable, handle := new_type_variable(checker);
variable.name = node.name; variable.name = node.name;
typename : string; typename : string;
@@ -1399,15 +1399,15 @@ check_call :: (checker : *Semantic_Checker, node : *AST_Node, type_var : Type_Va
check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_Handle { check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_Handle {
if node.kind == { if node.kind == {
case .Function; { case .Function; {
create_function(checker, node); check_function(checker, node);
return 0; return 0;
} }
case. Field; { case. Field; {
field_var := create_field(checker, node); field_var := check_field(checker, node);
return field_var; return field_var;
} }
case .Unnamed_Field; { case .Unnamed_Field; {
field_var := create_field(checker, node); field_var := check_field(checker, node);
return field_var; return field_var;
} }
case .Unary; { case .Unary; {
@@ -1497,7 +1497,7 @@ check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_H
} }
} }
case .Variable; { case .Variable; {
return create_variable(checker, node); return check_variable(checker, node);
} }
case .Integer; { case .Integer; {
type_variable, handle := new_type_variable(checker); type_variable, handle := new_type_variable(checker);
@@ -1565,22 +1565,6 @@ traverse :: (checker : *Semantic_Checker) {
traverse(checker, checker.program_root); traverse(checker, checker.program_root);
} }
// find :: (checker : *Semantic_Checker, root_handle : Type_Variable_Handle) -> Type_Variable_Handle {
// assert(root_handle > 0);
// root := from_handle(checker, root_handle);
// // if root.uf_parent != root_handle {
// // root.uf_parent = find(checker, root.uf_parent);
// // }
// return root.uf_parent;
// }
Unification_Result :: enum {
Unification_Success;
Unification_Failure;
}
types_compatible :: (checker : *Semantic_Checker, lhs : Type_Variable_Handle, rhs : Type_Variable_Handle, param_matching : bool = false) -> bool { types_compatible :: (checker : *Semantic_Checker, lhs : Type_Variable_Handle, rhs : Type_Variable_Handle, param_matching : bool = false) -> bool {
lhs_var := from_handle(checker, lhs); lhs_var := from_handle(checker, lhs);
rhs_var := from_handle(checker, rhs); rhs_var := from_handle(checker, rhs);
@@ -1662,12 +1646,6 @@ types_compatible :: (checker : *Semantic_Checker, lhs : Type_Variable_Handle, rh
return false; return false;
} }
// HLSL_BUILTIN :: #run -> string {
// T := #load "hlsl_builtin.jai";
// return "";
// };
add_hlsl_builtins :: (checker : *Semantic_Checker) { add_hlsl_builtins :: (checker : *Semantic_Checker) {
source_location := #location().fully_pathed_filename; source_location := #location().fully_pathed_filename;
path_array := split(source_location, "/"); path_array := split(source_location, "/");
@@ -1746,7 +1724,7 @@ check :: (result : *Compile_Result) {
checker.current_sampler_index = 0; checker.current_sampler_index = 0;
checker.current_texture_index = 0; checker.current_texture_index = 0;
checker.result_file = file; checker.result_file = file;
array_reserve(*checker.messages, 16); array_reserve(*checker.messages, 32);
init_semantic_checker(*checker, file.ast_root, file.file.path); init_semantic_checker(*checker, file.ast_root, file.file.path);
@@ -1755,30 +1733,11 @@ check :: (result : *Compile_Result) {
type_check(*checker, file.ast_root); type_check(*checker, file.ast_root);
// file.vertex_entry_point.node = checker.result.vertex_entry_point;
// file.pixel_entry_point.node = checker.result.pixel_entry_point;
result.had_error |= checker.had_error; result.had_error |= checker.had_error;
copy_messages(checker.messages, *result.messages); copy_messages(checker.messages, *result.messages);
} }
} }
// check :: (checker : *Semantic_Checker, root : *AST_Node) -> Semantic_Check_Result {
// checker.current_buffer_index = 0;
// checker.current_sampler_index = 0;
// checker.current_texture_index = 0;
// array_reserve(*checker.messages, 16);
// add_hlsl_builtins(checker);
// type_check(checker, root);
// return checker.result;
// }
// check :: (checker : *Semantic_Checker) -> Semantic_Check_Result {
// return check(checker, checker.program_root);
// }
// =========================================================== // ===========================================================
// Pretty printing // Pretty printing
@@ -1805,7 +1764,6 @@ type_to_string :: (type_variable : Type_Variable) -> string {
case .Array; case .Array;
return "array"; return "array";
} }
return ""; return "";
} }

1
module.jai
View File

@@ -4,7 +4,6 @@
#load "Semantic_Analysis.jai"; #load "Semantic_Analysis.jai";
#load "Codegen.jai"; #load "Codegen.jai";
add_define :: (env : *Environment, key : string) { add_define :: (env : *Environment, key : string) {
for define : env.defines { for define : env.defines {
if define == key { if define == key {