diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index 43072c26..2b830a57 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -25,19 +25,20 @@ void hlsl_message(const char *fmt, ...) /* FIXME */ } -void hlsl_report_message(const struct source_location loc, +void hlsl_report_message(struct hlsl_ctx *ctx, const struct source_location loc, enum hlsl_error_level level, const char *fmt, ...) { /* FIXME */ if (level == HLSL_LEVEL_ERROR) - set_parse_status(&hlsl_ctx.status, PARSE_ERR); + set_parse_status(&ctx->status, PARSE_ERR); else if (level == HLSL_LEVEL_WARNING) - set_parse_status(&hlsl_ctx.status, PARSE_WARN); + set_parse_status(&ctx->status, PARSE_WARN); } -bool hlsl_add_var(struct hlsl_scope *scope, struct hlsl_ir_var *decl, bool local_var) +bool hlsl_add_var(struct hlsl_ctx *ctx, struct hlsl_ir_var *decl, bool local_var) { + struct hlsl_scope *scope = ctx->cur_scope; struct hlsl_ir_var *var; LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry) @@ -45,7 +46,7 @@ bool hlsl_add_var(struct hlsl_scope *scope, struct hlsl_ir_var *decl, bool local if (!strcmp(decl->name, var->name)) return false; } - if (local_var && scope->upper->upper == hlsl_ctx.globals) + if (local_var && scope->upper->upper == ctx->globals) { /* Check whether the variable redefines a function parameter. */ LIST_FOR_EACH_ENTRY(var, &scope->upper->vars, struct hlsl_ir_var, scope_entry) @@ -81,7 +82,7 @@ void hlsl_free_var(struct hlsl_ir_var *decl) vkd3d_free(decl); } -struct hlsl_type *hlsl_new_type(const char *name, enum hlsl_type_class type_class, +struct hlsl_type *hlsl_new_type(struct hlsl_ctx *ctx, const char *name, enum hlsl_type_class type_class, enum hlsl_base_type base_type, unsigned dimx, unsigned dimy) { struct hlsl_type *type; @@ -98,14 +99,14 @@ struct hlsl_type *hlsl_new_type(const char *name, enum hlsl_type_class type_clas else type->reg_size = 1; - list_add_tail(&hlsl_ctx.types, &type->entry); + list_add_tail(&ctx->types, &type->entry); return type; } -struct hlsl_type *hlsl_new_array_type(struct hlsl_type *basic_type, unsigned int array_size) +struct hlsl_type *hlsl_new_array_type(struct hlsl_ctx *ctx, struct hlsl_type *basic_type, unsigned int array_size) { - struct hlsl_type *type = hlsl_new_type(NULL, HLSL_CLASS_ARRAY, HLSL_TYPE_FLOAT, 1, 1); + struct hlsl_type *type = hlsl_new_type(ctx, NULL, HLSL_CLASS_ARRAY, HLSL_TYPE_FLOAT, 1, 1); if (!type) return NULL; @@ -126,7 +127,7 @@ static DWORD get_array_size(const struct hlsl_type *type) return 1; } -struct hlsl_type *hlsl_new_struct_type(const char *name, struct list *fields) +struct hlsl_type *hlsl_new_struct_type(struct hlsl_ctx *ctx, const char *name, struct list *fields) { struct hlsl_struct_field *field; unsigned int reg_size = 0; @@ -149,7 +150,7 @@ struct hlsl_type *hlsl_new_struct_type(const char *name, struct list *fields) } type->reg_size = reg_size; - list_add_tail(&hlsl_ctx.types, &type->entry); + list_add_tail(&ctx->types, &type->entry); return type; } @@ -166,9 +167,9 @@ struct hlsl_type *hlsl_get_type(struct hlsl_scope *scope, const char *name, bool return NULL; } -bool hlsl_get_function(const char *name) +bool hlsl_get_function(struct hlsl_ctx *ctx, const char *name) { - return rb_get(&hlsl_ctx.functions, name) != NULL; + return rb_get(&ctx->functions, name) != NULL; } unsigned int hlsl_type_component_count(struct hlsl_type *type) @@ -243,7 +244,7 @@ bool hlsl_type_compare(const struct hlsl_type *t1, const struct hlsl_type *t2) return true; } -struct hlsl_type *hlsl_type_clone(struct hlsl_type *old, unsigned int default_majority) +struct hlsl_type *hlsl_type_clone(struct hlsl_ctx *ctx, struct hlsl_type *old, unsigned int default_majority) { struct hlsl_struct_field *old_field, *field; struct hlsl_type *type; @@ -271,7 +272,7 @@ struct hlsl_type *hlsl_type_clone(struct hlsl_type *old, unsigned int default_ma switch (old->type) { case HLSL_CLASS_ARRAY: - type->e.array.type = hlsl_type_clone(old->e.array.type, default_majority); + type->e.array.type = hlsl_type_clone(ctx, old->e.array.type, default_majority); type->e.array.elements_count = old->e.array.elements_count; type->reg_size = type->e.array.elements_count * type->e.array.type->reg_size; break; @@ -302,7 +303,7 @@ struct hlsl_type *hlsl_type_clone(struct hlsl_type *old, unsigned int default_ma vkd3d_free(type); return NULL; } - field->type = hlsl_type_clone(old_field->type, default_majority); + field->type = hlsl_type_clone(ctx, old_field->type, default_majority); field->name = vkd3d_strdup(old_field->name); if (old_field->semantic) field->semantic = vkd3d_strdup(old_field->semantic); @@ -324,7 +325,7 @@ struct hlsl_type *hlsl_type_clone(struct hlsl_type *old, unsigned int default_ma break; } - list_add_tail(&hlsl_ctx.types, &type->entry); + list_add_tail(&ctx->types, &type->entry); return type; } @@ -354,10 +355,7 @@ struct hlsl_ir_var *hlsl_new_var(const char *name, struct hlsl_type *type, const struct hlsl_ir_var *var; if (!(var = vkd3d_calloc(1, sizeof(*var)))) - { - hlsl_ctx.status = PARSE_ERR; return NULL; - } var->name = name; var->data_type = type; @@ -368,12 +366,13 @@ struct hlsl_ir_var *hlsl_new_var(const char *name, struct hlsl_type *type, const return var; } -struct hlsl_ir_var *hlsl_new_synthetic_var(const char *name, struct hlsl_type *type, const struct source_location loc) +struct hlsl_ir_var *hlsl_new_synthetic_var(struct hlsl_ctx *ctx, const char *name, struct hlsl_type *type, + const struct source_location loc) { struct hlsl_ir_var *var = hlsl_new_var(vkd3d_strdup(name), type, loc, NULL, 0, NULL); if (var) - list_add_tail(&hlsl_ctx.globals->vars, &var->scope_entry); + list_add_tail(&ctx->globals->vars, &var->scope_entry); return var; } @@ -406,13 +405,13 @@ struct hlsl_ir_assignment *hlsl_new_simple_assignment(struct hlsl_ir_var *lhs, s return hlsl_new_assignment(lhs, NULL, rhs, 0, rhs->loc); } -struct hlsl_ir_constant *hlsl_new_uint_constant(unsigned int n, const struct source_location loc) +struct hlsl_ir_constant *hlsl_new_uint_constant(struct hlsl_ctx *ctx, unsigned int n, const struct source_location loc) { struct hlsl_ir_constant *c; if (!(c = vkd3d_malloc(sizeof(*c)))) return NULL; - init_node(&c->node, HLSL_IR_CONSTANT, hlsl_ctx.builtin_types.scalar[HLSL_TYPE_UINT], loc); + init_node(&c->node, HLSL_IR_CONSTANT, ctx->builtin_types.scalar[HLSL_TYPE_UINT], loc); c->value.u[0] = n; return c; } @@ -468,7 +467,7 @@ struct hlsl_ir_load *hlsl_new_var_load(struct hlsl_ir_var *var, const struct sou return load; } -struct hlsl_ir_swizzle *hlsl_new_swizzle(DWORD s, unsigned int components, +struct hlsl_ir_swizzle *hlsl_new_swizzle(struct hlsl_ctx *ctx, DWORD s, unsigned int components, struct hlsl_ir_node *val, struct source_location *loc) { struct hlsl_ir_swizzle *swizzle; @@ -476,7 +475,7 @@ struct hlsl_ir_swizzle *hlsl_new_swizzle(DWORD s, unsigned int components, if (!(swizzle = vkd3d_malloc(sizeof(*swizzle)))) return NULL; init_node(&swizzle->node, HLSL_IR_SWIZZLE, - hlsl_new_type(NULL, HLSL_CLASS_VECTOR, val->data_type->base_type, components, 1), *loc); + hlsl_new_type(ctx, NULL, HLSL_CLASS_VECTOR, val->data_type->base_type, components, 1), *loc); hlsl_src_from_node(&swizzle->val, val); swizzle->swizzle = s; return swizzle; @@ -487,7 +486,7 @@ bool hlsl_type_is_void(const struct hlsl_type *type) return type->type == HLSL_CLASS_OBJECT && type->base_type == HLSL_TYPE_VOID; } -struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_type *return_type, +struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_ctx *ctx, struct hlsl_type *return_type, struct list *parameters, const char *semantic, struct source_location loc) { struct hlsl_ir_function_decl *decl; @@ -505,7 +504,7 @@ struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_type *return_type, char name[28]; sprintf(name, "", decl); - if (!(return_var = hlsl_new_synthetic_var(name, return_type, loc))) + if (!(return_var = hlsl_new_synthetic_var(ctx, name, return_type, loc))) { vkd3d_free(decl); return NULL; @@ -532,7 +531,7 @@ static int compare_hlsl_types_rb(const void *key, const struct rb_entry *entry) return strcmp(name, type->name); } -void hlsl_push_scope(struct hlsl_parse_ctx *ctx) +void hlsl_push_scope(struct hlsl_ctx *ctx) { struct hlsl_scope *new_scope; @@ -546,7 +545,7 @@ void hlsl_push_scope(struct hlsl_parse_ctx *ctx) list_add_tail(&ctx->scopes, &new_scope->entry); } -void hlsl_pop_scope(struct hlsl_parse_ctx *ctx) +void hlsl_pop_scope(struct hlsl_ctx *ctx) { struct hlsl_scope *prev_scope = ctx->cur_scope->upper; @@ -1376,7 +1375,7 @@ static int compare_function_rb(const void *key, const struct rb_entry *entry) return strcmp(name, func->name); } -static void declare_predefined_types(struct hlsl_scope *scope) +static void declare_predefined_types(struct hlsl_ctx *ctx) { unsigned int x, y, bt, i; struct hlsl_type *type; @@ -1427,22 +1426,22 @@ static void declare_predefined_types(struct hlsl_scope *scope) for (x = 1; x <= 4; ++x) { sprintf(name, "%s%ux%u", names[bt], y, x); - type = hlsl_new_type(vkd3d_strdup(name), HLSL_CLASS_MATRIX, bt, x, y); - hlsl_scope_add_type(scope, type); + type = hlsl_new_type(ctx, vkd3d_strdup(name), HLSL_CLASS_MATRIX, bt, x, y); + hlsl_scope_add_type(ctx->globals, type); if (y == 1) { sprintf(name, "%s%u", names[bt], x); - type = hlsl_new_type(vkd3d_strdup(name), HLSL_CLASS_VECTOR, bt, x, y); - hlsl_scope_add_type(scope, type); - hlsl_ctx.builtin_types.vector[bt][x - 1] = type; + type = hlsl_new_type(ctx, vkd3d_strdup(name), HLSL_CLASS_VECTOR, bt, x, y); + hlsl_scope_add_type(ctx->globals, type); + ctx->builtin_types.vector[bt][x - 1] = type; if (x == 1) { sprintf(name, "%s", names[bt]); - type = hlsl_new_type(vkd3d_strdup(name), HLSL_CLASS_SCALAR, bt, x, y); - hlsl_scope_add_type(scope, type); - hlsl_ctx.builtin_types.scalar[bt] = type; + type = hlsl_new_type(ctx, vkd3d_strdup(name), HLSL_CLASS_SCALAR, bt, x, y); + hlsl_scope_add_type(ctx->globals, type); + ctx->builtin_types.scalar[bt] = type; } } } @@ -1451,22 +1450,22 @@ static void declare_predefined_types(struct hlsl_scope *scope) for (bt = 0; bt <= HLSL_SAMPLER_DIM_MAX; ++bt) { - type = hlsl_new_type(vkd3d_strdup(sampler_names[bt]), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1); + type = hlsl_new_type(ctx, vkd3d_strdup(sampler_names[bt]), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1); type->sampler_dim = bt; - hlsl_ctx.builtin_types.sampler[bt] = type; + ctx->builtin_types.sampler[bt] = type; } - hlsl_ctx.builtin_types.Void = hlsl_new_type(vkd3d_strdup("void"), HLSL_CLASS_OBJECT, HLSL_TYPE_VOID, 1, 1); + ctx->builtin_types.Void = hlsl_new_type(ctx, vkd3d_strdup("void"), HLSL_CLASS_OBJECT, HLSL_TYPE_VOID, 1, 1); for (i = 0; i < ARRAY_SIZE(effect_types); ++i) { - type = hlsl_new_type(vkd3d_strdup(effect_types[i].name), effect_types[i].class, + type = hlsl_new_type(ctx, vkd3d_strdup(effect_types[i].name), effect_types[i].class, effect_types[i].base_type, effect_types[i].dimx, effect_types[i].dimy); - hlsl_scope_add_type(scope, type); + hlsl_scope_add_type(ctx->globals, type); } } -static bool hlsl_ctx_init(struct hlsl_parse_ctx *ctx, struct vkd3d_shader_message_context *message_context) +static bool hlsl_ctx_init(struct hlsl_ctx *ctx, struct vkd3d_shader_message_context *message_context) { memset(ctx, 0, sizeof(*ctx)); @@ -1490,7 +1489,7 @@ static bool hlsl_ctx_init(struct hlsl_parse_ctx *ctx, struct vkd3d_shader_messag ctx->globals = ctx->cur_scope; list_init(&ctx->types); - declare_predefined_types(ctx->globals); + declare_predefined_types(ctx); rb_init(&ctx->functions, compare_function_rb); @@ -1499,7 +1498,7 @@ static bool hlsl_ctx_init(struct hlsl_parse_ctx *ctx, struct vkd3d_shader_messag return true; } -static void hlsl_ctx_cleanup(struct hlsl_parse_ctx *ctx) +static void hlsl_ctx_cleanup(struct hlsl_ctx *ctx) { struct hlsl_scope *scope, *next_scope; struct hlsl_ir_var *var, *next_var; @@ -1529,6 +1528,7 @@ int hlsl_compile_shader(const char *text, const struct vkd3d_shader_compile_info { const struct vkd3d_shader_hlsl_source_info *hlsl_source_info; const struct hlsl_profile_info *profile; + struct hlsl_ctx ctx; int ret; if (!(hlsl_source_info = vkd3d_find_struct(compile_info->next, HLSL_SOURCE_INFO))) @@ -1545,12 +1545,12 @@ int hlsl_compile_shader(const char *text, const struct vkd3d_shader_compile_info vkd3d_shader_dump_shader(profile->type, &compile_info->source); - if (!hlsl_ctx_init(&hlsl_ctx, message_context)) + if (!hlsl_ctx_init(&ctx, message_context)) return VKD3D_ERROR_OUT_OF_MEMORY; - ret = hlsl_lexer_compile(text, hlsl_source_info->entry_point ? hlsl_source_info->entry_point : "main"); + ret = hlsl_lexer_compile(&ctx, text, hlsl_source_info->entry_point ? hlsl_source_info->entry_point : "main"); - hlsl_ctx_cleanup(&hlsl_ctx); + hlsl_ctx_cleanup(&ctx); return ret; } diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 48067956..d48ce79f 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -398,7 +398,7 @@ struct hlsl_scope struct hlsl_scope *upper; }; -struct hlsl_parse_ctx +struct hlsl_ctx { const char **source_files; unsigned int source_files_count; @@ -408,6 +408,8 @@ struct hlsl_parse_ctx enum parse_status status; struct vkd3d_shader_message_context *message_context; + void *scanner; + struct hlsl_scope *cur_scope; struct hlsl_scope *globals; struct list scopes; @@ -429,8 +431,6 @@ struct hlsl_parse_ctx struct list static_initializers; }; -extern struct hlsl_parse_ctx hlsl_ctx DECLSPEC_HIDDEN; - enum hlsl_error_level { HLSL_LEVEL_ERROR = 0, @@ -525,10 +525,7 @@ const char *hlsl_node_type_to_string(enum hlsl_ir_node_type type) DECLSPEC_HIDDE void hlsl_add_function(struct rb_tree *funcs, char *name, struct hlsl_ir_function_decl *decl, bool intrinsic) DECLSPEC_HIDDEN; -bool hlsl_add_var(struct hlsl_scope *scope, struct hlsl_ir_var *decl, bool local_var) DECLSPEC_HIDDEN; - -int hlsl_compile(enum vkd3d_shader_type type, DWORD major, DWORD minor, const char *entrypoint, - struct vkd3d_shader_code *dxbc, struct vkd3d_shader_message_context *message_context) DECLSPEC_HIDDEN; +bool hlsl_add_var(struct hlsl_ctx *ctx, struct hlsl_ir_var *decl, bool local_var) DECLSPEC_HIDDEN; void hlsl_dump_function(const struct hlsl_ir_function_decl *func) DECLSPEC_HIDDEN; @@ -537,30 +534,32 @@ void hlsl_free_instr_list(struct list *list) DECLSPEC_HIDDEN; void hlsl_free_type(struct hlsl_type *type) DECLSPEC_HIDDEN; void hlsl_free_var(struct hlsl_ir_var *decl) DECLSPEC_HIDDEN; -bool hlsl_get_function(const char *name) DECLSPEC_HIDDEN; +bool hlsl_get_function(struct hlsl_ctx *ctx, const char *name) DECLSPEC_HIDDEN; struct hlsl_type *hlsl_get_type(struct hlsl_scope *scope, const char *name, bool recursive) DECLSPEC_HIDDEN; struct hlsl_ir_var *hlsl_get_var(struct hlsl_scope *scope, const char *name) DECLSPEC_HIDDEN; -struct hlsl_type *hlsl_new_array_type(struct hlsl_type *basic_type, unsigned int array_size) DECLSPEC_HIDDEN; +struct hlsl_type *hlsl_new_array_type(struct hlsl_ctx *ctx, struct hlsl_type *basic_type, + unsigned int array_size) DECLSPEC_HIDDEN; struct hlsl_ir_assignment *hlsl_new_assignment(struct hlsl_ir_var *var, struct hlsl_ir_node *offset, struct hlsl_ir_node *rhs, unsigned int writemask, struct source_location loc) DECLSPEC_HIDDEN; struct hlsl_ir_node *hlsl_new_binary_expr(enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2) DECLSPEC_HIDDEN; struct hlsl_ir_expr *hlsl_new_cast(struct hlsl_ir_node *node, struct hlsl_type *type, struct source_location *loc) DECLSPEC_HIDDEN; -struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_type *return_type, +struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_ctx *ctx, struct hlsl_type *return_type, struct list *parameters, const char *semantic, struct source_location loc) DECLSPEC_HIDDEN; struct hlsl_ir_if *hlsl_new_if(struct hlsl_ir_node *condition, struct source_location loc) DECLSPEC_HIDDEN; struct hlsl_ir_assignment *hlsl_new_simple_assignment(struct hlsl_ir_var *lhs, struct hlsl_ir_node *rhs) DECLSPEC_HIDDEN; -struct hlsl_type *hlsl_new_struct_type(const char *name, struct list *fields) DECLSPEC_HIDDEN; -struct hlsl_ir_swizzle *hlsl_new_swizzle(DWORD s, unsigned int components, +struct hlsl_type *hlsl_new_struct_type(struct hlsl_ctx *ctx, const char *name, struct list *fields) DECLSPEC_HIDDEN; +struct hlsl_ir_swizzle *hlsl_new_swizzle(struct hlsl_ctx *ctx, DWORD s, unsigned int components, struct hlsl_ir_node *val, struct source_location *loc) DECLSPEC_HIDDEN; -struct hlsl_ir_var *hlsl_new_synthetic_var(const char *name, struct hlsl_type *type, +struct hlsl_ir_var *hlsl_new_synthetic_var(struct hlsl_ctx *ctx, const char *name, struct hlsl_type *type, const struct source_location loc) DECLSPEC_HIDDEN; -struct hlsl_type *hlsl_new_type(const char *name, enum hlsl_type_class type_class, +struct hlsl_type *hlsl_new_type(struct hlsl_ctx *ctx, const char *name, enum hlsl_type_class type_class, enum hlsl_base_type base_type, unsigned dimx, unsigned dimy) DECLSPEC_HIDDEN; -struct hlsl_ir_constant *hlsl_new_uint_constant(unsigned int n, const struct source_location loc) DECLSPEC_HIDDEN; +struct hlsl_ir_constant *hlsl_new_uint_constant(struct hlsl_ctx *ctx, unsigned int n, + const struct source_location loc) DECLSPEC_HIDDEN; struct hlsl_ir_node *hlsl_new_unary_expr(enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg, struct source_location loc) DECLSPEC_HIDDEN; struct hlsl_ir_var *hlsl_new_var(const char *name, struct hlsl_type *type, const struct source_location loc, @@ -569,21 +568,22 @@ struct hlsl_ir_var *hlsl_new_var(const char *name, struct hlsl_type *type, const struct hlsl_ir_load *hlsl_new_var_load(struct hlsl_ir_var *var, const struct source_location loc) DECLSPEC_HIDDEN; void hlsl_message(const char *fmt, ...) VKD3D_PRINTF_FUNC(1,2) DECLSPEC_HIDDEN; -void hlsl_report_message(const struct source_location loc, - enum hlsl_error_level level, const char *fmt, ...) VKD3D_PRINTF_FUNC(3,4) DECLSPEC_HIDDEN; +void hlsl_report_message(struct hlsl_ctx *ctx, const struct source_location loc, + enum hlsl_error_level level, const char *fmt, ...) VKD3D_PRINTF_FUNC(4, 5) DECLSPEC_HIDDEN; -void hlsl_push_scope(struct hlsl_parse_ctx *ctx) DECLSPEC_HIDDEN; -void hlsl_pop_scope(struct hlsl_parse_ctx *ctx) DECLSPEC_HIDDEN; +void hlsl_push_scope(struct hlsl_ctx *ctx) DECLSPEC_HIDDEN; +void hlsl_pop_scope(struct hlsl_ctx *ctx) DECLSPEC_HIDDEN; bool hlsl_scope_add_type(struct hlsl_scope *scope, struct hlsl_type *type) DECLSPEC_HIDDEN; -struct hlsl_type *hlsl_type_clone(struct hlsl_type *old, unsigned int default_majority) DECLSPEC_HIDDEN; +struct hlsl_type *hlsl_type_clone(struct hlsl_ctx *ctx, struct hlsl_type *old, + unsigned int default_majority) DECLSPEC_HIDDEN; bool hlsl_type_compare(const struct hlsl_type *t1, const struct hlsl_type *t2) DECLSPEC_HIDDEN; unsigned int hlsl_type_component_count(struct hlsl_type *type) DECLSPEC_HIDDEN; bool hlsl_type_is_row_major(const struct hlsl_type *type) DECLSPEC_HIDDEN; bool hlsl_type_is_void(const struct hlsl_type *type) DECLSPEC_HIDDEN; -int hlsl_lexer_compile(const char *text, const char *entrypoint) DECLSPEC_HIDDEN; -int hlsl_parser_compile(const char *entrypoint) DECLSPEC_HIDDEN; +int hlsl_lexer_compile(struct hlsl_ctx *ctx, const char *text, const char *entrypoint) DECLSPEC_HIDDEN; +int hlsl_parser_compile(struct hlsl_ctx *ctx, const char *entrypoint) DECLSPEC_HIDDEN; #endif diff --git a/libs/vkd3d-shader/hlsl.l b/libs/vkd3d-shader/hlsl.l index bdfab775..b1090844 100644 --- a/libs/vkd3d-shader/hlsl.l +++ b/libs/vkd3d-shader/hlsl.l @@ -24,17 +24,24 @@ #include "hlsl.h" #include "hlsl.tab.h" -static void update_location(HLSL_LTYPE *lloc); +#define YYSTYPE HLSL_STYPE +#define YYLTYPE HLSL_LTYPE -#define YY_USER_ACTION update_location(&hlsl_lloc); +static void update_location(struct hlsl_ctx *ctx, HLSL_LTYPE *loc); + +#define YY_USER_ACTION update_location(yyget_extra(yyscanner), yyget_lloc(yyscanner)); %} -%option prefix="hlsl_" +%option bison-bridge +%option bison-locations +%option extra-type="struct hlsl_ctx *" %option never-interactive %option noinput %option nounput %option noyywrap +%option prefix="hlsl_" +%option reentrant %x pp pp_line pp_pragma pp_ignore @@ -52,21 +59,14 @@ IDENTIFIER [A-Za-z_][A-Za-z0-9_]* ANY (.) %% -{RESERVED1} { - hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", hlsl_ctx.line_no, yytext); - set_parse_status(&hlsl_ctx.status, PARSE_ERR); - } -{RESERVED2} { - hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", hlsl_ctx.line_no, yytext); - set_parse_status(&hlsl_ctx.status, PARSE_ERR); - } -{RESERVED3} { - hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", hlsl_ctx.line_no, yytext); - set_parse_status(&hlsl_ctx.status, PARSE_ERR); - } +{RESERVED1} | +{RESERVED2} | +{RESERVED3} | {RESERVED4} { - hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", hlsl_ctx.line_no, yytext); - set_parse_status(&hlsl_ctx.status, PARSE_ERR); + struct hlsl_ctx *ctx = yyget_extra(yyscanner); + + hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", ctx->line_no, yytext); + set_parse_status(&ctx->status, PARSE_ERR); } BlendState {return KW_BLENDSTATE; } @@ -168,37 +168,39 @@ column_major {return KW_COLUMN_MAJOR; } row_major {return KW_ROW_MAJOR; } {IDENTIFIER} { - hlsl_lval.name = vkd3d_strdup(yytext); - if (hlsl_get_var(hlsl_ctx.cur_scope, yytext) || hlsl_get_function(yytext)) + struct hlsl_ctx *ctx = yyget_extra(yyscanner); + + yylval->name = vkd3d_strdup(yytext); + if (hlsl_get_var(ctx->cur_scope, yytext) || hlsl_get_function(ctx, yytext)) return VAR_IDENTIFIER; - else if (hlsl_get_type(hlsl_ctx.cur_scope, yytext, true)) + else if (hlsl_get_type(ctx->cur_scope, yytext, true)) return TYPE_IDENTIFIER; else return NEW_IDENTIFIER; } [0-9]*\.[0-9]+([eE][+-]?[0-9]+)?[h|H|f|F]? { - hlsl_lval.floatval = atof(yytext); + yylval->floatval = atof(yytext); return C_FLOAT; } [0-9]+\.([eE][+-]?[0-9]+)?[h|H|f|F]? { - hlsl_lval.floatval = atof(yytext); + yylval->floatval = atof(yytext); return C_FLOAT; } [0-9]+([eE][+-]?[0-9]+)?[h|H|f|F] { - hlsl_lval.floatval = atof(yytext); + yylval->floatval = atof(yytext); return C_FLOAT; } 0x[0-9a-fA-F]+ { - sscanf(yytext, "0x%x", &hlsl_lval.intval); + sscanf(yytext, "0x%x", &yylval->intval); return C_INTEGER; } 0[0-7]+ { - sscanf(yytext, "0%o", &hlsl_lval.intval); + sscanf(yytext, "0%o", &yylval->intval); return C_INTEGER; } [0-9]+ { - hlsl_lval.intval = (atoi(yytext)); + yylval->intval = (atoi(yytext)); return C_INTEGER; } @@ -206,8 +208,10 @@ row_major {return KW_ROW_MAJOR; } {WS}+ {} {NEWLINE} { - hlsl_ctx.line_no++; - hlsl_ctx.column = 1; + struct hlsl_ctx *ctx = yyget_extra(yyscanner); + + ctx->line_no++; + ctx->column = 1; } ^# { @@ -219,24 +223,30 @@ row_major {return KW_ROW_MAJOR; } BEGIN(pp_pragma); } pack_matrix{WS}*\({WS}*row_major{WS}*\) { + struct hlsl_ctx *ctx = yyget_extra(yyscanner); + TRACE("#pragma setting row_major mode.\n"); - hlsl_ctx.matrix_majority = HLSL_ROW_MAJOR; + ctx->matrix_majority = HLSL_ROW_MAJOR; BEGIN(pp_ignore); } pack_matrix{WS}*\({WS}*column_major{WS}*\) { + struct hlsl_ctx *ctx = yyget_extra(yyscanner); + TRACE("#pragma setting column_major mode.\n"); - hlsl_ctx.matrix_majority = HLSL_COLUMN_MAJOR; + ctx->matrix_majority = HLSL_COLUMN_MAJOR; BEGIN(pp_ignore); } {NEWLINE} { - FIXME("Unsupported preprocessor #pragma directive at line %u.\n", hlsl_ctx.line_no); + struct hlsl_ctx *ctx = yyget_extra(yyscanner); + + FIXME("Unsupported preprocessor #pragma directive at line %u.\n", ctx->line_no); BEGIN(INITIAL); } {ANY} {} [0-9]+ { TRACE("Preprocessor line info.\n"); BEGIN(pp_line); - hlsl_lval.intval = (atoi(yytext)); + yylval->intval = (atoi(yytext)); return PRE_LINE; } {STRING} { @@ -244,7 +254,7 @@ row_major {return KW_ROW_MAJOR; } BEGIN(pp_ignore); string[strlen(string) - 1] = 0; - hlsl_lval.name = string; + yylval->name = string; return STRING; } {WS}+ {} @@ -268,24 +278,26 @@ row_major {return KW_ROW_MAJOR; } %% -static void update_location(HLSL_LTYPE *lloc) +static void update_location(struct hlsl_ctx *ctx, HLSL_LTYPE *lloc) { - lloc->file = hlsl_ctx.source_file; - lloc->col = hlsl_ctx.column; - lloc->line = hlsl_ctx.line_no; - hlsl_ctx.column += yyleng; + lloc->file = ctx->source_file; + lloc->col = ctx->column; + lloc->line = ctx->line_no; + ctx->column += yyget_leng(ctx->scanner); } -int hlsl_lexer_compile(const char *text, const char *entrypoint) +int hlsl_lexer_compile(struct hlsl_ctx *ctx, const char *text, const char *entrypoint) { YY_BUFFER_STATE buffer; int ret; - buffer = hlsl__scan_string(text); - hlsl__switch_to_buffer(buffer); + yylex_init_extra(ctx, &ctx->scanner); + buffer = hlsl__scan_string(text, ctx->scanner); + hlsl__switch_to_buffer(buffer, ctx->scanner); - ret = hlsl_parser_compile(entrypoint); + ret = hlsl_parser_compile(ctx, entrypoint); - hlsl__delete_buffer(buffer); + hlsl__delete_buffer(buffer, ctx->scanner); + yylex_destroy(ctx->scanner); return ret; } diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index 7572f7d7..8fc7f825 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -99,24 +99,21 @@ enum parse_assign_op } +%code provides +{ + +int hlsl_lex(HLSL_STYPE *yylval_param, HLSL_LTYPE *yylloc_param, void *yyscanner); + +} + %code { #define YYLLOC_DEFAULT(cur, rhs, n) (cur) = YYRHSLOC(rhs, !!n) -int hlsl_lex(void); - -struct hlsl_parse_ctx hlsl_ctx; - -static void hlsl_error(const char *s) +static void yyerror(YYLTYPE *loc, void *scanner, struct hlsl_ctx *ctx, const char *s) { - const struct source_location loc = - { - .file = hlsl_ctx.source_file, - .line = hlsl_ctx.line_no, - .col = hlsl_ctx.column, - }; - hlsl_report_message(loc, HLSL_LEVEL_ERROR, "%s", s); + hlsl_report_message(ctx, *loc, HLSL_LEVEL_ERROR, "%s", s); } static struct hlsl_ir_node *node_from_list(struct list *list) @@ -132,10 +129,10 @@ static void debug_dump_decl(struct hlsl_type *type, DWORD modifiers, const char TRACE("%s %s;\n", debug_hlsl_type(type), declname); } -static void check_invalid_matrix_modifiers(DWORD modifiers, struct source_location loc) +static void check_invalid_matrix_modifiers(struct hlsl_ctx *ctx, DWORD modifiers, struct source_location loc) { if (modifiers & HLSL_MODIFIERS_MAJORITY_MASK) - hlsl_report_message(loc, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, loc, HLSL_LEVEL_ERROR, "'row_major' or 'column_major' modifiers are only allowed for matrices."); } @@ -255,8 +252,8 @@ static bool implicit_compatible_data_types(struct hlsl_type *t1, struct hlsl_typ return false; } -static struct hlsl_ir_node *add_implicit_conversion(struct list *instrs, struct hlsl_ir_node *node, - struct hlsl_type *dst_type, struct source_location *loc) +static struct hlsl_ir_node *add_implicit_conversion(struct hlsl_ctx *ctx, struct list *instrs, + struct hlsl_ir_node *node, struct hlsl_type *dst_type, struct source_location *loc) { struct hlsl_type *src_type = node->data_type; struct hlsl_ir_expr *cast; @@ -266,13 +263,13 @@ static struct hlsl_ir_node *add_implicit_conversion(struct list *instrs, struct if (!implicit_compatible_data_types(src_type, dst_type)) { - hlsl_report_message(*loc, HLSL_LEVEL_ERROR, "can't implicitly convert %s to %s", + hlsl_report_message(ctx, *loc, HLSL_LEVEL_ERROR, "can't implicitly convert %s to %s", debug_hlsl_type(src_type), debug_hlsl_type(dst_type)); return NULL; } if (dst_type->dimx * dst_type->dimy < src_type->dimx * src_type->dimy) - hlsl_report_message(*loc, HLSL_LEVEL_WARNING, "implicit truncation of vector type"); + hlsl_report_message(ctx, *loc, HLSL_LEVEL_WARNING, "implicit truncation of vector type"); TRACE("Implicit conversion from %s to %s.\n", debug_hlsl_type(src_type), debug_hlsl_type(dst_type)); @@ -282,13 +279,13 @@ static struct hlsl_ir_node *add_implicit_conversion(struct list *instrs, struct return &cast->node; } -static bool declare_variable(struct hlsl_ir_var *decl, bool local) +static bool declare_variable(struct hlsl_ctx *ctx, struct hlsl_ir_var *decl, bool local) { bool ret; TRACE("Declaring variable %s.\n", decl->name); if (decl->data_type->type != HLSL_CLASS_MATRIX) - check_invalid_matrix_modifiers(decl->modifiers, decl->loc); + check_invalid_matrix_modifiers(ctx, decl->modifiers, decl->loc); if (local) { @@ -297,46 +294,46 @@ static bool declare_variable(struct hlsl_ir_var *decl, bool local) if (invalid) { - hlsl_report_message(decl->loc, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, decl->loc, HLSL_LEVEL_ERROR, "modifier '%s' invalid for local variables", hlsl_debug_modifiers(invalid)); } if (decl->semantic) { - hlsl_report_message(decl->loc, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, decl->loc, HLSL_LEVEL_ERROR, "semantics are not allowed on local variables"); return false; } } else { - if (hlsl_get_function(decl->name)) + if (hlsl_get_function(ctx, decl->name)) { - hlsl_report_message(decl->loc, HLSL_LEVEL_ERROR, "redefinition of '%s'", decl->name); + hlsl_report_message(ctx, decl->loc, HLSL_LEVEL_ERROR, "redefinition of '%s'", decl->name); return false; } } - ret = hlsl_add_var(hlsl_ctx.cur_scope, decl, local); + ret = hlsl_add_var(ctx, decl, local); if (!ret) { - struct hlsl_ir_var *old = hlsl_get_var(hlsl_ctx.cur_scope, decl->name); + struct hlsl_ir_var *old = hlsl_get_var(ctx->cur_scope, decl->name); - hlsl_report_message(decl->loc, HLSL_LEVEL_ERROR, "\"%s\" already declared", decl->name); - hlsl_report_message(old->loc, HLSL_LEVEL_NOTE, "\"%s\" was previously declared here", old->name); + hlsl_report_message(ctx, decl->loc, HLSL_LEVEL_ERROR, "\"%s\" already declared", decl->name); + hlsl_report_message(ctx, old->loc, HLSL_LEVEL_NOTE, "\"%s\" was previously declared here", old->name); return false; } return true; } -static DWORD add_modifiers(DWORD modifiers, DWORD mod, const struct source_location loc) +static DWORD add_modifiers(struct hlsl_ctx *ctx, DWORD modifiers, DWORD mod, const struct source_location loc) { if (modifiers & mod) { - hlsl_report_message(loc, HLSL_LEVEL_ERROR, "modifier '%s' already specified", hlsl_debug_modifiers(mod)); + hlsl_report_message(ctx, loc, HLSL_LEVEL_ERROR, "modifier '%s' already specified", hlsl_debug_modifiers(mod)); return modifiers; } if ((mod & HLSL_MODIFIERS_MAJORITY_MASK) && (modifiers & HLSL_MODIFIERS_MAJORITY_MASK)) { - hlsl_report_message(loc, HLSL_LEVEL_ERROR, "more than one matrix majority keyword"); + hlsl_report_message(ctx, loc, HLSL_LEVEL_ERROR, "more than one matrix majority keyword"); return modifiers; } return modifiers | mod; @@ -444,7 +441,7 @@ static void free_parse_initializer(struct parse_initializer *initializer) vkd3d_free(initializer->args); } -static struct hlsl_ir_swizzle *get_swizzle(struct hlsl_ir_node *value, const char *swizzle, +static struct hlsl_ir_swizzle *get_swizzle(struct hlsl_ctx *ctx, struct hlsl_ir_node *value, const char *swizzle, struct source_location *loc) { unsigned int len = strlen(swizzle), component = 0; @@ -487,7 +484,7 @@ static struct hlsl_ir_swizzle *get_swizzle(struct hlsl_ir_node *value, const cha swiz |= (y << 4 | x) << component * 8; component++; } - return hlsl_new_swizzle(swiz, component, value, loc); + return hlsl_new_swizzle(ctx, swiz, component, value, loc); } /* Vector swizzle */ @@ -520,32 +517,32 @@ static struct hlsl_ir_swizzle *get_swizzle(struct hlsl_ir_node *value, const cha component++; } if (valid) - return hlsl_new_swizzle(swiz, component, value, loc); + return hlsl_new_swizzle(ctx, swiz, component, value, loc); } return NULL; } -static struct hlsl_ir_jump *add_return(struct list *instrs, +static struct hlsl_ir_jump *add_return(struct hlsl_ctx *ctx, struct list *instrs, struct hlsl_ir_node *return_value, struct source_location loc) { - struct hlsl_type *return_type = hlsl_ctx.cur_function->return_type; + struct hlsl_type *return_type = ctx->cur_function->return_type; struct hlsl_ir_jump *jump; if (return_value) { struct hlsl_ir_assignment *assignment; - if (!(return_value = add_implicit_conversion(instrs, return_value, return_type, &loc))) + if (!(return_value = add_implicit_conversion(ctx, instrs, return_value, return_type, &loc))) return NULL; - if (!(assignment = hlsl_new_simple_assignment(hlsl_ctx.cur_function->return_var, return_value))) + if (!(assignment = hlsl_new_simple_assignment(ctx->cur_function->return_var, return_value))) return NULL; list_add_after(&return_value->entry, &assignment->node.entry); } else if (!hlsl_type_is_void(return_type)) { - hlsl_report_message(loc, HLSL_LEVEL_ERROR, "non-void function must return a value"); + hlsl_report_message(ctx, loc, HLSL_LEVEL_ERROR, "non-void function must return a value"); return NULL; } @@ -558,8 +555,8 @@ static struct hlsl_ir_jump *add_return(struct list *instrs, return jump; } -static struct hlsl_ir_load *add_load(struct list *instrs, struct hlsl_ir_node *var_node, struct hlsl_ir_node *offset, - struct hlsl_type *data_type, const struct source_location loc) +static struct hlsl_ir_load *add_load(struct hlsl_ctx *ctx, struct list *instrs, struct hlsl_ir_node *var_node, + struct hlsl_ir_node *offset, struct hlsl_type *data_type, const struct source_location loc) { struct hlsl_ir_node *add = NULL; struct hlsl_ir_load *load; @@ -584,7 +581,7 @@ static struct hlsl_ir_load *add_load(struct list *instrs, struct hlsl_ir_node *v char name[27]; sprintf(name, "", var_node); - if (!(var = hlsl_new_synthetic_var(name, var_node->data_type, var_node->loc))) + if (!(var = hlsl_new_synthetic_var(ctx, name, var_node->data_type, var_node->loc))) return NULL; TRACE("Synthesized variable %p for %s node.\n", var, hlsl_node_type_to_string(var_node->type)); @@ -604,19 +601,19 @@ static struct hlsl_ir_load *add_load(struct list *instrs, struct hlsl_ir_node *v return load; } -static struct hlsl_ir_load *add_record_load(struct list *instrs, struct hlsl_ir_node *record, +static struct hlsl_ir_load *add_record_load(struct hlsl_ctx *ctx, struct list *instrs, struct hlsl_ir_node *record, const struct hlsl_struct_field *field, const struct source_location loc) { struct hlsl_ir_constant *c; - if (!(c = hlsl_new_uint_constant(field->reg_offset * 4, loc))) + if (!(c = hlsl_new_uint_constant(ctx, field->reg_offset * 4, loc))) return NULL; list_add_tail(instrs, &c->node.entry); - return add_load(instrs, record, &c->node, field->type, loc); + return add_load(ctx, instrs, record, &c->node, field->type, loc); } -static struct hlsl_ir_load *add_array_load(struct list *instrs, struct hlsl_ir_node *array, +static struct hlsl_ir_load *add_array_load(struct hlsl_ctx *ctx, struct list *instrs, struct hlsl_ir_node *array, struct hlsl_ir_node *index, const struct source_location loc) { const struct hlsl_type *expr_type = array->data_type; @@ -639,13 +636,13 @@ static struct hlsl_ir_load *add_array_load(struct list *instrs, struct hlsl_ir_n else { if (expr_type->type == HLSL_CLASS_SCALAR) - hlsl_report_message(loc, HLSL_LEVEL_ERROR, "array-indexed expression is scalar"); + hlsl_report_message(ctx, loc, HLSL_LEVEL_ERROR, "array-indexed expression is scalar"); else - hlsl_report_message(loc, HLSL_LEVEL_ERROR, "expression is not array-indexable"); + hlsl_report_message(ctx, loc, HLSL_LEVEL_ERROR, "expression is not array-indexable"); return NULL; } - if (!(c = hlsl_new_uint_constant(data_type->reg_size * 4, loc))) + if (!(c = hlsl_new_uint_constant(ctx, data_type->reg_size * 4, loc))) return NULL; list_add_tail(instrs, &c->node.entry); if (!(mul = hlsl_new_binary_expr(HLSL_IR_BINOP_MUL, index, &c->node))) @@ -653,7 +650,7 @@ static struct hlsl_ir_load *add_array_load(struct list *instrs, struct hlsl_ir_n list_add_tail(instrs, &mul->entry); index = mul; - return add_load(instrs, array, index, data_type, loc); + return add_load(ctx, instrs, array, index, data_type, loc); } static bool add_struct_field(struct list *fields, struct hlsl_struct_field *field) @@ -676,7 +673,7 @@ bool hlsl_type_is_row_major(const struct hlsl_type *type) return !!(type->modifiers & HLSL_MODIFIER_ROW_MAJOR); } -static struct hlsl_type *apply_type_modifiers(struct hlsl_type *type, +static struct hlsl_type *apply_type_modifiers(struct hlsl_ctx *ctx, struct hlsl_type *type, unsigned int *modifiers, struct source_location loc) { unsigned int default_majority = 0; @@ -692,7 +689,7 @@ static struct hlsl_type *apply_type_modifiers(struct hlsl_type *type, && !(type->modifiers & HLSL_MODIFIERS_MAJORITY_MASK) && type->type == HLSL_CLASS_MATRIX) { - if (hlsl_ctx.matrix_majority == HLSL_COLUMN_MAJOR) + if (ctx->matrix_majority == HLSL_COLUMN_MAJOR) default_majority = HLSL_MODIFIER_COLUMN_MAJOR; else default_majority = HLSL_MODIFIER_ROW_MAJOR; @@ -701,10 +698,10 @@ static struct hlsl_type *apply_type_modifiers(struct hlsl_type *type, if (!default_majority && !(*modifiers & HLSL_TYPE_MODIFIERS_MASK)) return type; - if (!(new_type = hlsl_type_clone(type, default_majority))) + if (!(new_type = hlsl_type_clone(ctx, type, default_majority))) return NULL; - new_type->modifiers = add_modifiers(new_type->modifiers, *modifiers, loc); + new_type->modifiers = add_modifiers(ctx, new_type->modifiers, *modifiers, loc); *modifiers &= ~HLSL_TYPE_MODIFIERS_MASK; if (new_type->type == HLSL_CLASS_MATRIX) @@ -712,7 +709,8 @@ static struct hlsl_type *apply_type_modifiers(struct hlsl_type *type, return new_type; } -static struct list *gen_struct_fields(struct hlsl_type *type, DWORD modifiers, struct list *fields) +static struct list *gen_struct_fields(struct hlsl_ctx *ctx, struct hlsl_type *type, + DWORD modifiers, struct list *fields) { struct parse_variable_def *v, *v_next; struct hlsl_struct_field *field; @@ -733,7 +731,7 @@ static struct list *gen_struct_fields(struct hlsl_type *type, DWORD modifiers, s return list; } if (v->array_size) - field->type = hlsl_new_array_type(type, v->array_size); + field->type = hlsl_new_array_type(ctx, type, v->array_size); else field->type = type; field->name = v->name; @@ -741,7 +739,7 @@ static struct list *gen_struct_fields(struct hlsl_type *type, DWORD modifiers, s field->semantic = v->semantic; if (v->initializer.args_count) { - hlsl_report_message(v->loc, HLSL_LEVEL_ERROR, "struct field with an initializer.\n"); + hlsl_report_message(ctx, v->loc, HLSL_LEVEL_ERROR, "struct field with an initializer.\n"); free_parse_initializer(&v->initializer); } list_add_tail(list, &field->entry); @@ -751,7 +749,7 @@ static struct list *gen_struct_fields(struct hlsl_type *type, DWORD modifiers, s return list; } -static bool add_typedef(DWORD modifiers, struct hlsl_type *orig_type, struct list *list) +static bool add_typedef(struct hlsl_ctx *ctx, DWORD modifiers, struct hlsl_type *orig_type, struct list *list) { struct parse_variable_def *v, *v_next; struct hlsl_type *type; @@ -760,9 +758,9 @@ static bool add_typedef(DWORD modifiers, struct hlsl_type *orig_type, struct lis LIST_FOR_EACH_ENTRY_SAFE(v, v_next, list, struct parse_variable_def, entry) { if (v->array_size) - type = hlsl_new_array_type(orig_type, v->array_size); + type = hlsl_new_array_type(ctx, orig_type, v->array_size); else - type = hlsl_type_clone(orig_type, 0); + type = hlsl_type_clone(ctx, orig_type, 0); if (!type) return false; vkd3d_free((void *)type->name); @@ -770,17 +768,17 @@ static bool add_typedef(DWORD modifiers, struct hlsl_type *orig_type, struct lis type->modifiers |= modifiers; if (type->type != HLSL_CLASS_MATRIX) - check_invalid_matrix_modifiers(type->modifiers, v->loc); + check_invalid_matrix_modifiers(ctx, type->modifiers, v->loc); else type->reg_size = hlsl_type_is_row_major(type) ? type->dimy : type->dimx; if ((type->modifiers & HLSL_MODIFIER_COLUMN_MAJOR) && (type->modifiers & HLSL_MODIFIER_ROW_MAJOR)) - hlsl_report_message(v->loc, HLSL_LEVEL_ERROR, "more than one matrix majority keyword"); + hlsl_report_message(ctx, v->loc, HLSL_LEVEL_ERROR, "more than one matrix majority keyword"); - ret = hlsl_scope_add_type(hlsl_ctx.cur_scope, type); + ret = hlsl_scope_add_type(ctx->cur_scope, type); if (!ret) - hlsl_report_message(v->loc, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, v->loc, HLSL_LEVEL_ERROR, "redefinition of custom type '%s'", v->name); vkd3d_free(v); } @@ -788,7 +786,8 @@ static bool add_typedef(DWORD modifiers, struct hlsl_type *orig_type, struct lis return true; } -static bool add_func_parameter(struct list *list, struct parse_parameter *param, const struct source_location loc) +static bool add_func_parameter(struct hlsl_ctx *ctx, struct list *list, + struct parse_parameter *param, const struct source_location loc) { struct hlsl_ir_var *var; @@ -798,7 +797,7 @@ static bool add_func_parameter(struct list *list, struct parse_parameter *param, if (!(var = hlsl_new_var(param->name, param->type, loc, param->semantic, param->modifiers, param->reg_reservation))) return false; - if (!hlsl_add_var(hlsl_ctx.cur_scope, var, false)) + if (!hlsl_add_var(ctx, var, false)) { hlsl_free_var(var); return false; @@ -868,13 +867,13 @@ static const struct hlsl_ir_function_decl *get_overloaded_func(struct rb_tree *f return NULL; } -static struct hlsl_ir_function_decl *get_func_entry(const char *name) +static struct hlsl_ir_function_decl *get_func_entry(struct hlsl_ctx *ctx, const char *name) { struct hlsl_ir_function_decl *decl; struct hlsl_ir_function *func; struct rb_entry *entry; - if ((entry = rb_get(&hlsl_ctx.functions, name))) + if ((entry = rb_get(&ctx->functions, name))) { func = RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry); RB_FOR_EACH_ENTRY(decl, &func->overloads, struct hlsl_ir_function_decl, entry) @@ -1006,7 +1005,7 @@ static enum hlsl_base_type expr_common_base_type(enum hlsl_base_type t1, enum hl return t1_idx >= t2_idx ? t1 : t2; } -static struct hlsl_type *expr_common_type(struct hlsl_type *t1, struct hlsl_type *t2, +static struct hlsl_type *expr_common_type(struct hlsl_ctx *ctx, struct hlsl_type *t1, struct hlsl_type *t2, struct source_location *loc) { enum hlsl_type_class type; @@ -1015,7 +1014,7 @@ static struct hlsl_type *expr_common_type(struct hlsl_type *t1, struct hlsl_type if (t1->type > HLSL_CLASS_LAST_NUMERIC || t2->type > HLSL_CLASS_LAST_NUMERIC) { - hlsl_report_message(*loc, HLSL_LEVEL_ERROR, "non scalar/vector/matrix data type in expression"); + hlsl_report_message(ctx, *loc, HLSL_LEVEL_ERROR, "non scalar/vector/matrix data type in expression"); return NULL; } @@ -1024,7 +1023,7 @@ static struct hlsl_type *expr_common_type(struct hlsl_type *t1, struct hlsl_type if (!expr_compatible_data_types(t1, t2)) { - hlsl_report_message(*loc, HLSL_LEVEL_ERROR, "expression data types are incompatible"); + hlsl_report_message(ctx, *loc, HLSL_LEVEL_ERROR, "expression data types are incompatible"); return NULL; } @@ -1095,14 +1094,14 @@ static struct hlsl_type *expr_common_type(struct hlsl_type *t1, struct hlsl_type } if (type == HLSL_CLASS_SCALAR) - return hlsl_ctx.builtin_types.scalar[base]; + return ctx->builtin_types.scalar[base]; if (type == HLSL_CLASS_VECTOR) - return hlsl_ctx.builtin_types.vector[base][dimx - 1]; - return hlsl_new_type(NULL, type, base, dimx, dimy); + return ctx->builtin_types.vector[base][dimx - 1]; + return hlsl_new_type(ctx, NULL, type, base, dimx, dimy); } -static struct hlsl_ir_expr *add_expr(struct list *instrs, enum hlsl_ir_expr_op op, - struct hlsl_ir_node *operands[3], struct source_location *loc) +static struct hlsl_ir_expr *add_expr(struct hlsl_ctx *ctx, struct list *instrs, + enum hlsl_ir_expr_op op, struct hlsl_ir_node *operands[3], struct source_location *loc) { struct hlsl_ir_expr *expr; struct hlsl_type *type; @@ -1113,7 +1112,7 @@ static struct hlsl_ir_expr *add_expr(struct list *instrs, enum hlsl_ir_expr_op o { if (!operands[i]) break; - type = expr_common_type(type, operands[i]->data_type, loc); + type = expr_common_type(ctx, type, operands[i]->data_type, loc); if (!type) return NULL; } @@ -1129,7 +1128,7 @@ static struct hlsl_ir_expr *add_expr(struct list *instrs, enum hlsl_ir_expr_op o if (operands[i]->data_type->dimx * operands[i]->data_type->dimy != 1 && operands[i]->data_type->dimx * operands[i]->data_type->dimy != type->dimx * type->dimy) { - hlsl_report_message(operands[i]->loc, HLSL_LEVEL_WARNING, "implicit truncation of vector/matrix type"); + hlsl_report_message(ctx, operands[i]->loc, HLSL_LEVEL_WARNING, "implicit truncation of vector/matrix type"); } if (!(cast = hlsl_new_cast(operands[i], type, &operands[i]->loc))) @@ -1155,14 +1154,14 @@ static struct list *append_unop(struct list *list, struct hlsl_ir_node *node) return list; } -static struct list *add_binary_expr(struct list *list1, struct list *list2, +static struct list *add_binary_expr(struct hlsl_ctx *ctx, struct list *list1, struct list *list2, enum hlsl_ir_expr_op op, struct source_location loc) { struct hlsl_ir_node *args[3] = {node_from_list(list1), node_from_list(list2)}; list_move_tail(list1, list2); vkd3d_free(list2); - add_expr(list1, op, args, &loc); + add_expr(ctx, list1, op, args, &loc); return list1; } @@ -1222,7 +1221,7 @@ static bool invert_swizzle(unsigned int *swizzle, unsigned int *writemask, unsig return true; } -static struct hlsl_ir_node *add_assignment(struct list *instrs, struct hlsl_ir_node *lhs, +static struct hlsl_ir_node *add_assignment(struct hlsl_ctx *ctx, struct list *instrs, struct hlsl_ir_node *lhs, enum parse_assign_op assign_op, struct hlsl_ir_node *rhs) { struct hlsl_ir_assignment *assign; @@ -1234,7 +1233,7 @@ static struct hlsl_ir_node *add_assignment(struct list *instrs, struct hlsl_ir_n { writemask = (1 << lhs_type->dimx) - 1; - if (!(rhs = add_implicit_conversion(instrs, rhs, lhs_type, &rhs->loc))) + if (!(rhs = add_implicit_conversion(ctx, instrs, rhs, lhs_type, &rhs->loc))) return NULL; } @@ -1268,18 +1267,18 @@ static struct hlsl_ir_node *add_assignment(struct list *instrs, struct hlsl_ir_n hlsl_src_from_node(&swizzle->val, rhs); if (!invert_swizzle(&swizzle->swizzle, &writemask, &width)) { - hlsl_report_message(lhs->loc, HLSL_LEVEL_ERROR, "invalid writemask"); + hlsl_report_message(ctx, lhs->loc, HLSL_LEVEL_ERROR, "invalid writemask"); vkd3d_free(assign); return NULL; } assert(swizzle_type->type == HLSL_CLASS_VECTOR); if (swizzle_type->dimx != width) - swizzle->node.data_type = hlsl_ctx.builtin_types.vector[swizzle_type->base_type][width - 1]; + swizzle->node.data_type = ctx->builtin_types.vector[swizzle_type->base_type][width - 1]; rhs = &swizzle->node; } else { - hlsl_report_message(lhs->loc, HLSL_LEVEL_ERROR, "invalid lvalue"); + hlsl_report_message(ctx, lhs->loc, HLSL_LEVEL_ERROR, "invalid lvalue"); vkd3d_free(assign); return NULL; } @@ -1307,7 +1306,7 @@ static struct hlsl_ir_node *add_assignment(struct list *instrs, struct hlsl_ir_n return &assign->node; } -static void struct_var_initializer(struct list *list, struct hlsl_ir_var *var, +static void struct_var_initializer(struct hlsl_ctx *ctx, struct list *list, struct hlsl_ir_var *var, struct parse_initializer *initializer) { struct hlsl_type *type = var->data_type; @@ -1316,7 +1315,7 @@ static void struct_var_initializer(struct list *list, struct hlsl_ir_var *var, if (initializer_size(initializer) != hlsl_type_component_count(type)) { - hlsl_report_message(var->loc, HLSL_LEVEL_ERROR, "structure initializer mismatch"); + hlsl_report_message(ctx, var->loc, HLSL_LEVEL_ERROR, "structure initializer mismatch"); free_parse_initializer(initializer); return; } @@ -1335,7 +1334,7 @@ static void struct_var_initializer(struct list *list, struct hlsl_ir_var *var, if (hlsl_type_component_count(field->type) == hlsl_type_component_count(node->data_type)) { - if (!(c = hlsl_new_uint_constant(field->reg_offset * 4, node->loc))) + if (!(c = hlsl_new_uint_constant(ctx, field->reg_offset * 4, node->loc))) break; list_add_tail(list, &c->node.entry); @@ -1359,7 +1358,8 @@ static void free_parse_variable_def(struct parse_variable_def *v) vkd3d_free(v); } -static struct list *declare_vars(struct hlsl_type *basic_type, DWORD modifiers, struct list *var_list) +static struct list *declare_vars(struct hlsl_ctx *ctx, struct hlsl_type *basic_type, + DWORD modifiers, struct list *var_list) { struct parse_variable_def *v, *v_next; struct list *statements_list; @@ -1385,7 +1385,7 @@ static struct list *declare_vars(struct hlsl_type *basic_type, DWORD modifiers, LIST_FOR_EACH_ENTRY_SAFE(v, v_next, var_list, struct parse_variable_def, entry) { if (v->array_size) - type = hlsl_new_array_type(basic_type, v->array_size); + type = hlsl_new_array_type(ctx, basic_type, v->array_size); else type = basic_type; @@ -1396,7 +1396,7 @@ static struct list *declare_vars(struct hlsl_type *basic_type, DWORD modifiers, } debug_dump_decl(type, modifiers, v->name, v->loc.line); - if (hlsl_ctx.cur_scope == hlsl_ctx.globals) + if (ctx->cur_scope == ctx->globals) { var->modifiers |= HLSL_STORAGE_UNIFORM; local = false; @@ -1404,13 +1404,13 @@ static struct list *declare_vars(struct hlsl_type *basic_type, DWORD modifiers, if (type->modifiers & HLSL_MODIFIER_CONST && !(var->modifiers & HLSL_STORAGE_UNIFORM) && !v->initializer.args_count) { - hlsl_report_message(v->loc, HLSL_LEVEL_ERROR, "const variable without initializer"); + hlsl_report_message(ctx, v->loc, HLSL_LEVEL_ERROR, "const variable without initializer"); hlsl_free_var(var); vkd3d_free(v); continue; } - ret = declare_variable(var, local); + ret = declare_variable(ctx, var, local); if (!ret) { hlsl_free_var(var); @@ -1430,7 +1430,7 @@ static struct list *declare_vars(struct hlsl_type *basic_type, DWORD modifiers, { if (size < type->dimx * type->dimy) { - hlsl_report_message(v->loc, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, v->loc, HLSL_LEVEL_ERROR, "'%s' initializer does not match", v->name); free_parse_initializer(&v->initializer); vkd3d_free(v); @@ -1440,7 +1440,7 @@ static struct list *declare_vars(struct hlsl_type *basic_type, DWORD modifiers, if ((type->type == HLSL_CLASS_STRUCT || type->type == HLSL_CLASS_ARRAY) && hlsl_type_component_count(type) != size) { - hlsl_report_message(v->loc, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, v->loc, HLSL_LEVEL_ERROR, "'%s' initializer does not match", v->name); free_parse_initializer(&v->initializer); vkd3d_free(v); @@ -1449,7 +1449,7 @@ static struct list *declare_vars(struct hlsl_type *basic_type, DWORD modifiers, if (type->type == HLSL_CLASS_STRUCT) { - struct_var_initializer(statements_list, var, &v->initializer); + struct_var_initializer(ctx, statements_list, var, &v->initializer); vkd3d_free(v); continue; } @@ -1477,11 +1477,11 @@ static struct list *declare_vars(struct hlsl_type *basic_type, DWORD modifiers, load = hlsl_new_var_load(var, var->loc); list_add_tail(v->initializer.instrs, &load->node.entry); - add_assignment(v->initializer.instrs, &load->node, ASSIGN_OP_ASSIGN, v->initializer.args[0]); + add_assignment(ctx, v->initializer.instrs, &load->node, ASSIGN_OP_ASSIGN, v->initializer.args[0]); vkd3d_free(v->initializer.args); if (modifiers & HLSL_STORAGE_STATIC) - list_move_tail(&hlsl_ctx.static_initializers, v->initializer.instrs); + list_move_tail(&ctx->static_initializers, v->initializer.instrs); else list_move_tail(statements_list, v->initializer.instrs); vkd3d_free(v->initializer.instrs); @@ -1497,7 +1497,11 @@ static struct list *declare_vars(struct hlsl_type *basic_type, DWORD modifiers, %locations %define parse.error verbose %define api.prefix {hlsl_} +%define api.pure full %expect 1 +%lex-param {yyscan_t scanner} +%parse-param {void *scanner} +%parse-param {struct hlsl_ctx *ctx} %union { @@ -1711,21 +1715,21 @@ hlsl_prog: { const struct hlsl_ir_function_decl *decl; - decl = get_overloaded_func(&hlsl_ctx.functions, $2.name, $2.decl->parameters, true); + decl = get_overloaded_func(&ctx->functions, $2.name, $2.decl->parameters, true); if (decl && !decl->func->intrinsic) { if (decl->body && $2.decl->body) { - hlsl_report_message($2.decl->loc, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, $2.decl->loc, HLSL_LEVEL_ERROR, "redefinition of function %s", debugstr_a($2.name)); YYABORT; } else if (!hlsl_type_compare(decl->return_type, $2.decl->return_type)) { - hlsl_report_message($2.decl->loc, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, $2.decl->loc, HLSL_LEVEL_ERROR, "redefining function %s with a different return type", debugstr_a($2.name)); - hlsl_report_message(decl->loc, HLSL_LEVEL_NOTE, + hlsl_report_message(ctx, decl->loc, HLSL_LEVEL_NOTE, "%s previously declared here", debugstr_a($2.name)); YYABORT; @@ -1734,12 +1738,12 @@ hlsl_prog: if (hlsl_type_is_void($2.decl->return_type) && $2.decl->semantic) { - hlsl_report_message($2.decl->loc, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, $2.decl->loc, HLSL_LEVEL_ERROR, "void function with a semantic"); } TRACE("Adding function '%s' to the function list.\n", $2.name); - hlsl_add_function(&hlsl_ctx.functions, $2.name, $2.decl, false); + hlsl_add_function(&ctx->functions, $2.name, $2.decl, false); } | hlsl_prog declaration_statement { @@ -1761,16 +1765,16 @@ preproc_directive: const char **new_array = NULL; TRACE("Updating line information to file %s, line %u.\n", debugstr_a($2), $1); - hlsl_ctx.line_no = $1; - if (strcmp($2, hlsl_ctx.source_file)) - new_array = vkd3d_realloc(hlsl_ctx.source_files, - sizeof(*hlsl_ctx.source_files) * (hlsl_ctx.source_files_count + 1)); + ctx->line_no = $1; + if (strcmp($2, ctx->source_file)) + new_array = vkd3d_realloc(ctx->source_files, + sizeof(*ctx->source_files) * (ctx->source_files_count + 1)); if (new_array) { - hlsl_ctx.source_files = new_array; - hlsl_ctx.source_files[hlsl_ctx.source_files_count++] = $2; - hlsl_ctx.source_file = $2; + ctx->source_files = new_array; + ctx->source_files[ctx->source_files_count++] = $2; + ctx->source_file = $2; } else { @@ -1788,19 +1792,19 @@ struct_declaration: { if (!$2->name) { - hlsl_report_message(@2, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @2, HLSL_LEVEL_ERROR, "anonymous struct declaration with no variables"); } if (modifiers) { - hlsl_report_message(@1, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @1, HLSL_LEVEL_ERROR, "modifier not allowed on struct type declaration"); } } - if (!(type = apply_type_modifiers($2, &modifiers, @1))) + if (!(type = apply_type_modifiers(ctx, $2, &modifiers, @1))) YYABORT; - $$ = declare_vars(type, modifiers, $3); + $$ = declare_vars(ctx, type, modifiers, $3); } struct_spec: @@ -1813,18 +1817,18 @@ named_struct_spec: bool ret; TRACE("Structure %s declaration.\n", debugstr_a($2)); - $$ = hlsl_new_struct_type($2, $4); + $$ = hlsl_new_struct_type(ctx, $2, $4); - if (hlsl_get_var(hlsl_ctx.cur_scope, $2)) + if (hlsl_get_var(ctx->cur_scope, $2)) { - hlsl_report_message(@2, HLSL_LEVEL_ERROR, "redefinition of '%s'", $2); + hlsl_report_message(ctx, @2, HLSL_LEVEL_ERROR, "redefinition of '%s'", $2); YYABORT; } - ret = hlsl_scope_add_type(hlsl_ctx.cur_scope, $$); + ret = hlsl_scope_add_type(ctx->cur_scope, $$); if (!ret) { - hlsl_report_message(@2, HLSL_LEVEL_ERROR, "redefinition of struct '%s'", $2); + hlsl_report_message(ctx, @2, HLSL_LEVEL_ERROR, "redefinition of struct '%s'", $2); YYABORT; } } @@ -1833,7 +1837,7 @@ unnamed_struct_spec: KW_STRUCT '{' fields_list '}' { TRACE("Anonymous structure declaration.\n"); - $$ = hlsl_new_struct_type(NULL, $3); + $$ = hlsl_new_struct_type(ctx, NULL, $3); } any_identifier: @@ -1858,7 +1862,7 @@ fields_list: ret = add_struct_field($$, field); if (ret == false) { - hlsl_report_message(@2, + hlsl_report_message(ctx, @2, HLSL_LEVEL_ERROR, "redefinition of '%s'", field->name); vkd3d_free(field); } @@ -1876,9 +1880,9 @@ field: struct hlsl_type *type; DWORD modifiers = $1; - if (!(type = apply_type_modifiers($2, &modifiers, @1))) + if (!(type = apply_type_modifiers(ctx, $2, &modifiers, @1))) YYABORT; - $$ = gen_struct_fields(type, modifiers, $3); + $$ = gen_struct_fields(ctx, type, modifiers, $3); } func_declaration: @@ -1887,13 +1891,13 @@ func_declaration: TRACE("Function %s parsed.\n", $1.name); $$ = $1; $$.decl->body = $2; - hlsl_pop_scope(&hlsl_ctx); + hlsl_pop_scope(ctx); } | func_prototype ';' { TRACE("Function prototype for %s.\n", $1.name); $$ = $1; - hlsl_pop_scope(&hlsl_ctx); + hlsl_pop_scope(ctx); } func_prototype: @@ -1902,18 +1906,18 @@ func_prototype: { if ($1) { - hlsl_report_message(@1, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @1, HLSL_LEVEL_ERROR, "unexpected modifiers on a function"); YYABORT; } - if (hlsl_get_var(hlsl_ctx.globals, $3)) + if (hlsl_get_var(ctx->globals, $3)) { - hlsl_report_message(@3, HLSL_LEVEL_ERROR, "redefinition of '%s'\n", $3); + hlsl_report_message(ctx, @3, HLSL_LEVEL_ERROR, "redefinition of '%s'\n", $3); YYABORT; } if (hlsl_type_is_void($2) && $7.semantic) { - hlsl_report_message(@7, HLSL_LEVEL_ERROR, "void function with a semantic"); + hlsl_report_message(ctx, @7, HLSL_LEVEL_ERROR, "void function with a semantic"); } if ($7.reg_reservation) @@ -1921,10 +1925,10 @@ func_prototype: FIXME("Unexpected register reservation for a function.\n"); vkd3d_free($7.reg_reservation); } - if (!($$.decl = hlsl_new_func_decl($2, $5, $7.semantic, @3))) + if (!($$.decl = hlsl_new_func_decl(ctx, $2, $5, $7.semantic, @3))) YYABORT; $$.name = $3; - hlsl_ctx.cur_function = $$.decl; + ctx->cur_function = $$.decl; } compound_statement: @@ -1935,14 +1939,14 @@ compound_statement: } | '{' scope_start statement_list '}' { - hlsl_pop_scope(&hlsl_ctx); + hlsl_pop_scope(ctx); $$ = $3; } scope_start: /* empty */ { - hlsl_push_scope(&hlsl_ctx); + hlsl_push_scope(ctx); } var_identifier: @@ -2004,19 +2008,19 @@ param_list: { $$ = vkd3d_malloc(sizeof(*$$)); list_init($$); - if (!add_func_parameter($$, &$1, @1)) + if (!add_func_parameter(ctx, $$, &$1, @1)) { ERR("Error adding function parameter %s.\n", $1.name); - set_parse_status(&hlsl_ctx.status, PARSE_ERR); + set_parse_status(&ctx->status, PARSE_ERR); YYABORT; } } | param_list ',' parameter { $$ = $1; - if (!add_func_parameter($$, &$3, @3)) + if (!add_func_parameter(ctx, $$, &$3, @3)) { - hlsl_report_message(@3, HLSL_LEVEL_ERROR, "duplicate parameter %s", $3.name); + hlsl_report_message(ctx, @3, HLSL_LEVEL_ERROR, "duplicate parameter %s", $3.name); YYABORT; } } @@ -2027,7 +2031,7 @@ parameter: struct hlsl_type *type; DWORD modifiers = $2; - if (!(type = apply_type_modifiers($3, &modifiers, @2))) + if (!(type = apply_type_modifiers(ctx, $3, &modifiers, @2))) YYABORT; $$.modifiers = $1 ? $1 : HLSL_STORAGE_IN; @@ -2047,7 +2051,7 @@ input_mods: { if ($1 & $2) { - hlsl_report_message(@2, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @2, HLSL_LEVEL_ERROR, "duplicate input-output modifiers"); YYABORT; } @@ -2077,78 +2081,78 @@ type: { if ($3->type != HLSL_CLASS_SCALAR) { - hlsl_report_message(@3, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @3, HLSL_LEVEL_ERROR, "vectors of non-scalar types are not allowed\n"); YYABORT; } if ($5 < 1 || $5 > 4) { - hlsl_report_message(@5, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @5, HLSL_LEVEL_ERROR, "vector size must be between 1 and 4\n"); YYABORT; } - $$ = hlsl_new_type(NULL, HLSL_CLASS_VECTOR, $3->base_type, $5, 1); + $$ = hlsl_new_type(ctx, NULL, HLSL_CLASS_VECTOR, $3->base_type, $5, 1); } | KW_MATRIX '<' base_type ',' C_INTEGER ',' C_INTEGER '>' { if ($3->type != HLSL_CLASS_SCALAR) { - hlsl_report_message(@3, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @3, HLSL_LEVEL_ERROR, "matrices of non-scalar types are not allowed\n"); YYABORT; } if ($5 < 1 || $5 > 4) { - hlsl_report_message(@5, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @5, HLSL_LEVEL_ERROR, "matrix row count must be between 1 and 4\n"); YYABORT; } if ($7 < 1 || $7 > 4) { - hlsl_report_message(@7, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @7, HLSL_LEVEL_ERROR, "matrix column count must be between 1 and 4\n"); YYABORT; } - $$ = hlsl_new_type(NULL, HLSL_CLASS_MATRIX, $3->base_type, $7, $5); + $$ = hlsl_new_type(ctx, NULL, HLSL_CLASS_MATRIX, $3->base_type, $7, $5); } base_type: KW_VOID { - $$ = hlsl_ctx.builtin_types.Void; + $$ = ctx->builtin_types.Void; } | KW_SAMPLER { - $$ = hlsl_ctx.builtin_types.sampler[HLSL_SAMPLER_DIM_GENERIC]; + $$ = ctx->builtin_types.sampler[HLSL_SAMPLER_DIM_GENERIC]; } | KW_SAMPLER1D { - $$ = hlsl_ctx.builtin_types.sampler[HLSL_SAMPLER_DIM_1D]; + $$ = ctx->builtin_types.sampler[HLSL_SAMPLER_DIM_1D]; } | KW_SAMPLER2D { - $$ = hlsl_ctx.builtin_types.sampler[HLSL_SAMPLER_DIM_2D]; + $$ = ctx->builtin_types.sampler[HLSL_SAMPLER_DIM_2D]; } | KW_SAMPLER3D { - $$ = hlsl_ctx.builtin_types.sampler[HLSL_SAMPLER_DIM_3D]; + $$ = ctx->builtin_types.sampler[HLSL_SAMPLER_DIM_3D]; } | KW_SAMPLERCUBE { - $$ = hlsl_ctx.builtin_types.sampler[HLSL_SAMPLER_DIM_3D]; + $$ = ctx->builtin_types.sampler[HLSL_SAMPLER_DIM_3D]; } | TYPE_IDENTIFIER { - $$ = hlsl_get_type(hlsl_ctx.cur_scope, $1, true); + $$ = hlsl_get_type(ctx->cur_scope, $1, true); vkd3d_free($1); } | KW_STRUCT TYPE_IDENTIFIER { - $$ = hlsl_get_type(hlsl_ctx.cur_scope, $2, true); + $$ = hlsl_get_type(ctx->cur_scope, $2, true); if ($$->type != HLSL_CLASS_STRUCT) - hlsl_report_message(@1, HLSL_LEVEL_ERROR, "'%s' redefined as a structure\n", $2); + hlsl_report_message(ctx, @1, HLSL_LEVEL_ERROR, "'%s' redefined as a structure\n", $2); vkd3d_free($2); } @@ -2172,13 +2176,13 @@ typedef: if ($2 & ~HLSL_TYPE_MODIFIERS_MASK) { struct parse_variable_def *v, *v_next; - hlsl_report_message(@1, HLSL_LEVEL_ERROR, "modifier not allowed on typedefs"); + hlsl_report_message(ctx, @1, HLSL_LEVEL_ERROR, "modifier not allowed on typedefs"); LIST_FOR_EACH_ENTRY_SAFE(v, v_next, $4, struct parse_variable_def, entry) vkd3d_free(v); vkd3d_free($4); YYABORT; } - if (!add_typedef($2, $3, $4)) + if (!add_typedef(ctx, $2, $3, $4)) YYABORT; } @@ -2210,9 +2214,9 @@ declaration: struct hlsl_type *type; DWORD modifiers = $1; - if (!(type = apply_type_modifiers($2, &modifiers, @1))) + if (!(type = apply_type_modifiers(ctx, $2, &modifiers, @1))) YYABORT; - $$ = declare_vars(type, modifiers, $3); + $$ = declare_vars(ctx, type, modifiers, $3); } variables_def_optional: @@ -2270,7 +2274,7 @@ array: if (!size) { - hlsl_report_message(@2, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @2, HLSL_LEVEL_ERROR, "array size is not a positive integer constant\n"); YYABORT; } @@ -2278,7 +2282,7 @@ array: if (size > 65536) { - hlsl_report_message(@2, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @2, HLSL_LEVEL_ERROR, "array size must be between 1 and 65536"); YYABORT; } @@ -2292,47 +2296,47 @@ var_modifiers: } | KW_EXTERN var_modifiers { - $$ = add_modifiers($2, HLSL_STORAGE_EXTERN, @1); + $$ = add_modifiers(ctx, $2, HLSL_STORAGE_EXTERN, @1); } | KW_NOINTERPOLATION var_modifiers { - $$ = add_modifiers($2, HLSL_STORAGE_NOINTERPOLATION, @1); + $$ = add_modifiers(ctx, $2, HLSL_STORAGE_NOINTERPOLATION, @1); } | KW_PRECISE var_modifiers { - $$ = add_modifiers($2, HLSL_MODIFIER_PRECISE, @1); + $$ = add_modifiers(ctx, $2, HLSL_MODIFIER_PRECISE, @1); } | KW_SHARED var_modifiers { - $$ = add_modifiers($2, HLSL_STORAGE_SHARED, @1); + $$ = add_modifiers(ctx, $2, HLSL_STORAGE_SHARED, @1); } | KW_GROUPSHARED var_modifiers { - $$ = add_modifiers($2, HLSL_STORAGE_GROUPSHARED, @1); + $$ = add_modifiers(ctx, $2, HLSL_STORAGE_GROUPSHARED, @1); } | KW_STATIC var_modifiers { - $$ = add_modifiers($2, HLSL_STORAGE_STATIC, @1); + $$ = add_modifiers(ctx, $2, HLSL_STORAGE_STATIC, @1); } | KW_UNIFORM var_modifiers { - $$ = add_modifiers($2, HLSL_STORAGE_UNIFORM, @1); + $$ = add_modifiers(ctx, $2, HLSL_STORAGE_UNIFORM, @1); } | KW_VOLATILE var_modifiers { - $$ = add_modifiers($2, HLSL_STORAGE_VOLATILE, @1); + $$ = add_modifiers(ctx, $2, HLSL_STORAGE_VOLATILE, @1); } | KW_CONST var_modifiers { - $$ = add_modifiers($2, HLSL_MODIFIER_CONST, @1); + $$ = add_modifiers(ctx, $2, HLSL_MODIFIER_CONST, @1); } | KW_ROW_MAJOR var_modifiers { - $$ = add_modifiers($2, HLSL_MODIFIER_ROW_MAJOR, @1); + $$ = add_modifiers(ctx, $2, HLSL_MODIFIER_ROW_MAJOR, @1); } | KW_COLUMN_MAJOR var_modifiers { - $$ = add_modifiers($2, HLSL_MODIFIER_COLUMN_MAJOR, @1); + $$ = add_modifiers(ctx, $2, HLSL_MODIFIER_COLUMN_MAJOR, @1); } complex_initializer: @@ -2405,7 +2409,7 @@ statement: jump_statement: KW_RETURN expr ';' { - if (!add_return($2, node_from_list($2), @1)) + if (!add_return(ctx, $2, node_from_list($2), @1)) YYABORT; $$ = $2; } @@ -2414,7 +2418,7 @@ jump_statement: if (!($$ = vkd3d_malloc(sizeof(*$$)))) YYABORT; list_init($$); - if (!add_return($$, NULL, @1)) + if (!add_return(ctx, $$, NULL, @1)) YYABORT; } @@ -2431,7 +2435,7 @@ selection_statement: vkd3d_free($5.then_instrs); vkd3d_free($5.else_instrs); if (condition->data_type->dimx > 1 || condition->data_type->dimy > 1) - hlsl_report_message(instr->node.loc, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, instr->node.loc, HLSL_LEVEL_ERROR, "if condition requires a scalar"); $$ = $3; list_add_tail($$, &instr->node.entry); @@ -2461,15 +2465,15 @@ loop_statement: | KW_FOR '(' scope_start expr_statement expr_statement expr ')' statement { $$ = create_loop(LOOP_FOR, $4, $5, $6, $8, @1); - hlsl_pop_scope(&hlsl_ctx); + hlsl_pop_scope(ctx); } | KW_FOR '(' scope_start declaration expr_statement expr ')' statement { if (!$4) - hlsl_report_message(@4, HLSL_LEVEL_WARNING, + hlsl_report_message(ctx, @4, HLSL_LEVEL_WARNING, "no expressions in for loop initializer"); $$ = create_loop(LOOP_FOR, $4, $5, $6, $8, @1); - hlsl_pop_scope(&hlsl_ctx); + hlsl_pop_scope(ctx); } expr_statement: @@ -2490,7 +2494,7 @@ primary_expr: if (!(c = vkd3d_malloc(sizeof(*c)))) YYABORT; - init_node(&c->node, HLSL_IR_CONSTANT, hlsl_ctx.builtin_types.scalar[HLSL_TYPE_FLOAT], @1); + init_node(&c->node, HLSL_IR_CONSTANT, ctx->builtin_types.scalar[HLSL_TYPE_FLOAT], @1); c->value.f[0] = $1; if (!($$ = make_list(&c->node))) YYABORT; @@ -2501,7 +2505,7 @@ primary_expr: if (!(c = vkd3d_malloc(sizeof(*c)))) YYABORT; - init_node(&c->node, HLSL_IR_CONSTANT, hlsl_ctx.builtin_types.scalar[HLSL_TYPE_INT], @1); + init_node(&c->node, HLSL_IR_CONSTANT, ctx->builtin_types.scalar[HLSL_TYPE_INT], @1); c->value.i[0] = $1; if (!($$ = make_list(&c->node))) YYABORT; @@ -2512,7 +2516,7 @@ primary_expr: if (!(c = vkd3d_malloc(sizeof(*c)))) YYABORT; - init_node(&c->node, HLSL_IR_CONSTANT, hlsl_ctx.builtin_types.scalar[HLSL_TYPE_BOOL], @1); + init_node(&c->node, HLSL_IR_CONSTANT, ctx->builtin_types.scalar[HLSL_TYPE_BOOL], @1); c->value.b[0] = $1; if (!($$ = make_list(&c->node))) YYABORT; @@ -2522,9 +2526,9 @@ primary_expr: struct hlsl_ir_load *load; struct hlsl_ir_var *var; - if (!(var = hlsl_get_var(hlsl_ctx.cur_scope, $1))) + if (!(var = hlsl_get_var(ctx->cur_scope, $1))) { - hlsl_report_message(@1, HLSL_LEVEL_ERROR, "variable '%s' is not declared\n", $1); + hlsl_report_message(ctx, @1, HLSL_LEVEL_ERROR, "variable '%s' is not declared\n", $1); YYABORT; } if ((load = hlsl_new_var_load(var, @1))) @@ -2548,12 +2552,12 @@ postfix_expr: if (node_from_list($1)->data_type->modifiers & HLSL_MODIFIER_CONST) { - hlsl_report_message(@2, HLSL_LEVEL_ERROR, "modifying a const expression"); + hlsl_report_message(ctx, @2, HLSL_LEVEL_ERROR, "modifying a const expression"); YYABORT; } inc = hlsl_new_unary_expr(HLSL_IR_UNOP_POSTINC, node_from_list($1), @2); /* Post increment/decrement expressions are considered const */ - inc->data_type = hlsl_type_clone(inc->data_type, 0); + inc->data_type = hlsl_type_clone(ctx, inc->data_type, 0); inc->data_type->modifiers |= HLSL_MODIFIER_CONST; $$ = append_unop($1, inc); } @@ -2563,12 +2567,12 @@ postfix_expr: if (node_from_list($1)->data_type->modifiers & HLSL_MODIFIER_CONST) { - hlsl_report_message(@2, HLSL_LEVEL_ERROR, "modifying a const expression"); + hlsl_report_message(ctx, @2, HLSL_LEVEL_ERROR, "modifying a const expression"); YYABORT; } inc = hlsl_new_unary_expr(HLSL_IR_UNOP_POSTDEC, node_from_list($1), @2); /* Post increment/decrement expressions are considered const */ - inc->data_type = hlsl_type_clone(inc->data_type, 0); + inc->data_type = hlsl_type_clone(ctx, inc->data_type, 0); inc->data_type->modifiers |= HLSL_MODIFIER_CONST; $$ = append_unop($1, inc); } @@ -2586,7 +2590,7 @@ postfix_expr: { if (!strcmp($3, field->name)) { - if (!add_record_load($1, node, field, @2)) + if (!add_record_load(ctx, $1, node, field, @2)) YYABORT; $$ = $1; break; @@ -2594,7 +2598,7 @@ postfix_expr: } if (!$$) { - hlsl_report_message(@3, HLSL_LEVEL_ERROR, "invalid subscript %s", debugstr_a($3)); + hlsl_report_message(ctx, @3, HLSL_LEVEL_ERROR, "invalid subscript %s", debugstr_a($3)); YYABORT; } } @@ -2602,16 +2606,16 @@ postfix_expr: { struct hlsl_ir_swizzle *swizzle; - if (!(swizzle = get_swizzle(node, $3, &@3))) + if (!(swizzle = get_swizzle(ctx, node, $3, &@3))) { - hlsl_report_message(@3, HLSL_LEVEL_ERROR, "invalid swizzle %s", debugstr_a($3)); + hlsl_report_message(ctx, @3, HLSL_LEVEL_ERROR, "invalid swizzle %s", debugstr_a($3)); YYABORT; } $$ = append_unop($1, &swizzle->node); } else { - hlsl_report_message(@3, HLSL_LEVEL_ERROR, "invalid subscript %s", debugstr_a($3)); + hlsl_report_message(ctx, @3, HLSL_LEVEL_ERROR, "invalid subscript %s", debugstr_a($3)); YYABORT; } } @@ -2624,12 +2628,12 @@ postfix_expr: if (index->data_type->type != HLSL_CLASS_SCALAR) { - hlsl_report_message(@3, HLSL_LEVEL_ERROR, "array index is not scalar"); + hlsl_report_message(ctx, @3, HLSL_LEVEL_ERROR, "array index is not scalar"); hlsl_free_instr_list($1); YYABORT; } - if (!add_array_load($1, array, index, @2)) + if (!add_array_load(ctx, $1, array, index, @2)) { hlsl_free_instr_list($1); YYABORT; @@ -2649,19 +2653,19 @@ postfix_expr: if ($1) { - hlsl_report_message(@1, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @1, HLSL_LEVEL_ERROR, "unexpected modifier on a constructor\n"); YYABORT; } if ($2->type > HLSL_CLASS_LAST_NUMERIC) { - hlsl_report_message(@2, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @2, HLSL_LEVEL_ERROR, "constructors may only be used with numeric data types\n"); YYABORT; } if ($2->dimx * $2->dimy != initializer_size(&$4)) { - hlsl_report_message(@4, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, @4, HLSL_LEVEL_ERROR, "expected %u components in constructor, but got %u\n", $2->dimx * $2->dimy, initializer_size(&$4)); YYABORT; @@ -2671,7 +2675,7 @@ postfix_expr: FIXME("Matrix constructors are not supported yet.\n"); sprintf(name, "", counter++); - if (!(var = hlsl_new_synthetic_var(name, $2, @2))) + if (!(var = hlsl_new_synthetic_var(ctx, name, $2, @2))) YYABORT; for (i = 0; i < $4.args_count; ++i) { @@ -2680,7 +2684,7 @@ postfix_expr: if (arg->data_type->type == HLSL_CLASS_OBJECT) { - hlsl_report_message(arg->loc, HLSL_LEVEL_ERROR, "invalid constructor argument"); + hlsl_report_message(ctx, arg->loc, HLSL_LEVEL_ERROR, "invalid constructor argument"); continue; } width = hlsl_type_component_count(arg->data_type); @@ -2691,8 +2695,8 @@ postfix_expr: continue; } - if (!(arg = add_implicit_conversion($4.instrs, arg, - hlsl_ctx.builtin_types.vector[$2->base_type][width - 1], &arg->loc))) + if (!(arg = add_implicit_conversion(ctx, $4.instrs, arg, + ctx->builtin_types.vector[$2->base_type][width - 1], &arg->loc))) continue; if (!(assignment = hlsl_new_assignment(var, NULL, arg, @@ -2713,7 +2717,7 @@ unary_expr: { if (node_from_list($2)->data_type->modifiers & HLSL_MODIFIER_CONST) { - hlsl_report_message(@1, HLSL_LEVEL_ERROR, "modifying a const expression"); + hlsl_report_message(ctx, @1, HLSL_LEVEL_ERROR, "modifying a const expression"); YYABORT; } $$ = append_unop($2, hlsl_new_unary_expr(HLSL_IR_UNOP_PREINC, node_from_list($2), @1)); @@ -2722,7 +2726,7 @@ unary_expr: { if (node_from_list($2)->data_type->modifiers & HLSL_MODIFIER_CONST) { - hlsl_report_message(@1, HLSL_LEVEL_ERROR, "modifying a const expression"); + hlsl_report_message(ctx, @1, HLSL_LEVEL_ERROR, "modifying a const expression"); YYABORT; } $$ = append_unop($2, hlsl_new_unary_expr(HLSL_IR_UNOP_PREDEC, node_from_list($2), @1)); @@ -2746,18 +2750,18 @@ unary_expr: if ($2) { - hlsl_report_message(@3, HLSL_LEVEL_ERROR, "unexpected modifier in a cast"); + hlsl_report_message(ctx, @3, HLSL_LEVEL_ERROR, "unexpected modifier in a cast"); YYABORT; } if ($4) - dst_type = hlsl_new_array_type($3, $4); + dst_type = hlsl_new_array_type(ctx, $3, $4); else dst_type = $3; if (!compatible_data_types(src_type, dst_type)) { - hlsl_report_message(@3, HLSL_LEVEL_ERROR, "can't cast from %s to %s", + hlsl_report_message(ctx, @3, HLSL_LEVEL_ERROR, "can't cast from %s to %s", debug_hlsl_type(src_type), debug_hlsl_type(dst_type)); YYABORT; } @@ -2787,26 +2791,26 @@ mul_expr: unary_expr | mul_expr '*' unary_expr { - $$ = add_binary_expr($1, $3, HLSL_IR_BINOP_MUL, @2); + $$ = add_binary_expr(ctx, $1, $3, HLSL_IR_BINOP_MUL, @2); } | mul_expr '/' unary_expr { - $$ = add_binary_expr($1, $3, HLSL_IR_BINOP_DIV, @2); + $$ = add_binary_expr(ctx, $1, $3, HLSL_IR_BINOP_DIV, @2); } | mul_expr '%' unary_expr { - $$ = add_binary_expr($1, $3, HLSL_IR_BINOP_MOD, @2); + $$ = add_binary_expr(ctx, $1, $3, HLSL_IR_BINOP_MOD, @2); } add_expr: mul_expr | add_expr '+' mul_expr { - $$ = add_binary_expr($1, $3, HLSL_IR_BINOP_ADD, @2); + $$ = add_binary_expr(ctx, $1, $3, HLSL_IR_BINOP_ADD, @2); } | add_expr '-' mul_expr { - $$ = add_binary_expr($1, $3, HLSL_IR_BINOP_SUB, @2); + $$ = add_binary_expr(ctx, $1, $3, HLSL_IR_BINOP_SUB, @2); } shift_expr: @@ -2824,30 +2828,30 @@ relational_expr: shift_expr | relational_expr '<' shift_expr { - $$ = add_binary_expr($1, $3, HLSL_IR_BINOP_LESS, @2); + $$ = add_binary_expr(ctx, $1, $3, HLSL_IR_BINOP_LESS, @2); } | relational_expr '>' shift_expr { - $$ = add_binary_expr($1, $3, HLSL_IR_BINOP_GREATER, @2); + $$ = add_binary_expr(ctx, $1, $3, HLSL_IR_BINOP_GREATER, @2); } | relational_expr OP_LE shift_expr { - $$ = add_binary_expr($1, $3, HLSL_IR_BINOP_LEQUAL, @2); + $$ = add_binary_expr(ctx, $1, $3, HLSL_IR_BINOP_LEQUAL, @2); } | relational_expr OP_GE shift_expr { - $$ = add_binary_expr($1, $3, HLSL_IR_BINOP_GEQUAL, @2); + $$ = add_binary_expr(ctx, $1, $3, HLSL_IR_BINOP_GEQUAL, @2); } equality_expr: relational_expr | equality_expr OP_EQ relational_expr { - $$ = add_binary_expr($1, $3, HLSL_IR_BINOP_EQUAL, @2); + $$ = add_binary_expr(ctx, $1, $3, HLSL_IR_BINOP_EQUAL, @2); } | equality_expr OP_NE relational_expr { - $$ = add_binary_expr($1, $3, HLSL_IR_BINOP_NEQUAL, @2); + $$ = add_binary_expr(ctx, $1, $3, HLSL_IR_BINOP_NEQUAL, @2); } bitand_expr: @@ -2901,12 +2905,12 @@ assignment_expr: if (lhs->data_type->modifiers & HLSL_MODIFIER_CONST) { - hlsl_report_message(@2, HLSL_LEVEL_ERROR, "l-value is const"); + hlsl_report_message(ctx, @2, HLSL_LEVEL_ERROR, "l-value is const"); YYABORT; } list_move_tail($3, $1); vkd3d_free($1); - if (!add_assignment($3, lhs, $2, rhs)) + if (!add_assignment(ctx, $3, lhs, $2, rhs)) YYABORT; $$ = $3; } @@ -3084,11 +3088,11 @@ static void compute_liveness_recurse(struct list *instrs, unsigned int loop_firs } } -static void compute_liveness(struct hlsl_ir_function_decl *entry_func) +static void compute_liveness(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func) { struct hlsl_ir_var *var; - LIST_FOR_EACH_ENTRY(var, &hlsl_ctx.globals->vars, struct hlsl_ir_var, scope_entry) + LIST_FOR_EACH_ENTRY(var, &ctx->globals->vars, struct hlsl_ir_var, scope_entry) { var->first_write = 1; } @@ -3107,16 +3111,16 @@ static void compute_liveness(struct hlsl_ir_function_decl *entry_func) compute_liveness_recurse(entry_func->body, 0, 0); } -int hlsl_parser_compile(const char *entrypoint) +int hlsl_parser_compile(struct hlsl_ctx *ctx, const char *entrypoint) { struct hlsl_ir_function_decl *entry_func; - hlsl_parse(); + yyparse(ctx->scanner, ctx); - if (hlsl_ctx.status == PARSE_ERR) + if (ctx->status == PARSE_ERR) return VKD3D_ERROR_INVALID_SHADER; - if (!(entry_func = get_func_entry(entrypoint))) + if (!(entry_func = get_func_entry(ctx, entrypoint))) { hlsl_message("error: entry point %s is not defined\n", debugstr_a(entrypoint)); return VKD3D_ERROR_INVALID_SHADER; @@ -3125,11 +3129,11 @@ int hlsl_parser_compile(const char *entrypoint) if (!hlsl_type_is_void(entry_func->return_type) && entry_func->return_type->type != HLSL_CLASS_STRUCT && !entry_func->semantic) { - hlsl_report_message(entry_func->loc, HLSL_LEVEL_ERROR, + hlsl_report_message(ctx, entry_func->loc, HLSL_LEVEL_ERROR, "entry point \"%s\" is missing a return value semantic", entry_func->func->name); } - list_move_head(entry_func->body, &hlsl_ctx.static_initializers); + list_move_head(entry_func->body, &ctx->static_initializers); /* Index 0 means unused; index 1 means function entry, so start at 2. */ index_instructions(entry_func->body, 2); @@ -3137,12 +3141,12 @@ int hlsl_parser_compile(const char *entrypoint) if (TRACE_ON()) { TRACE("IR dump.\n"); - rb_for_each_entry(&hlsl_ctx.functions, dump_function, NULL); + rb_for_each_entry(&ctx->functions, dump_function, NULL); } - compute_liveness(entry_func); + compute_liveness(ctx, entry_func); - if (hlsl_ctx.status == PARSE_ERR) + if (ctx->status == PARSE_ERR) return VKD3D_ERROR_INVALID_SHADER; return VKD3D_ERROR_NOT_IMPLEMENTED; }