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

Move compile result stuff out of specific stages.

Browse Source
This commit is contained in:
Niels Bross
2025-08-27 21:55:01 +02:00
parent ab711b5610
commit da87209690
8 changed files with 288 additions and 317 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
Codegen.jai
View File

@@ -16,26 +16,26 @@ Output_Language :: enum {
Codegen_State :: struct { Codegen_State :: struct {
path : string; path : string;
scope_stack : Scope_Stack; // scope_stack : Scope_Stack;
current_scope : Scope_Handle; current_scope : Scope_Handle;
type_variables : []Type_Variable; // type_variables : []Type_Variable;
root : *AST_Node; // root : *AST_Node;
output_language : Output_Language; output_language : Output_Language;
builder : String_Builder; builder : String_Builder;
result : Codegen_Result; result : *Compile_Result;
} }
Codegen_Result :: struct { // Codegen_Result :: struct {
messages : [..]Compiler_Message; // messages : [..]Compiler_Message;
had_error : bool; // had_error : bool;
result_text : string; // @Incomplete(nb): Result for now, should likely be far more sophisticated. // result_text : string; // @Incomplete(nb): Result for now, should likely be far more sophisticated.
} // }
Reserved_HLSL_Words :: string.[ Reserved_HLSL_Words :: string.[
"texture", "texture",
@@ -56,10 +56,7 @@ Reserved_GLSL_Words :: string.[
"" ""
]; ];
init_codegen_state :: (state : *Codegen_State, file : *Compiled_File, output_language : Output_Language) { init_codegen_state :: (state : *Codegen_State, result : *Compile_Result, output_language : Output_Language) {
state.root = file.ast_root;
state.scope_stack = file.scope_stack;
state.type_variables = file.type_variables;
state.current_scope = cast(Scope_Handle)1; state.current_scope = cast(Scope_Handle)1;
state.output_language = output_language; state.output_language = output_language;
init_string_builder(*state.builder); init_string_builder(*state.builder);
@@ -105,16 +102,16 @@ hlsl_type_to_string :: (type_variable : Type_Variable) -> string {
} }
emit_field :: (state : *Codegen_State, node : *AST_Node, indentation : int) { emit_field :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
find_result := find_symbol(state.scope_stack, node.name, state.current_scope); find_result := find_symbol(state.result.scope_stack, node.name, state.current_scope);
field := from_handle(state.type_variables, find_result.type_variable); field := from_handle(state.result.type_variables, find_result.type_variable);
indent(state, indentation); indent(state, indentation);
print_to_builder(*state.builder, "% ", hlsl_type_to_string(field)); print_to_builder(*state.builder, "% ", hlsl_type_to_string(field));
if field.struct_field_parent { if field.struct_field_parent {
parent_tv := from_handle(state.type_variables, field.struct_field_parent.type_variable); parent_tv := from_handle(state.result.type_variables, field.struct_field_parent.type_variable);
if parent_tv.typename == "properties" { if parent_tv.typename == "properties" {
append(*state.builder, "__PROPERTIES__"); append(*state.builder, "__PROPERTIES__");
@@ -144,7 +141,7 @@ emit_field :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
for i :0..field.children.count - 1 { for i :0..field.children.count - 1 {
child := from_handle(state.type_variables, field.children[i]); child := from_handle(state.result.type_variables, field.children[i]);
emit_node(state, child.source_node, 0); emit_node(state, child.source_node, 0);
} }
@@ -230,7 +227,7 @@ emit_call :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
} }
emit_properties :: (state : *Codegen_State, node : *AST_Node, indentation : int) { emit_properties :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
find_result := find_symbol(state.scope_stack, ifx node.name.count > 0 then node.name else "properties", state.current_scope); find_result := find_symbol(state.result.scope_stack, ifx node.name.count > 0 then node.name else "properties", state.current_scope);
if !find_result { if !find_result {
message : Compiler_Message; message : Compiler_Message;
@@ -241,7 +238,7 @@ emit_properties :: (state : *Codegen_State, node : *AST_Node, indentation : int)
} }
assert(find_result != null, "Attempting to generate undeclared properties buffer. This should never happen at this stage."); assert(find_result != null, "Attempting to generate undeclared properties buffer. This should never happen at this stage.");
variable := from_handle(state.type_variables, find_result.type_variable); variable := from_handle(state.result.type_variables, find_result.type_variable);
print_to_builder(*state.builder, "cbuffer __PROPERTIES : register(b%) \n{\n", variable.resource_index); print_to_builder(*state.builder, "cbuffer __PROPERTIES : register(b%) \n{\n", variable.resource_index);
@@ -253,7 +250,7 @@ emit_properties :: (state : *Codegen_State, node : *AST_Node, indentation : int)
for child : node.children { for child : node.children {
if child.kind == .FieldList { if child.kind == .FieldList {
for field : child.children { for field : child.children {
tv := from_handle(state.type_variables, field.type_variable); tv := from_handle(state.result.type_variables, field.type_variable);
if tv.type == .Sampler || tv.type == .Texture2D { if tv.type == .Sampler || tv.type == .Texture2D {
array_add(*resources, field); array_add(*resources, field);
continue; continue;
@@ -281,7 +278,7 @@ emit_properties :: (state : *Codegen_State, node : *AST_Node, indentation : int)
emit_function :: (state : *Codegen_State, node : *AST_Node, indentation : int, emit_body := true) { emit_function :: (state : *Codegen_State, node : *AST_Node, indentation : int, emit_body := true) {
name := get_actual_function_name(node); name := get_actual_function_name(node);
find_result := find_symbol(state.scope_stack, name, state.current_scope); find_result := find_symbol(state.result.scope_stack, name, state.current_scope);
assert(find_result != null, "Attempting to generate undeclared function. This should never happen at this stage."); assert(find_result != null, "Attempting to generate undeclared function. This should never happen at this stage.");
if !find_result { if !find_result {
@@ -293,12 +290,12 @@ emit_function :: (state : *Codegen_State, node : *AST_Node, indentation : int, e
} }
for func : find_result.functions { for func : find_result.functions {
function_variable := from_handle(state.type_variables, func.type_variable); function_variable := from_handle(state.result.type_variables, func.type_variable);
indent(state, indentation); indent(state, indentation);
if function_variable.return_type_variable { if function_variable.return_type_variable {
return_variable := from_handle(state.type_variables, function_variable.return_type_variable); return_variable := from_handle(state.result.type_variables, function_variable.return_type_variable);
print_to_builder(*state.builder, "% ", hlsl_type_to_string(return_variable)); print_to_builder(*state.builder, "% ", hlsl_type_to_string(return_variable));
} else { } else {
append(*state.builder, "void "); append(*state.builder, "void ");
@@ -438,12 +435,12 @@ emit_node :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
case .Variable; { case .Variable; {
indent(*state.builder, indentation); indent(*state.builder, indentation);
type_var := from_handle(state.type_variables, node.type_variable); type_var := from_handle(state.result.type_variables, node.type_variable);
is_properties := type_var.typename == "properties"; is_properties := type_var.typename == "properties";
if !is_properties { if !is_properties {
if type_var.struct_field_parent { if type_var.struct_field_parent {
parent_tv := from_handle(state.type_variables, type_var.struct_field_parent.type_variable); parent_tv := from_handle(state.result.type_variables, type_var.struct_field_parent.type_variable);
if parent_tv.typename == "properties" { if parent_tv.typename == "properties" {
append(*state.builder, "__PROPERTIES__"); append(*state.builder, "__PROPERTIES__");
@@ -556,7 +553,7 @@ emit_struct :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
print_to_builder(*state.builder, "struct %", node.name); print_to_builder(*state.builder, "struct %", node.name);
current_scope := state.current_scope; current_scope := state.current_scope;
state.current_scope = from_handle(state.type_variables, node.type_variable).scope; state.current_scope = from_handle(state.result.type_variables, node.type_variable).scope;
field_list := node.children[0]; field_list := node.children[0];
@@ -573,11 +570,11 @@ emit_struct :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
} }
emit_cbuffer :: (state : *Codegen_State, node : *AST_Node, indentation : int) { emit_cbuffer :: (state : *Codegen_State, node : *AST_Node, indentation : int) {
variable := from_handle(state.type_variables, node.type_variable); variable := from_handle(state.result.type_variables, node.type_variable);
print_to_builder(*state.builder, "cbuffer % : register(b%)", variable.name, variable.resource_index); print_to_builder(*state.builder, "cbuffer % : register(b%)", variable.name, variable.resource_index);
current_scope := state.current_scope; current_scope := state.current_scope;
state.current_scope = from_handle(state.type_variables, node.type_variable).scope; state.current_scope = from_handle(state.result.type_variables, node.type_variable).scope;
field_list := node.children[0]; field_list := node.children[0];
@@ -615,21 +612,20 @@ codegen :: (result : *Compile_Result) {
return; return;
} }
for *file : result.files {
state : Codegen_State; state : Codegen_State;
init_codegen_state(*state, file, .HLSL); state.result = result;
state.current_scope = cast(Scope_Handle)1;
state.output_language = .HLSL;
init_string_builder(*state.builder);
codegen_result := codegen(*state); codegen(*state);
file.codegen_result_text = copy_string(codegen_result.result_text);
}
} }
codegen :: (state : *Codegen_State) -> Codegen_Result { codegen :: (state : *Codegen_State) {
found_function : bool = false; found_function : bool = false;
// found_struct : bool = false; // found_struct : bool = false;
// for variable : state.type_variables { // for variable : state.result.type_variables {
// if variable.type == .Struct && variable.kind == .Declaration && !variable.builtin { // if variable.type == .Struct && variable.kind == .Declaration && !variable.builtin {
// if variable.source_node.kind == .Properties continue; // if variable.source_node.kind == .Properties continue;
// if variable.source_node.kind == .Meta continue; // if variable.source_node.kind == .Meta continue;
@@ -642,7 +638,7 @@ codegen :: (state : *Codegen_State) -> Codegen_Result {
// append(*state.builder, "\n"); // append(*state.builder, "\n");
// } // }
for variable : state.type_variables { for variable : state.result.type_variables {
if variable.type == .Function && !variable.builtin if variable.type == .Function && !variable.builtin
&& !variable.source_node.vertex_entry_point && !variable.source_node.pixel_entry_point { && !variable.source_node.vertex_entry_point && !variable.source_node.pixel_entry_point {
emit_function(state, variable.source_node, 0, false); emit_function(state, variable.source_node, 0, false);
@@ -653,22 +649,24 @@ codegen :: (state : *Codegen_State) -> Codegen_Result {
append(*state.builder, "\n"); append(*state.builder, "\n");
} }
for declaration : state.root.children { for declaration : state.result.root.children {
if declaration.foreign_declaration { if declaration.foreign_declaration {
continue; continue;
} }
emit_declaration(state, declaration); emit_declaration(state, declaration);
} }
state.result.result_text = builder_to_string(*state.builder); state.result.codegen_result_text = builder_to_string(*state.builder);
return state.result;
} }
codegen :: (file : *Compiled_File, output_language : Output_Language) -> Codegen_Result { codegen :: (result : *Compile_Result, output_language : Output_Language) {
codegen_state : Codegen_State; codegen_state : Codegen_State;
init_codegen_state(*codegen_state, file, output_language); codegen_state.result = result;
return codegen(*codegen_state); codegen_state.current_scope = cast(Scope_Handle)1;
codegen_state.output_language = output_language;
init_string_builder(*codegen_state.builder);
codegen(*codegen_state);
} }
#scope_module #scope_module

9
Lexing.jai
View File

@@ -367,6 +367,7 @@ make_token :: (lexer : *Lexer, token_kind : Token_Kind) -> *Token {
skip_whitespace :: (lexer : *Lexer) { skip_whitespace :: (lexer : *Lexer) {
while true { while true {
if is_at_end(lexer) return;
c := peek_char(lexer); c := peek_char(lexer);
if c == { if c == {
@@ -506,21 +507,19 @@ lex :: (result : *Compile_Result) {
return; return;
} }
for *file : result.files {
lexer : Lexer; lexer : Lexer;
init_lexer_from_string(*lexer, file.file.source); init_lexer_from_string(*lexer, result.file.source);
lexer.path = file.file.path; lexer.path = result.file.path;
token : *Token = scan_next_token(*lexer); token : *Token = scan_next_token(*lexer);
while token && token.kind != .TOKEN_EOF { while token && token.kind != .TOKEN_EOF {
token = scan_next_token(*lexer); token = scan_next_token(*lexer);
} }
array_copy(*file.tokens.tokens, lexer.result.tokens); array_copy(*result.tokens.tokens, lexer.result.tokens);
result.had_error |= lexer.result.had_error; result.had_error |= lexer.result.had_error;
// @Incomplete(nb): Temporary until we figure out a good way of passing this stuff around // @Incomplete(nb): Temporary until we figure out a good way of passing this stuff around
copy_messages(lexer.result.messages, *result.messages); copy_messages(lexer.result.messages, *result.messages);
}
} }
lex :: (lexer : *Lexer, allocator : Allocator = context.allocator) -> Lexing_Result { lex :: (lexer : *Lexer, allocator : Allocator = context.allocator) -> Lexing_Result {

93
Parsing.jai
View File

@@ -11,33 +11,22 @@
Parse_State :: struct { Parse_State :: struct {
current : *Token; current : *Token;
previous : *Token; previous : *Token;
tokens : [..]Token;
current_token_index : int; current_token_index : int;
node_allocator : Allocator; result : *Compile_Result;
node_arena : Arena;
child_allocator : Allocator;
child_arena : Arena;
// had_error : bool;
path : string;
result : Parse_Result;
} }
//////////////////////////// ////////////////////////////
//@nb - Result and error handling //@nb - Result and error handling
Parse_Result :: struct { // Parse_Result :: struct {
root : *AST_Node; // root : *AST_Node;
nodes : [..]AST_Node; // nodes : [..]AST_Node;
had_error : bool; // had_error : bool;
messages : [..]Compiler_Message; // messages : [..]Compiler_Message;
} // }
Parse_Error_Kind :: enum { Parse_Error_Kind :: enum {
Parse_Error_Type_Missing; Parse_Error_Type_Missing;
@@ -129,16 +118,6 @@ parse_rules :: #run -> [(cast(int)Token_Kind.TOKEN_ERROR) + 1]Parse_Rule {
return rules; return rules;
} }
init_parse_state :: (parse_state : *Parse_State, tokens : [..]Token, path : string) {
parse_state.tokens = tokens;
parse_state.path = path;
parse_state.node_allocator = make_arena(*parse_state.node_arena);
parse_state.child_allocator = make_arena(*parse_state.child_arena);
parse_state.result.nodes.allocator = parse_state.node_allocator;
array_reserve(*parse_state.result.nodes, 4096);
parse_state.current_token_index = 0;
}
//////////////////////////// ////////////////////////////
//@nb - Error handling functions //@nb - Error handling functions
@@ -147,7 +126,7 @@ record_error :: (parse_state : *Parse_State, token : Token, message : string, re
error : Compiler_Message; error : Compiler_Message;
error.message_kind = .Error; error.message_kind = .Error;
error.message = message; error.message = message;
error.path = parse_state.path; error.path = parse_state.result.file.path;
source_location : Source_Range; source_location : Source_Range;
source_location.begin = token; source_location.begin = token;
@@ -357,7 +336,7 @@ make_node :: (parse_state : *Parse_State, kind : AST_Kind) -> *AST_Node {
node : AST_Node; node : AST_Node;
node.kind = kind; node.kind = kind;
node.children.allocator = parse_state.child_allocator; node.children.allocator = parse_state.result.allocator;
array_add(*parse_state.result.nodes, node); array_add(*parse_state.result.nodes, node);
return *parse_state.result.nodes[parse_state.result.nodes.count - 1]; return *parse_state.result.nodes[parse_state.result.nodes.count - 1];
@@ -393,10 +372,10 @@ advance :: (parse_state : *Parse_State) {
parse_state.previous = parse_state.current; parse_state.previous = parse_state.current;
while true { while true {
if parse_state.current_token_index >= parse_state.tokens.count { if parse_state.current_token_index >= parse_state.result.tokens.tokens.count {
break; break;
} }
parse_state.current = *parse_state.tokens[parse_state.current_token_index]; parse_state.current = *parse_state.result.tokens.tokens[parse_state.current_token_index];
parse_state.current_token_index += 1; parse_state.current_token_index += 1;
if parse_state.current.kind != .TOKEN_ERROR break; if parse_state.current.kind != .TOKEN_ERROR break;
@@ -429,7 +408,7 @@ check_any :: (parse_state : *Parse_State, kinds : ..Token_Kind) -> bool {
//nb - Checks if the next token is of a certain kind //nb - Checks if the next token is of a certain kind
check_next :: (parse_state : *Parse_State, kind : Token_Kind) -> bool { check_next :: (parse_state : *Parse_State, kind : Token_Kind) -> bool {
return parse_state.tokens[parse_state.current_token_index].kind == kind; return parse_state.result.tokens.tokens[parse_state.current_token_index].kind == kind;
} }
//nb - Consume a token if //nb - Consume a token if
@@ -440,8 +419,13 @@ consume :: (parse_state : *Parse_State, kind : Token_Kind, message : string) {
} }
token := parse_state.previous; token := parse_state.previous;
advance(parse_state); advance_to_sync_point(parse_state);
unexpected_token(parse_state, token, message); unexpected_token(parse_state, token, message);
if parse_state.current.kind == .TOKEN_EOF {
return;
}
consume(parse_state, kind, message); consume(parse_state, kind, message);
} }
@@ -540,8 +524,8 @@ binary :: (parse_state : *Parse_State, left : *AST_Node) -> *AST_Node {
} }
array_access :: (parse_state : *Parse_State, left : *AST_Node) -> *AST_Node { array_access :: (parse_state : *Parse_State, left : *AST_Node) -> *AST_Node {
identifier := parse_state.tokens[parse_state.current_token_index - 3]; identifier := parse_state.result.tokens.tokens[parse_state.current_token_index - 3];
left_bracket := parse_state.tokens[parse_state.current_token_index - 2]; left_bracket := parse_state.result.tokens.tokens[parse_state.current_token_index - 2];
array_access := make_node(parse_state, .Unary); array_access := make_node(parse_state, .Unary);
array_access.token = left_bracket; array_access.token = left_bracket;
@@ -749,7 +733,7 @@ field_declaration :: (parse_state : *Parse_State, identifier_token : *Token) ->
node.array_field = true; node.array_field = true;
} else { } else {
if !check(parse_state, .TOKEN_ASSIGN) { if !check(parse_state, .TOKEN_ASSIGN) {
internal_error_message(*parse_state.result.messages, "Unimplemented error message.", parse_state.path); internal_error_message(*parse_state.result.messages, "Unimplemented error message.", parse_state.result.file.path);
return node; return node;
} }
// missing_type_specifier(parse_state, identifier_token, "Expected type specifier after field name."); // missing_type_specifier(parse_state, identifier_token, "Expected type specifier after field name.");
@@ -1227,9 +1211,12 @@ parse :: (result : *Compile_Result) {
return; return;
} }
for *file : result.files {
parse_state : Parse_State; parse_state : Parse_State;
init_parse_state(*parse_state, file.tokens.tokens, file.file.path); result.nodes.allocator = result.allocator;
array_reserve(*result.nodes, 4096);
parse_state.current_token_index = 0;
parse_state.result = result;
advance(*parse_state); advance(*parse_state);
if !match(*parse_state, .TOKEN_EOF) { if !match(*parse_state, .TOKEN_EOF) {
@@ -1244,34 +1231,6 @@ parse :: (result : *Compile_Result) {
} }
} }
} }
//@Incomplete(nb): will this straight copy just work?
// Might need to rething how we do this.
file.ast_root = parse_state.result.root;
file.ast_nodes = parse_state.result.nodes;
copy_messages(parse_state.result.messages, *result.messages);
result.had_error |= parse_state.result.had_error;
}
}
parse :: (parse_state : *Parse_State) -> Parse_Result {
advance(parse_state);
if !match(parse_state, .TOKEN_EOF) {
parse_state.result.root = make_node(parse_state, .Program);
array_reserve(*parse_state.result.root.children, 1024);
program := parse_state.result.root;
while !check(parse_state, .TOKEN_EOF) {
decl := declaration(parse_state);
if decl {
add_child(program, decl);
}
}
}
return parse_state.result;
} }
#load "AST.jai"; #load "AST.jai";

131
Semantic_Analysis.jai
View File

@@ -140,7 +140,7 @@ Semantic_Checker :: struct {
current_scope : Scope_Handle; current_scope : Scope_Handle;
result_file : *Compiled_File; result : *Compile_Result;
current_buffer_index : u32 = 0; current_buffer_index : u32 = 0;
current_sampler_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); init_string_builder(*builder,, temp);
variable := from_handle(checker, handle); 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_file.type_variables, variable)); print_to_builder(*builder, "Attempting to access a field on a primitive type '%'.\n", proper_type_to_string(checker.result.type_variables, variable));
indent(*builder, 1); indent(*builder, 1);
cyan(*builder); 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_child := usage_site.children[0];
usage_loc := usage_child.source_location; 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_file.type_variables, var)); print_to_builder(*builder, "% has type %\n", print_from_source_location(*usage_loc), proper_type_to_string(checker.result.type_variables, var));
message := builder_to_string(*builder,, temp); message := builder_to_string(*builder,, temp);
record_error(checker, message, usage_site.source_location, false); 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); indent(*builder, 1);
print_to_builder(*builder, "expected:\n"); print_to_builder(*builder, "expected:\n");
indent(*builder, 2); indent(*builder, 2);
proper_type_to_string(*builder, checker.result_file.type_variables, expect_var); proper_type_to_string(*builder, checker.result.type_variables, expect_var);
append(*builder, "\n"); append(*builder, "\n");
// indent(*builder, 2); // indent(*builder, 2);
@@ -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 { push_scope :: (checker : *Semantic_Checker, name := "", kind : Scope_Kind = .Global) -> *Scope, Scope_Handle {
new_scope : Scope; new_scope : Scope;
array_add(*checker.result_file.scope_stack.stack, new_scope); array_add(*checker.result.scope_stack.stack, new_scope);
count := checker.result_file.scope_stack.stack.count; count := checker.result.scope_stack.stack.count;
scope := *checker.result_file.scope_stack.stack[count - 1]; scope := *checker.result.scope_stack.stack[count - 1];
scope.parent = checker.current_scope; scope.parent = checker.current_scope;
scope.name = name; scope.name = name;
scope.kind = kind; scope.kind = kind;
@@ -628,7 +628,7 @@ push_scope :: (checker : *Semantic_Checker, name := "", kind : Scope_Kind = .Glo
scope.builtin = true; scope.builtin = true;
} }
scope.children.allocator = checker.result_file.scope_stack.allocator; scope.children.allocator = checker.result.scope_stack.allocator;
if checker.current_scope { if checker.current_scope {
scope := get_current_scope(checker); scope := get_current_scope(checker);
@@ -651,12 +651,12 @@ pop_scope :: (checker : *Semantic_Checker) -> Scope_Handle {
} }
peek_scope :: (checker : *Semantic_Checker) -> *Scope, Scope_Handle { peek_scope :: (checker : *Semantic_Checker) -> *Scope, Scope_Handle {
if checker.result_file.scope_stack.stack.count == 0 { if checker.result.scope_stack.stack.count == 0 {
return null, 0; return null, 0;
} }
count := checker.result_file.scope_stack.stack.count; count := checker.result.scope_stack.stack.count;
scope := *checker.result_file.scope_stack.stack[count - 1]; scope := *checker.result.scope_stack.stack[count - 1];
return scope, xx count; return scope, xx count;
} }
@@ -673,7 +673,7 @@ get_scope :: (scope_stack : Scope_Stack, handle : Scope_Handle) -> *Scope {
} }
get_scope :: (checker : *Semantic_Checker, handle : Scope_Handle) -> *Scope { get_scope :: (checker : *Semantic_Checker, handle : Scope_Handle) -> *Scope {
return get_scope(*checker.result_file.scope_stack, handle); return get_scope(*checker.result.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 { add_symbol_to_scope :: (state : Checker_State, scope_stack : *Scope_Stack, scope_handle : Scope_Handle, name : string, symbol : Defined_Symbol) -> *Defined_Symbol {
@@ -695,8 +695,8 @@ add_symbol_to_scope :: (state : Checker_State, scope_stack : *Scope_Stack, scope
new_type_variable :: (checker : *Semantic_Checker) -> *Type_Variable, Type_Variable_Handle { new_type_variable :: (checker : *Semantic_Checker) -> *Type_Variable, Type_Variable_Handle {
variable : Type_Variable; variable : Type_Variable;
handle := cast(Type_Variable_Handle)checker.result_file.type_variables.count + 1; handle := cast(Type_Variable_Handle)checker.result.type_variables.count + 1;
array_add(*checker.result_file.type_variables, variable); array_add(*checker.result.type_variables, variable);
return from_handle(checker, handle), handle; return from_handle(checker, handle), handle;
} }
@@ -725,10 +725,10 @@ init_semantic_checker :: (checker : *Semantic_Checker, root : *AST_Node, path :
checker.path = path; checker.path = path;
// @Incomplete(niels): Use other allocator and/or add static array with convenience functions // @Incomplete(niels): Use other allocator and/or add static array with convenience functions
array_reserve(*checker.result_file.type_variables, 2048); array_reserve(*checker.result.type_variables, 2048);
checker.result_file.scope_stack.allocator = make_arena(*checker.result_file.scope_stack.arena); checker.result.scope_stack.allocator = make_arena(*checker.result.scope_stack.arena);
array_reserve(*checker.result_file.scope_stack.stack, 256); array_reserve(*checker.result.scope_stack.stack, 256);
global_scope, global_handle := push_scope(checker, kind = .Global); global_scope, global_handle := push_scope(checker, kind = .Global);
array_reserve(*global_scope.children, 2048); array_reserve(*global_scope.children, 2048);
@@ -754,7 +754,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 { find_symbol :: (checker : *Semantic_Checker, name : string, current_scope : Scope_Handle, containing_scope : *Scope_Handle = null) -> *Defined_Symbol {
return find_symbol(checker.result_file.scope_stack, name, current_scope, containing_scope); return find_symbol(checker.result.scope_stack, name, current_scope, containing_scope);
} }
find_symbol :: (name : string, checker : *Semantic_Checker, containing_scope : *Scope_Handle = null) -> *Defined_Symbol { find_symbol :: (name : string, checker : *Semantic_Checker, containing_scope : *Scope_Handle = null) -> *Defined_Symbol {
@@ -767,7 +767,7 @@ from_handle :: (variables : []Type_Variable, handle : Type_Variable_Handle) -> *
} }
from_handle :: (checker : *Semantic_Checker, handle : Type_Variable_Handle) -> *Type_Variable { from_handle :: (checker : *Semantic_Checker, handle : Type_Variable_Handle) -> *Type_Variable {
return from_handle(checker.result_file.type_variables, handle); return from_handle(checker.result.type_variables, handle);
} }
proper_type_to_string :: (builder : *String_Builder, variables : []Type_Variable, var : Type_Variable) { proper_type_to_string :: (builder : *String_Builder, variables : []Type_Variable, var : Type_Variable) {
@@ -843,7 +843,6 @@ proper_type_to_string :: (variables : []Type_Variable, var : Type_Variable, allo
return "______not proper type______"; return "______not proper type______";
} }
get_type_from_identifier :: (checker : *Semantic_Checker, scope : Scope_Handle, node : *AST_Node, typename : *string = null) -> Type_Kind { 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;
@@ -872,10 +871,6 @@ get_type_from_identifier :: (checker : *Semantic_Checker, scope : Scope_Handle,
return .Invalid; return .Invalid;
} }
check_expression :: (node : *AST_Node, checker : *Semantic_Checker) -> Type_Variable_Handle {
return 0;
}
check_block :: (checker : *Semantic_Checker, node : *AST_Node) { check_block :: (checker : *Semantic_Checker, node : *AST_Node) {
for child : node.children { for child : node.children {
check_node(checker, child); check_node(checker, child);
@@ -898,7 +893,7 @@ declare_struct :: (checker : *Semantic_Checker, node : *AST_Node, name : string)
symbol.name = name; symbol.name = name;
symbol.source_node = node; symbol.source_node = node;
symbol.type_variable = handle; symbol.type_variable = handle;
add_symbol_to_scope(checker.state, *checker.result_file.scope_stack, checker.current_scope, name, symbol); add_symbol_to_scope(checker.state, *checker.result.scope_stack, checker.current_scope, name, symbol);
} else { } else {
symbol_redeclaration(checker, node, find_result); symbol_redeclaration(checker, node, find_result);
return 0; return 0;
@@ -933,7 +928,7 @@ declare_properties :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Va
name := ifx node.name.count == 0 then "properties" else node.name; name := ifx node.name.count == 0 then "properties" else node.name;
if node.name.count > 0 { if node.name.count > 0 {
checker.result_file.property_name = name; checker.result.property_name = name;
} }
type_var := declare_struct(checker, node, name); type_var := declare_struct(checker, node, name);
var := from_handle(checker, type_var); var := from_handle(checker, type_var);
@@ -950,7 +945,7 @@ declare_cbuffer :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Varia
var.type = .CBuffer; var.type = .CBuffer;
var.resource_index = checker.current_buffer_index; var.resource_index = checker.current_buffer_index;
checker.current_buffer_index += 1; checker.current_buffer_index += 1;
array_add(*checker.result_file.constant_buffers, type_var); array_add(*checker.result.constant_buffers, type_var);
return type_var; return type_var;
} }
@@ -986,11 +981,11 @@ declare_function :: (checker : *Semantic_Checker, node : *AST_Node, builtin : bo
name_to_check := get_actual_function_name(node); name_to_check := get_actual_function_name(node);
if node.vertex_entry_point { if node.vertex_entry_point {
checker.result_file.vertex_entry_point.node = node; checker.result.vertex_entry_point.node = node;
} }
if node.pixel_entry_point { if node.pixel_entry_point {
checker.result_file.pixel_entry_point.node = node; checker.result.pixel_entry_point.node = node;
} }
find_result := find_symbol(checker, name_to_check, checker.current_scope); find_result := find_symbol(checker, name_to_check, checker.current_scope);
@@ -1007,7 +1002,7 @@ declare_function :: (checker : *Semantic_Checker, node : *AST_Node, builtin : bo
array_reserve(*symbol.functions, 32); array_reserve(*symbol.functions, 32);
array_add(*symbol.functions, function); array_add(*symbol.functions, function);
add_symbol_to_scope(checker.state, *checker.result_file.scope_stack, checker.current_scope, name_to_check, symbol); add_symbol_to_scope(checker.state, *checker.result.scope_stack, checker.current_scope, name_to_check, symbol);
} else { } else {
//@Note(niels): This is some ugly code, but it's probably fine for now. //@Note(niels): This is some ugly code, but it's probably fine for now.
field_list := node.children[0]; field_list := node.children[0];
@@ -1244,7 +1239,7 @@ check_field :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_
symbol.name = node.name; symbol.name = node.name;
symbol.source_node = node; symbol.source_node = node;
symbol.type_variable = handle; symbol.type_variable = handle;
add_symbol_to_scope(checker.state, *checker.result_file.scope_stack, checker.current_scope, node.name, symbol); add_symbol_to_scope(checker.state, *checker.result.scope_stack, checker.current_scope, node.name, symbol);
} else { } else {
symbol_redeclaration(checker, node, find_result); symbol_redeclaration(checker, node, find_result);
return 0; return 0;
@@ -1672,7 +1667,7 @@ types_compatible :: (checker : *Semantic_Checker, lhs : Type_Variable_Handle, rh
// //~ Functions // //~ Functions
// } // }
add_hlsl_builtins :: (checker : *Semantic_Checker) { add_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, "/");
@@ -1682,11 +1677,11 @@ add_hlsl_builtins :: (checker : *Semantic_Checker) {
append(*sb, "/"); append(*sb, "/");
} }
append(*sb, "hlsl_builtin.ink"); append(*sb, "builtins.ink");
path := builder_to_string(*sb); path := builder_to_string(*sb);
HLSL_BUILTIN, ok := read_entire_file(path); BUILTIN, ok := read_entire_file(path);
if !ok { if !ok {
messages : [..]Compiler_Message; messages : [..]Compiler_Message;
@@ -1698,36 +1693,36 @@ add_hlsl_builtins :: (checker : *Semantic_Checker) {
checker.state = .Adding_Builtins; checker.state = .Adding_Builtins;
add_file_from_string(checker.result, BUILTIN);
lexer : Lexer; lexer : Lexer;
init_lexer_from_string(*lexer, HLSL_BUILTIN); lex(checker.result);
if lexer.result.had_error { parse(checker.result);
print("%\n", report_messages(lexer.result.messages)); type_check(checker, checker.result.root);
return;
}
lex_result := lex(*lexer,, *temp); // lex_result := lex(*lexer,, *temp);
if lex_result.had_error { // if lex_result.had_error {
print("%\n", report_messages(lex_result.messages)); // print("%\n", report_messages(lex_result.messages));
return; // return;
} // }
parse_state : Parse_State; // parse_state : Parse_State;
init_parse_state(*parse_state, lex_result.tokens, lexer.path); // init_parse_state(*parse_state, lex_result.tokens, lexer.path);
parse_result := parse(*parse_state); // parse_result := parse(*parse_state);
if parse_result.had_error { // if parse_result.had_error {
print("%\n", report_messages(parse_result.messages)); // print("%\n", report_messages(parse_result.messages));
return; // return;
} // }
type_check(checker, parse_result.root); // type_check(checker, parse_result.root);
if checker.had_error { // if checker.had_error {
print("%\n", report_messages(checker.messages)); // print("%\n", report_messages(checker.messages));
return; // return;
} // }
for *type_var : checker.result_file.type_variables { for *type_var : checker.result.type_variables {
type_var.builtin = true; type_var.builtin = true;
} }
@@ -1743,25 +1738,28 @@ check :: (result : *Compile_Result) {
return; return;
} }
for *file : result.files {
checker : Semantic_Checker; checker : Semantic_Checker;
checker.current_buffer_index = 0; checker.current_buffer_index = 0;
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 = result;
file := result.file;
root := result.root;
array_reserve(*checker.messages, 32); array_reserve(*checker.messages, 32);
init_semantic_checker(*checker, file.ast_root, file.file.path); init_semantic_checker(*checker, result.root, result.file.path);
// @Performance: Should have this built in stuff done earlier and only once // @Performance: Should have this built in stuff done earlier and only once
add_hlsl_builtins(*checker); add_builtins(*checker);
checker.result.file = file;
type_check(*checker, file.ast_root); result.root = root;
type_check(*checker, result.root);
result.had_error |= checker.had_error; result.had_error |= checker.had_error;
copy_messages(checker.messages, *result.messages); copy_messages(checker.messages, *result.messages);
}
} }
// =========================================================== // ===========================================================
@@ -2040,7 +2038,7 @@ pretty_print_symbol_table :: (checker : *Semantic_Checker, allocator : Allocator
builder : String_Builder; builder : String_Builder;
init_string_builder(*builder,, allocator); init_string_builder(*builder,, allocator);
pretty_print_scope(xx checker.current_scope, checker.result_file.scope_stack, checker.result_file.type_variables, *checker.result_file.scope_stack.stack[0], *builder); pretty_print_scope(xx checker.current_scope, checker.result.scope_stack, checker.result.type_variables, *checker.result.scope_stack.stack[0], *builder);
return builder_to_string(*builder,, allocator); return builder_to_string(*builder,, allocator);
} }
@@ -2049,11 +2047,8 @@ pretty_print_symbol_table :: (result : *Compile_Result, allocator : Allocator) -
builder : String_Builder; builder : String_Builder;
init_string_builder(*builder,, allocator); init_string_builder(*builder,, allocator);
for *file : result.files {
current_scope := cast(Scope_Handle)1; current_scope := cast(Scope_Handle)1;
pretty_print_scope(current_scope, file.scope_stack, file.type_variables, *file.scope_stack.stack[0], *builder); pretty_print_scope(current_scope, result.scope_stack, result.type_variables, *result.scope_stack.stack[0], *builder);
}
return builder_to_string(*builder,, allocator); return builder_to_string(*builder,, allocator);

63
Test.jai
View File

@@ -174,7 +174,7 @@ run_codegen_test :: (file_path : string, result : *Compile_Result, output_type :
run_codegen_test :: (result : *Compile_Result, output_type : Output_Type = 0) -> Result { run_codegen_test :: (result : *Compile_Result, output_type : Output_Type = 0) -> Result {
result_data : Result; result_data : Result;
result_data.path = result.files[0].file.path; result_data.path = result.file.path;
result_text : string; result_text : string;
codegen(result); codegen(result);
@@ -185,7 +185,7 @@ run_codegen_test :: (result : *Compile_Result, output_type : Output_Type = 0) ->
return result_data; return result_data;
} }
result_text = result.files[0].codegen_result_text; result_text = result.codegen_result_text;
if output_type & .StdOut { if output_type & .StdOut {
result_data.info_text = result_text; result_data.info_text = result_text;
@@ -193,7 +193,7 @@ run_codegen_test :: (result : *Compile_Result, output_type : Output_Type = 0) ->
return result_data; return result_data;
} }
golden_path := get_golden_path(result.files[0].file.path, .Codegen); golden_path := get_golden_path(result.file.path, .Codegen);
do_golden_comparison(golden_path, result_text, *result_data, output_type); do_golden_comparison(golden_path, result_text, *result_data, output_type);
return result_data; return result_data;
} }
@@ -225,7 +225,7 @@ run_lexer_test :: (file_path : string, result : *Compile_Result, output_type : O
result_data.type = .Failed; result_data.type = .Failed;
result_text = report_messages(result.messages); result_text = report_messages(result.messages);
} else { } else {
result_text = pretty_print_tokens(result.files[0].tokens.tokens, *temp); result_text = pretty_print_tokens(result.tokens.tokens, *temp);
} }
if output_type & .StdOut { if output_type & .StdOut {
@@ -259,14 +259,14 @@ run_parser_test :: (file_path : string, result : *Compile_Result, output_type :
run_parser_test :: (result : *Compile_Result, output_type : Output_Type = 0) -> Result { run_parser_test :: (result : *Compile_Result, output_type : Output_Type = 0) -> Result {
parse(result); parse(result);
result_data : Result; result_data : Result;
result_data.path = result.files[0].file.path; result_data.path = result.file.path;
result_text : string; result_text : string;
if result.had_error { if result.had_error {
result_data.type = .Failed; result_data.type = .Failed;
result_text = report_messages(result.messages,, temp); result_text = report_messages(result.messages,, temp);
} else { } else {
result_text = pretty_print_ast(result.files[0].ast_root, *temp); result_text = pretty_print_ast(result.root, *temp);
} }
if output_type & .StdOut { if output_type & .StdOut {
@@ -275,14 +275,14 @@ run_parser_test :: (result : *Compile_Result, output_type : Output_Type = 0) ->
return result_data; return result_data;
} }
golden_path := get_golden_path(result.files[0].file.path, .Parser); golden_path := get_golden_path(result.file.path, .Parser);
do_golden_comparison(golden_path, result_text, *result_data, output_type); do_golden_comparison(golden_path, result_text, *result_data, output_type);
return result_data; return result_data;
} }
run_semantic_analysis_test :: (result : *Compile_Result, output_type : Output_Type = 0) -> Result { run_semantic_analysis_test :: (result : *Compile_Result, output_type : Output_Type = 0) -> Result {
result_data : Result; result_data : Result;
result_data.path = result.files[0].file.path; result_data.path = result.file.path;
result_text : string; result_text : string;
check(result); check(result);
@@ -300,7 +300,7 @@ run_semantic_analysis_test :: (result : *Compile_Result, output_type : Output_Ty
return result_data; return result_data;
} }
golden_path := get_golden_path(result.files[0].file.path, .Semantic_Analysis); golden_path := get_golden_path(result.file.path, .Semantic_Analysis);
do_golden_comparison(golden_path, result_text, *result_data, output_type); do_golden_comparison(golden_path, result_text, *result_data, output_type);
return result_data; return result_data;
} }
@@ -318,7 +318,7 @@ run_semantic_analysis_test :: (file_path : string, result : *Compile_Result, out
return result_data; return result_data;
} }
result_data = run_semantic_analysis_test(result, output_type);; result_data = run_semantic_analysis_test(result, output_type);
return result_data; return result_data;
} }
@@ -334,6 +334,7 @@ make_test_case :: (path : string, stage_flags : Stage_Flags, allocator := contex
run_test_new :: (file_path : string, stage_flags : Stage_Flags, results : *[..]Result, output_type : Output_Type = 0) { run_test_new :: (file_path : string, stage_flags : Stage_Flags, results : *[..]Result, output_type : Output_Type = 0) {
compile_result : Compile_Result; compile_result : Compile_Result;
add_file(*compile_result, file_path);
result : Result; result : Result;
if stage_flags & .Lexer { if stage_flags & .Lexer {
result = run_lexer_test(file_path, *compile_result, output_type); result = run_lexer_test(file_path, *compile_result, output_type);
@@ -372,8 +373,8 @@ run_test_new :: (file_path : string, stage_flags : Stage_Flags, results : *[..]R
} }
} }
run_test :: (test_case : Test_Case, results : *[..]Result, output_type : Output_Type = 0, builder : *String_Builder) { run_test :: (test_case : Test_Case, results : *[..]Result, output_type : Output_Type = 0) {
print_to_builder(builder, "%Running test: %......", cyan(), test_case.path); print("%Running test: %......", cyan(), test_case.path);
// path 30 // path 30
// len 35 // len 35
@@ -387,7 +388,7 @@ run_test :: (test_case : Test_Case, results : *[..]Result, output_type : Output_
len := 50; len := 50;
rest := len - test_case.path.count; rest := len - test_case.path.count;
for i: 0..rest { for i: 0..rest {
append(builder, " "); print(" ");
} }
run_test_new(test_case.path, test_case.stage_flags, results, output_type); run_test_new(test_case.path, test_case.stage_flags, results, output_type);
@@ -416,7 +417,7 @@ run_test_suite :: (using suite : *Test_Suite, output_type : Output_Type = 0) {
init_string_builder(*builder,, temp); init_string_builder(*builder,, temp);
for test_case : test_cases { for test_case : test_cases {
run_test(test_case, *suite.results, output_type, *builder); run_test(test_case, *suite.results, output_type);
for < suite.results { for < suite.results {
result := suite.results[it_index]; result := suite.results[it_index];
@@ -432,7 +433,7 @@ run_test_suite :: (using suite : *Test_Suite, output_type : Output_Type = 0) {
array_add(*failed_test_paths, .{ result.path, tprint("golden file not found for %", stage_to_string(result.stage)) }); array_add(*failed_test_paths, .{ result.path, tprint("golden file not found for %", stage_to_string(result.stage)) });
} }
} }
evaluate_result(result, *builder); evaluate_result(result);
} else { } else {
break; break;
} }
@@ -530,42 +531,42 @@ stage_to_string :: (stage : Stage_Flags) -> string {
} }
} }
evaluate_result :: (result : Result, builder : *String_Builder) { evaluate_result :: (result : Result) {
stage : string = stage_to_string(result.stage); stage : string = stage_to_string(result.stage);
if #complete result.type == { if #complete result.type == {
case .File_Read_Failed; { case .File_Read_Failed; {
print_to_builder(builder, " %", red()); print(" %", red());
print_to_builder(builder, "failed with File_Read_Failed\n"); print("failed with File_Read_Failed\n");
} }
case .Golden_File_Not_Found; { case .Golden_File_Not_Found; {
print_to_builder(builder, " %", red()); print(" %", red());
print_to_builder(builder, "failed with Golden File Not Found for stage %\n", stage); print("failed with Golden File Not Found for stage %\n", stage);
} }
case .StdOut; { case .StdOut; {
} }
case .Golden_Output; { case .Golden_Output; {
print_to_builder(builder, " %", yellow()); print(" %", yellow());
print_to_builder(builder, "output new golden file at %\n", result.golden_path); print("output new golden file at %\n", result.golden_path);
} }
case .Passed; { case .Passed; {
print_to_builder(builder, " %", green()); print(" %", green());
print_to_builder(builder, "passed %\n", stage); print("passed %\n", stage);
} }
case .Failed; { case .Failed; {
print_to_builder(builder, " %", red()); print(" %", red());
print_to_builder(builder, "failed %\n", stage); print("failed %\n", stage);
} }
} }
if result.info_text.count > 0 { if result.info_text.count > 0 {
print_to_builder(builder, "%", cyan()); print("%", cyan());
print_to_builder(builder, "--- Info text ---\n"); print("--- Info text ---\n");
print_to_builder(builder, "%", yellow()); print("%", yellow());
print_to_builder(builder, "%\n", result.info_text); print("%\n", result.info_text);
} }
print_to_builder(builder, "%", reset_color()); print("%", reset_color());
} }
main :: () { main :: () {

0
hlsl_builtin.ink → builtins.ink
View File

96
module.jai
View File

@@ -140,11 +140,17 @@ Token_Stream :: struct {
tokens : [..]Token; tokens : [..]Token;
} }
Compiled_File :: struct { // Compiled_File :: struct {
// allocator : Allocator;
// arena : Arena;
// }
Compile_Result :: struct {
file : Input_File; file : Input_File;
tokens : Token_Stream; tokens : Token_Stream;
ast_root : *AST_Node; root : *AST_Node;
ast_nodes : [..]AST_Node; nodes : [..]AST_Node;
codegen_result_text : string; codegen_result_text : string;
@@ -172,12 +178,6 @@ Compiled_File :: struct {
max_constant_buffers :: 16; max_constant_buffers :: 16;
cbuffers : Static_Array(Constant_Buffer, max_constant_buffers); cbuffers : Static_Array(Constant_Buffer, max_constant_buffers);
allocator : Allocator;
arena : Arena;
}
Compile_Result :: struct {
files : [..]Compiled_File;
had_error : bool; had_error : bool;
messages : [..]Compiler_Message; messages : [..]Compiler_Message;
@@ -203,17 +203,18 @@ add_file :: (result : *Compile_Result, path : string) {
return; return;
} }
add_file_from_string(result, file_string, path);
}
add_file_from_string :: (result : *Compile_Result, source : string, path : string = "") {
input_file : Input_File; input_file : Input_File;
input_file.source = file_string; input_file.source = source;
input_file.path = path; input_file.path = path;
compiled_file : Compiled_File; result.file = input_file;
compiled_file.file = input_file;
compiled_file.allocator = make_arena(*compiled_file.arena); result.allocator = make_arena(*result.arena);
array_add(*result.files, compiled_file);
} }
// @Incomplete(nb): Will we ever even use this? // @Incomplete(nb): Will we ever even use this?
@@ -396,15 +397,18 @@ type_variable_to_field :: (type_variables : []Type_Variable, scope_stack : Scope
} }
type_variable_to_field :: (checker : *Semantic_Checker, variable : *Type_Variable) -> Field { type_variable_to_field :: (checker : *Semantic_Checker, variable : *Type_Variable) -> Field {
return type_variable_to_field(checker.result_file.type_variables, checker.result_file.scope_stack, variable); return type_variable_to_field(checker.result.type_variables, checker.result.scope_stack, variable);
} }
generate_output_data :: (result : *Compile_Result) { generate_output_data :: (result : *Compile_Result) {
for *file : result.files { if result.had_error {
if file.vertex_entry_point.node { return;
file.vertex_entry_point.name = file.vertex_entry_point.node.name; }
type_variable := from_handle(file.type_variables, file.vertex_entry_point.node.type_variable); if result.vertex_entry_point.node {
result.vertex_entry_point.name = result.vertex_entry_point.node.name;
type_variable := from_handle(result.type_variables, result.vertex_entry_point.node.type_variable);
assert(type_variable.type == .Function); assert(type_variable.type == .Function);
node := type_variable.source_node; node := type_variable.source_node;
@@ -412,50 +416,51 @@ generate_output_data :: (result : *Compile_Result) {
if node.children[0].kind == .FieldList { if node.children[0].kind == .FieldList {
field_list := node.children[0]; field_list := node.children[0];
for child : field_list.children { for child : field_list.children {
tv := from_handle(file.type_variables, child.type_variable); tv := from_handle(result.type_variables, child.type_variable);
field := type_variable_to_field(file.type_variables, file.scope_stack, tv); field := type_variable_to_field(result.type_variables, result.scope_stack, tv);
array_add(*file.vertex_entry_point.input, field); array_add(*result.vertex_entry_point.input, field);
} }
} }
} }
} }
for buffer_variable : file.constant_buffers { for buffer_variable : result.constant_buffers {
variable := from_handle(file.type_variables, buffer_variable); variable := from_handle(result.type_variables, buffer_variable);
cb := array_add(*file.cbuffers); cb := array_add(*result.cbuffers);
for i : 0..variable.children.count - 1 { for i : 0..variable.children.count - 1 {
child := variable.children[i]; child := variable.children[i];
field : Property_Field; field : Property_Field;
field.base_field = type_variable_to_field(file.type_variables, file.scope_stack, from_handle(file.type_variables, child)); field.base_field = type_variable_to_field(result.type_variables, result.scope_stack, from_handle(result.type_variables, child));
array_add(*cb.fields, field); array_add(*cb.fields, field);
} }
cb.buffer_index = variable.resource_index; cb.buffer_index = variable.resource_index;
} }
find_result := find_symbol(*file.scope_stack, file.property_name, xx 1); find_result := find_symbol(*result.scope_stack, result.property_name, xx 1);
if find_result { if find_result {
property_variable := from_handle(file.type_variables, find_result.type_variable); property_variable := from_handle(result.type_variables, find_result.type_variable);
for i : 0..property_variable.children.count - 1 { for i : 0..property_variable.children.count - 1 {
child := property_variable.children[i]; child := property_variable.children[i];
field := type_variable_to_field(file.type_variables, file.scope_stack, from_handle(file.type_variables, child)); field := type_variable_to_field(result.type_variables, result.scope_stack, from_handle(result.type_variables, child));
prop_field : Property_Field; prop_field : Property_Field;
prop_field.base_field = field; prop_field.base_field = field;
array_add(*file.properties.fields, prop_field); array_add(*result.properties.fields, prop_field);
} }
file.properties.buffer_index = property_variable.resource_index; result.properties.buffer_index = property_variable.resource_index;
} }
if file.pixel_entry_point.node {
file.pixel_entry_point.name = file.pixel_entry_point.node.name;
type_variable := from_handle(file.type_variables, file.pixel_entry_point.node.type_variable); if result.pixel_entry_point.node {
result.pixel_entry_point.name = result.pixel_entry_point.node.name;
type_variable := from_handle(result.type_variables, result.pixel_entry_point.node.type_variable);
assert(type_variable.type == .Function); assert(type_variable.type == .Function);
field := type_variable_to_field(file.type_variables, file.scope_stack, type_variable.return_type_variable); field := type_variable_to_field(result.type_variables, result.scope_stack, type_variable.return_type_variable);
for hint : type_variable.source_node.hint_tokens { for hint : type_variable.source_node.hint_tokens {
field_hint : Field_Hint; field_hint : Field_Hint;
@@ -479,12 +484,25 @@ generate_output_data :: (result : *Compile_Result) {
array_add(*field.hints, field_hint); array_add(*field.hints, field_hint);
} }
file.pixel_entry_point.return_value = field; result.pixel_entry_point.return_value = field;
}
} }
} }
compile_file :: (compiler : *Shader_Compiler, paths : ..string) -> Compile_Result { compile_file :: (compiler : *Shader_Compiler, path : string) -> Compile_Result {
result : Compile_Result;
add_file(*result, path);
lex(*result);
parse(*result);
check(*result);
codegen(*result);
generate_output_data(*result);
return result;
}
compile_files :: (compiler : *Shader_Compiler, paths : ..string) -> Compile_Result {
result : Compile_Result; result : Compile_Result;
for path : paths { for path : paths {

3
test/lex/field_assignment.golden
View File

@@ -27,4 +27,5 @@
{kind = TOKEN_IDENTIFIER; ; index = 103 ; length = 3 line = 5 ; column = 7 ; value ='pos'; } {kind = TOKEN_IDENTIFIER; ; index = 103 ; length = 3 line = 5 ; column = 7 ; value ='pos'; }
{kind = TOKEN_SEMICOLON; ; index = 106 ; length = 1 line = 5 ; column = 10 ; value =';'; } {kind = TOKEN_SEMICOLON; ; index = 106 ; length = 1 line = 5 ; column = 10 ; value =';'; }
{kind = TOKEN_RIGHTBRACE; ; index = 109 ; length = 1 line = 6 ; column = 0 ; value ='}'; } {kind = TOKEN_RIGHTBRACE; ; index = 109 ; length = 1 line = 6 ; column = 0 ; value ='}'; }
{kind = TOKEN_EOF; ; index = 112 ; length = 0 line = 7 ; column = 0 ; value =''; } {kind = TOKEN_IDENTIFIER; ; index = 110 ; length = 1 line = 6 ; column = 1 ; value ='x'; }
{kind = TOKEN_EOF; ; index = 113 ; length = 0 line = 7 ; column = 0 ; value =''; }