[PATCH 5/5] d3dcompiler: Parse variable declarations.
Matteo Bruni
mbruni at codeweavers.com
Mon Jun 4 10:58:24 CDT 2012
---
dlls/d3dcompiler_43/d3dcompiler_private.h | 134 ++++++++++++++++++++
dlls/d3dcompiler_43/hlsl.y | 188 ++++++++++++++++++++++++++++-
dlls/d3dcompiler_43/utils.c | 157 ++++++++++++++++++++++++
3 files changed, 478 insertions(+), 1 deletions(-)
diff --git a/dlls/d3dcompiler_43/d3dcompiler_private.h b/dlls/d3dcompiler_43/d3dcompiler_private.h
index ec6e6e4..3ee0ed5 100644
--- a/dlls/d3dcompiler_43/d3dcompiler_private.h
+++ b/dlls/d3dcompiler_43/d3dcompiler_private.h
@@ -588,12 +588,131 @@ struct bwriter_shader *SlAssembleShader(const char *text, char **messages) DECLS
HRESULT SlWriteBytecode(const struct bwriter_shader *shader, int dxversion, DWORD **result, DWORD *size) DECLSPEC_HIDDEN;
void SlDeleteShader(struct bwriter_shader *shader) DECLSPEC_HIDDEN;
+/* The general IR structure is inspired by Mesa GLSL hir, even though the code
+ * ends up being quite different in practice. Anyway, here comes the relevant
+ * licensing information.
+ *
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+enum hlsl_base_type
+{
+ HLSL_TYPE_FLOAT,
+ HLSL_TYPE_HALF,
+ HLSL_TYPE_DOUBLE,
+ HLSL_TYPE_INT,
+ HLSL_TYPE_UINT,
+ HLSL_TYPE_BOOL,
+ HLSL_TYPE_LAST_SCALAR = HLSL_TYPE_BOOL,
+ HLSL_TYPE_SAMPLER,
+ HLSL_TYPE_TEXTURE,
+ HLSL_TYPE_PIXELSHADER,
+ HLSL_TYPE_VERTEXSHADER,
+ HLSL_TYPE_STRING,
+ HLSL_TYPE_STRUCT,
+ HLSL_TYPE_ARRAY,
+ HLSL_TYPE_VOID,
+};
+
enum hlsl_matrix_majority
{
HLSL_COLUMN_MAJOR,
HLSL_ROW_MAJOR
};
+struct hlsl_type
+{
+ struct list entry;
+ struct list scope_entry;
+ enum hlsl_base_type base_type;
+ const char *name;
+ unsigned int modifiers;
+ unsigned int dimx;
+ unsigned int dimy;
+ union
+ {
+ struct list *elements;
+ struct
+ {
+ struct hlsl_type *type;
+ unsigned int elements_count;
+ } array;
+ } e;
+};
+
+struct hlsl_struct_field
+{
+ struct list entry;
+ struct hlsl_type *type;
+ const char *name;
+ const char *semantic;
+ DWORD modifiers;
+};
+
+enum hlsl_ir_node_type
+{
+ HLSL_IR_VAR = 0,
+};
+
+struct hlsl_ir_node
+{
+ struct list entry;
+ enum hlsl_ir_node_type type;
+ struct hlsl_type *data_type;
+
+ char *source_file;
+ unsigned int line;
+ unsigned int column;
+};
+
+struct hlsl_ir_var
+{
+ struct hlsl_ir_node node;
+ const char *name;
+ const char *semantic;
+ unsigned int modifiers;
+ struct list scope_entry;
+
+ struct hlsl_var_allocation *allocation;
+};
+
+struct hlsl_scope
+{
+ struct list entry;
+ struct list vars;
+ struct list types;
+ struct hlsl_scope *upper;
+};
+
+/* Structures used only during parsing */
+struct parse_variable_def
+{
+ struct list entry;
+ char *name;
+ unsigned int array_size;
+ char *semantic;
+ struct list *initializer;
+};
+
struct hlsl_parse_ctx
{
char *source_file;
@@ -614,12 +733,27 @@ struct hlsl_parse_ctx
extern struct hlsl_parse_ctx hlsl_ctx DECLSPEC_HIDDEN;
void hlsl_message(const char *fmt, ...) PRINTF_ATTR(1,2) DECLSPEC_HIDDEN;
+
+BOOL add_declaration(struct hlsl_scope *scope, struct hlsl_ir_var *decl, BOOL local_var) DECLSPEC_HIDDEN;
struct hlsl_ir_var *get_variable(struct hlsl_scope *scope, const char *name) DECLSPEC_HIDDEN;
+void free_declaration(struct hlsl_ir_var *decl) DECLSPEC_HIDDEN;
+struct hlsl_type *new_hlsl_type(const char *name, enum hlsl_base_type base_type, unsigned dimx, unsigned dimy) DECLSPEC_HIDDEN;
+struct hlsl_type *new_array_type(struct hlsl_type *basic_type, unsigned int array_size) DECLSPEC_HIDDEN;
struct hlsl_type *get_type(struct hlsl_scope *scope, const char *name, BOOL recursive) DECLSPEC_HIDDEN;
BOOL find_function(const char *name) DECLSPEC_HIDDEN;
+unsigned int components_count_type(struct hlsl_type *type) DECLSPEC_HIDDEN;
+struct hlsl_ir_deref *new_var_deref(struct hlsl_ir_var *var) DECLSPEC_HIDDEN;
+void push_scope(struct hlsl_parse_ctx *ctx) DECLSPEC_HIDDEN;
+BOOL pop_scope(struct hlsl_parse_ctx *ctx) DECLSPEC_HIDDEN;
struct bwriter_shader *parse_hlsl_shader(const char *text, enum shader_type type, DWORD version,
const char *entrypoint, char **messages) DECLSPEC_HIDDEN;
+const char *debug_base_type(const struct hlsl_type *type) DECLSPEC_HIDDEN;
+const char *debug_hlsl_type(const struct hlsl_type *type) DECLSPEC_HIDDEN;
+const char *debug_modifiers(DWORD modifiers) DECLSPEC_HIDDEN;
+void free_hlsl_type(struct hlsl_type *type) DECLSPEC_HIDDEN;
+
+
#define MAKE_TAG(ch0, ch1, ch2, ch3) \
((DWORD)(ch0) | ((DWORD)(ch1) << 8) | \
((DWORD)(ch2) << 16) | ((DWORD)(ch3) << 24 ))
diff --git a/dlls/d3dcompiler_43/hlsl.y b/dlls/d3dcompiler_43/hlsl.y
index b00226e..8461529 100644
--- a/dlls/d3dcompiler_43/hlsl.y
+++ b/dlls/d3dcompiler_43/hlsl.y
@@ -47,15 +47,43 @@ static void hlsl_error(const char *s)
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
}
+static void debug_dump_decl(struct hlsl_type *type, DWORD modifiers, const char *declname, unsigned int line_no)
+{
+ TRACE("Line %u: ", line_no);
+ TRACE("%s %s;\n", debug_hlsl_type(type), declname);
+}
+
+static BOOL declare_variable(struct hlsl_ir_var *decl, BOOL local)
+{
+ BOOL ret;
+
+ TRACE("Declaring variable %s.\n", decl->name);
+ ret = add_declaration(hlsl_ctx.cur_scope, decl, local);
+ if (ret == FALSE)
+ {
+ struct hlsl_ir_var *old = get_variable(hlsl_ctx.cur_scope, decl->name);
+
+ hlsl_message("Line %u: \"%s\" already declared.\n", hlsl_ctx.line_no, decl->name);
+ hlsl_message("Line %u: \"%s\" was previously declared here.\n", old->node.line, decl->name);
+ set_parse_status(&hlsl_ctx.status, PARSE_ERR);
+ return FALSE;
+ }
+ return TRUE;
+}
+
%}
%error-verbose
%union
{
- char *name;
+ struct hlsl_type *type;
INT intval;
FLOAT floatval;
+ char *name;
+ DWORD modifiers;
+ struct list *list;
+ struct parse_variable_def *variable_def;
}
%token KW_BLENDSTATE
@@ -160,14 +188,26 @@ static void hlsl_error(const char *s)
%token <intval> PRE_LINE
%token <name> VAR_IDENTIFIER TYPE_IDENTIFIER NEW_IDENTIFIER
+%type <name> any_identifier
%token <name> STRING
%token <floatval> C_FLOAT
%token <intval> C_INTEGER
+%type <type> base_type
+%type <type> type
+%type <modifiers> var_modifiers
+%type <intval> array
+%type <name> semantic
+%type <variable_def> variable_def
+%type <list> variables_def
%%
hlsl_prog: /* empty */
{
}
+ | hlsl_prog declaration_statement
+ {
+ TRACE("Declaration statement parsed.\n");
+ }
| hlsl_prog preproc_directive
{
}
@@ -180,17 +220,163 @@ preproc_directive: PRE_LINE STRING
hlsl_ctx.source_file = $2;
}
+any_identifier: VAR_IDENTIFIER
+ | TYPE_IDENTIFIER
+ | NEW_IDENTIFIER
+
+semantic: /* Empty */
+ {
+ $$ = NULL;
+ }
+ | ':' any_identifier
+ {
+ $$ = $2;
+ }
+
+type: base_type
+ {
+ $$ = $1;
+ }
+
+base_type: KW_VOID
+ {
+ $$ = new_hlsl_type("void", HLSL_TYPE_VOID, 1, 1);
+ }
+ | TYPE_IDENTIFIER
+ {
+ struct hlsl_type *type;
+
+ TRACE("Type %s.\n", $1);
+ type = get_type(hlsl_ctx.cur_scope, $1, TRUE);
+ $$ = type;
+ d3dcompiler_free($1);
+ }
+ | KW_STRUCT TYPE_IDENTIFIER
+ {
+ struct hlsl_type *type;
+
+ TRACE("Struct type %s.\n", $2);
+ type = get_type(hlsl_ctx.cur_scope, $2, TRUE);
+ if (type->base_type != HLSL_TYPE_STRUCT)
+ {
+ hlsl_message("Line %u: Redefining %s as a structure.\n",
+ hlsl_ctx.line_no, $2);
+ set_parse_status(&hlsl_ctx.status, PARSE_ERR);
+ }
+ else
+ {
+ $$ = type;
+ }
+ d3dcompiler_free($2);
+ }
+
+declaration_statement: declaration
+ {
+ }
+
+declaration: var_modifiers type variables_def ';'
+ {
+ struct parse_variable_def *v, *v_next;
+ struct hlsl_ir_var *var;
+ BOOL ret, local = TRUE;
+
+ LIST_FOR_EACH_ENTRY_SAFE(v, v_next, $3, struct parse_variable_def, entry)
+ {
+ debug_dump_decl($2, $1, v->name, hlsl_ctx.line_no);
+ var = d3dcompiler_alloc(sizeof(*var));
+ var->node.type = HLSL_IR_VAR;
+ if (v->array_size)
+ var->node.data_type = new_array_type($2, v->array_size);
+ else
+ var->node.data_type = $2;
+ var->name = v->name;
+ var->modifiers = $1;
+ var->semantic = v->semantic;
+ var->node.line = hlsl_ctx.line_no;
+ if (v->initializer)
+ {
+ FIXME("Variable with an initializer.\n");
+ }
+
+ ret = declare_variable(var, local);
+ if (ret == FALSE)
+ free_declaration(var);
+ else
+ TRACE("Declared variable %s.\n", var->name);
+ d3dcompiler_free(v);
+ }
+ d3dcompiler_free($3);
+ }
+
+variables_def: variable_def
+ {
+ $$ = d3dcompiler_alloc(sizeof(*$$));
+ list_init($$);
+ list_add_head($$, &$1->entry);
+ }
+ | variables_def ',' variable_def
+ {
+ $$ = $1;
+ list_add_tail($$, &$3->entry);
+ }
+
+ /* FIXME: Local variables can't have semantics. */
+variable_def: any_identifier array semantic
+ {
+ $$ = d3dcompiler_alloc(sizeof(*$$));
+ $$->name = $1;
+ $$->array_size = $2;
+ $$->semantic = $3;
+ }
+
+array: /* Empty */
+ {
+ $$ = 0;
+ }
+
+var_modifiers: /* Empty */
+ {
+ $$ = 0;
+ }
+
%%
struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD version, const char *entrypoint, char **messages)
{
+ struct hlsl_scope *scope, *next_scope;
+ struct hlsl_type *hlsl_type, *next_type;
+ struct hlsl_ir_var *var, *next_var;
+
hlsl_ctx.line_no = 1;
hlsl_ctx.source_file = d3dcompiler_strdup("");
+ hlsl_ctx.cur_scope = NULL;
hlsl_ctx.matrix_majority = HLSL_COLUMN_MAJOR;
+ list_init(&hlsl_ctx.scopes);
+ list_init(&hlsl_ctx.types);
+ list_init(&hlsl_ctx.functions);
+
+ push_scope(&hlsl_ctx);
+ hlsl_ctx.globals = hlsl_ctx.cur_scope;
hlsl_parse();
d3dcompiler_free(hlsl_ctx.source_file);
+ TRACE("Freeing variables.\n");
+ LIST_FOR_EACH_ENTRY_SAFE(scope, next_scope, &hlsl_ctx.scopes, struct hlsl_scope, entry)
+ {
+ LIST_FOR_EACH_ENTRY_SAFE(var, next_var, &scope->vars, struct hlsl_ir_var, scope_entry)
+ {
+ free_declaration(var);
+ }
+ d3dcompiler_free(scope);
+ }
+
+ TRACE("Freeing types.\n");
+ LIST_FOR_EACH_ENTRY_SAFE(hlsl_type, next_type, &hlsl_ctx.types, struct hlsl_type, entry)
+ {
+ free_hlsl_type(hlsl_type);
+ }
+
return NULL;
}
diff --git a/dlls/d3dcompiler_43/utils.c b/dlls/d3dcompiler_43/utils.c
index d512a14..eaf2566 100644
--- a/dlls/d3dcompiler_43/utils.c
+++ b/dlls/d3dcompiler_43/utils.c
@@ -761,8 +761,71 @@ void compilation_message(struct compilation_messages *msg, const char *fmt, va_l
}
}
+BOOL add_declaration(struct hlsl_scope *scope, struct hlsl_ir_var *decl, BOOL local_var)
+{
+ struct hlsl_ir_var *var;
+
+ LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
+ {
+ if (!strcmp(decl->name, var->name))
+ return FALSE;
+ }
+ if (local_var)
+ {
+ LIST_FOR_EACH_ENTRY(var, &scope->upper->vars, struct hlsl_ir_var, scope_entry)
+ {
+ if (!strcmp(decl->name, var->name))
+ return FALSE;
+ }
+ }
+
+ list_add_tail(&scope->vars, &decl->scope_entry);
+ return TRUE;
+}
+
struct hlsl_ir_var *get_variable(struct hlsl_scope *scope, const char *name)
{
+ struct hlsl_ir_var *var;
+
+ LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
+ {
+ if (!strcmp(name, var->name))
+ return var;
+ }
+ if (!scope->upper)
+ return NULL;
+ return get_variable(scope->upper, name);
+}
+
+void free_declaration(struct hlsl_ir_var *decl)
+{
+ d3dcompiler_free((void *)decl->name);
+ d3dcompiler_free((void *)decl->semantic);
+ d3dcompiler_free(decl);
+}
+
+struct hlsl_type *new_hlsl_type(const char *name, enum hlsl_base_type base_type, unsigned dimx, unsigned dimy)
+{
+ struct hlsl_type *type;
+
+ type = d3dcompiler_alloc(sizeof(*type));
+ if (!type)
+ {
+ ERR("Out of memory\n");
+ return NULL;
+ }
+ type->name = name;
+ type->base_type = base_type;
+ type->dimx = dimx;
+ type->dimy = dimy;
+
+ list_add_tail(&hlsl_ctx.types, &type->entry);
+
+ return type;
+}
+
+struct hlsl_type *new_array_type(struct hlsl_type *basic_type, unsigned int array_size)
+{
FIXME("stub.\n");
return NULL;
}
@@ -778,3 +841,97 @@ BOOL find_function(const char *name)
FIXME("stub.\n");
return FALSE;
}
+
+void push_scope(struct hlsl_parse_ctx *ctx)
+{
+ struct hlsl_scope *new_scope = d3dcompiler_alloc(sizeof(*new_scope));
+
+ if (!new_scope)
+ {
+ ERR("Out of memory!\n");
+ return;
+ }
+ list_init(&new_scope->vars);
+ list_init(&new_scope->types);
+ new_scope->upper = ctx->cur_scope;
+ ctx->cur_scope = new_scope;
+ list_add_tail(&ctx->scopes, &new_scope->entry);
+}
+
+BOOL pop_scope(struct hlsl_parse_ctx *ctx)
+{
+ struct hlsl_scope *prev_scope = ctx->cur_scope->upper;
+ if (!prev_scope)
+ return FALSE;
+
+ ctx->cur_scope = prev_scope;
+ return TRUE;
+}
+
+const char *debug_base_type(const struct hlsl_type *type)
+{
+ const char *name = "(unknown)";
+
+ switch (type->base_type)
+ {
+ case HLSL_TYPE_FLOAT: name = "float"; break;
+ case HLSL_TYPE_HALF: name = "half"; break;
+ case HLSL_TYPE_INT: name = "int"; break;
+ case HLSL_TYPE_UINT: name = "uint"; break;
+ case HLSL_TYPE_BOOL: name = "bool"; break;
+ case HLSL_TYPE_STRUCT: name = "struct"; break;
+ case HLSL_TYPE_ARRAY: name = "array"; break;
+ default:
+ FIXME("Unhandled case %u\n", type->base_type);
+ }
+ return name;
+}
+
+const char *debug_hlsl_type(const struct hlsl_type *type)
+{
+ const char *name;
+
+ if (type->name)
+ return debugstr_a(type->name);
+
+ if (type->base_type == HLSL_TYPE_STRUCT)
+ name = "<anonymous struct>";
+ else
+ name = debug_base_type(type);
+ if (type->dimx == 1 && type->dimy == 1)
+ return wine_dbg_sprintf("%s", name);
+ if (type->dimy == 1)
+ return wine_dbg_sprintf("vector<%s, %u>", name, type->dimx);
+ return wine_dbg_sprintf("matrix<%s, %u, %u>", name, type->dimx, type->dimy);
+}
+
+const char *debug_node_type(enum hlsl_ir_node_type type)
+{
+ const char *names[] =
+ {
+ "HLSL_IR_VAR",
+ };
+
+ if (type > sizeof(names) / sizeof(names[0]))
+ {
+ return "Unexpected node type";
+ }
+ return names[type];
+}
+
+void free_hlsl_type(struct hlsl_type *type)
+{
+ struct hlsl_struct_field *field, *next_field;
+
+ d3dcompiler_free((void *)type->name);
+ if (type->base_type == HLSL_TYPE_STRUCT)
+ {
+ LIST_FOR_EACH_ENTRY_SAFE(field, next_field, type->e.elements, struct hlsl_struct_field, entry)
+ {
+ d3dcompiler_free((void *)field->name);
+ d3dcompiler_free((void *)field->semantic);
+ d3dcompiler_free(field);
+ }
+ }
+ d3dcompiler_free(type);
+}
--
1.7.3.4
More information about the wine-patches
mailing list