ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/d3dcompiler_43/hlsl.y

2049 lines
79 KiB
Plaintext
Raw Normal View History

d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
/*
* HLSL parser
*
* Copyright 2008 Stefan Dösinger
* Copyright 2012 Matteo Bruni for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
%{
#include "config.h"
#include "wine/debug.h"
#include <stdio.h>
#include "d3dcompiler_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(hlsl_parser);
d3dcompiler: Add a stub lexer.
2012-05-15 16:12:57 +02:00
int hlsl_lex(void);
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
struct hlsl_parse_ctx hlsl_ctx;
d3dcompiler: Store (and begin to use) location information for variables.
2012-07-12 16:01:35 +02:00
struct YYLTYPE;
static void set_location(struct source_location *loc, const struct YYLTYPE *l);
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
void hlsl_message(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
compilation_message(&hlsl_ctx.messages, fmt, args);
va_end(args);
}
d3dcompiler: Add hlsl_report_message function to standardize error messages.
2012-07-12 16:01:32 +02:00
static const char *hlsl_get_error_level_name(enum hlsl_error_level level)
{
const char *names[] =
{
"error",
"warning",
"note",
};
return names[level];
}
void hlsl_report_message(const char *filename, DWORD line, DWORD column,
enum hlsl_error_level level, const char *fmt, ...)
{
va_list args;
char *string = NULL;
int rc, size = 0;
while (1)
{
va_start(args, fmt);
rc = vsnprintf(string, size, fmt, args);
va_end(args);
if (rc >= 0 && rc < size)
break;
if (rc >= size)
size = rc + 1;
else
size = size ? size * 2 : 32;
if (!string)
string = d3dcompiler_alloc(size);
else
string = d3dcompiler_realloc(string, size);
if (!string)
{
ERR("Error reallocating memory for a string.\n");
return;
}
}
hlsl_message("%s:%u:%u: %s: %s\n", filename, line, column, hlsl_get_error_level_name(level), string);
d3dcompiler_free(string);
if (level == HLSL_LEVEL_ERROR)
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
else if (level == HLSL_LEVEL_WARNING)
set_parse_status(&hlsl_ctx.status, PARSE_WARN);
}
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
static void hlsl_error(const char *s)
{
d3dcompiler: Track the location of each lexer token.
2012-07-12 16:01:33 +02:00
hlsl_report_message(hlsl_ctx.source_file, hlsl_ctx.line_no, hlsl_ctx.column, HLSL_LEVEL_ERROR, "%s", s);
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
static void debug_dump_decl(struct hlsl_type *type, DWORD modifiers, const char *declname, unsigned int line_no)
{
TRACE("Line %u: ", line_no);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
if (modifiers)
TRACE("%s ", debug_modifiers(modifiers));
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
TRACE("%s %s;\n", debug_hlsl_type(type), declname);
}
d3dcompiler: Check for invalid matrix majority modifiers.
2012-07-18 16:25:11 +02:00
static void check_invalid_matrix_modifiers(DWORD modifiers, struct source_location *loc)
{
if (modifiers & (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR))
{
hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR,
"'row_major' or 'column_major' modifiers are only allowed for matrices");
}
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
static BOOL declare_variable(struct hlsl_ir_var *decl, BOOL local)
{
BOOL ret;
TRACE("Declaring variable %s.\n", decl->name);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
if (decl->node.data_type->type == HLSL_CLASS_MATRIX)
{
if (!(decl->modifiers & (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR)))
{
decl->modifiers |= hlsl_ctx.matrix_majority == HLSL_ROW_MAJOR
? HLSL_MODIFIER_ROW_MAJOR : HLSL_MODIFIER_COLUMN_MAJOR;
}
}
d3dcompiler: Check for invalid matrix majority modifiers.
2012-07-18 16:25:11 +02:00
else
check_invalid_matrix_modifiers(decl->modifiers, &decl->node.loc);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
if (local)
{
DWORD invalid = decl->modifiers & (HLSL_STORAGE_EXTERN | HLSL_STORAGE_SHARED
| HLSL_STORAGE_GROUPSHARED | HLSL_STORAGE_UNIFORM);
if (invalid)
{
d3dcompiler: Store (and begin to use) location information for variables.
2012-07-12 16:01:35 +02:00
hlsl_report_message(decl->node.loc.file, decl->node.loc.line, decl->node.loc.col, HLSL_LEVEL_ERROR,
"modifier '%s' invalid for local variables", debug_modifiers(invalid));
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
d3dcompiler: Don't allow semantics on local variables.
2012-07-18 16:25:13 +02:00
if (decl->semantic)
{
hlsl_report_message(decl->node.loc.file, decl->node.loc.line, decl->node.loc.col, HLSL_LEVEL_ERROR,
"semantics are not allowed on local variables");
return FALSE;
}
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
d3dcompiler: Variables and functions can't have the same name.
2012-07-16 20:39:21 +02:00
else
{
if (find_function(decl->name))
{
hlsl_report_message(decl->node.loc.file, decl->node.loc.line, decl->node.loc.col, HLSL_LEVEL_ERROR,
"redefinition of '%s'", decl->name);
return FALSE;
}
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
ret = add_declaration(hlsl_ctx.cur_scope, decl, local);
d3dcompiler: Variables and functions can't have the same name.
2012-07-16 20:39:21 +02:00
if (!ret)
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
{
struct hlsl_ir_var *old = get_variable(hlsl_ctx.cur_scope, decl->name);
d3dcompiler: Store (and begin to use) location information for variables.
2012-07-12 16:01:35 +02:00
hlsl_report_message(decl->node.loc.file, decl->node.loc.line, decl->node.loc.col, HLSL_LEVEL_ERROR,
"\"%s\" already declared", decl->name);
hlsl_report_message(old->node.loc.file, old->node.loc.line, old->node.loc.col, HLSL_LEVEL_NOTE,
"\"%s\" was previously declared here", old->name);
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
return FALSE;
}
return TRUE;
}
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
static DWORD add_modifier(DWORD modifiers, DWORD mod, const struct YYLTYPE *loc);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
d3dcompiler: Parse "typedef" statement.
2012-09-19 19:46:13 +02:00
static BOOL check_type_modifiers(DWORD modifiers, struct source_location *loc)
{
if (modifiers & ~HLSL_TYPE_MODIFIERS_MASK)
{
hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR,
"modifier not allowed on typedefs");
return FALSE;
}
return TRUE;
}
d3dcompiler_43: Make add_type_to_scope() static.
2012-09-19 20:12:17 +02:00
static BOOL add_type_to_scope(struct hlsl_scope *scope, struct hlsl_type *def)
d3dcompiler: Declare predefined data types.
2012-09-18 18:18:05 +02:00
{
if (get_type(scope, def->name, FALSE))
return FALSE;
d3dcompiler: Store data types in a RB tree for faster search.
2012-09-19 19:46:12 +02:00
wine_rb_put(&scope->types, def->name, &def->scope_entry);
d3dcompiler: Declare predefined data types.
2012-09-18 18:18:05 +02:00
return TRUE;
}
static void declare_predefined_types(struct hlsl_scope *scope)
{
struct hlsl_type *type;
unsigned int x, y, bt;
static const char *names[] =
{
"float",
"half",
"double",
"int",
"uint",
"bool",
};
char name[10];
for (bt = 0; bt <= HLSL_TYPE_LAST_SCALAR; ++bt)
{
for (y = 1; y <= 4; ++y)
{
for (x = 1; x <= 4; ++x)
{
sprintf(name, "%s%ux%u", names[bt], x, y);
type = new_hlsl_type(d3dcompiler_strdup(name), HLSL_CLASS_MATRIX, bt, x, y);
add_type_to_scope(scope, type);
if (y == 1)
{
sprintf(name, "%s%u", names[bt], x);
type = new_hlsl_type(d3dcompiler_strdup(name), HLSL_CLASS_VECTOR, bt, x, y);
add_type_to_scope(scope, type);
if (x == 1)
{
sprintf(name, "%s", names[bt]);
type = new_hlsl_type(d3dcompiler_strdup(name), HLSL_CLASS_SCALAR, bt, x, y);
add_type_to_scope(scope, type);
}
}
}
}
}
/* DX8 effects predefined types */
type = new_hlsl_type(d3dcompiler_strdup("DWORD"), HLSL_CLASS_SCALAR, HLSL_TYPE_INT, 1, 1);
add_type_to_scope(scope, type);
type = new_hlsl_type(d3dcompiler_strdup("FLOAT"), HLSL_CLASS_SCALAR, HLSL_TYPE_FLOAT, 1, 1);
add_type_to_scope(scope, type);
type = new_hlsl_type(d3dcompiler_strdup("VECTOR"), HLSL_CLASS_VECTOR, HLSL_TYPE_FLOAT, 4, 1);
add_type_to_scope(scope, type);
type = new_hlsl_type(d3dcompiler_strdup("MATRIX"), HLSL_CLASS_MATRIX, HLSL_TYPE_FLOAT, 4, 4);
add_type_to_scope(scope, type);
type = new_hlsl_type(d3dcompiler_strdup("STRING"), HLSL_CLASS_OBJECT, HLSL_TYPE_STRING, 1, 1);
add_type_to_scope(scope, type);
type = new_hlsl_type(d3dcompiler_strdup("TEXTURE"), HLSL_CLASS_OBJECT, HLSL_TYPE_TEXTURE, 1, 1);
add_type_to_scope(scope, type);
type = new_hlsl_type(d3dcompiler_strdup("PIXELSHADER"), HLSL_CLASS_OBJECT, HLSL_TYPE_PIXELSHADER, 1, 1);
add_type_to_scope(scope, type);
type = new_hlsl_type(d3dcompiler_strdup("VERTEXSHADER"), HLSL_CLASS_OBJECT, HLSL_TYPE_VERTEXSHADER, 1, 1);
add_type_to_scope(scope, type);
}
d3dcompiler: Parse "while" loops.
2012-09-21 16:25:56 +02:00
static struct hlsl_ir_if *loop_condition(struct list *cond_list)
{
struct hlsl_ir_if *out_cond;
struct hlsl_ir_expr *not_cond;
struct hlsl_ir_node *cond, *operands[3];
struct hlsl_ir_jump *jump;
unsigned int count = list_count(cond_list);
if (!count)
return NULL;
if (count != 1)
ERR("Got multiple expressions in a for condition.\n");
cond = LIST_ENTRY(list_head(cond_list), struct hlsl_ir_node, entry);
out_cond = d3dcompiler_alloc(sizeof(*out_cond));
if (!out_cond)
{
ERR("Out of memory.\n");
return NULL;
}
out_cond->node.type = HLSL_IR_IF;
operands[0] = cond;
operands[1] = operands[2] = NULL;
not_cond = new_expr(HLSL_IR_UNOP_LOGIC_NOT, operands, &cond->loc);
if (!not_cond)
{
ERR("Out of memory.\n");
d3dcompiler_free(out_cond);
return NULL;
}
out_cond->condition = &not_cond->node;
jump = d3dcompiler_alloc(sizeof(*jump));
if (!jump)
{
ERR("Out of memory.\n");
d3dcompiler_free(out_cond);
d3dcompiler_free(not_cond);
return NULL;
}
jump->node.type = HLSL_IR_JUMP;
jump->type = HLSL_IR_JUMP_BREAK;
out_cond->then_instrs = d3dcompiler_alloc(sizeof(*out_cond->then_instrs));
if (!out_cond->then_instrs)
{
ERR("Out of memory.\n");
d3dcompiler_free(out_cond);
d3dcompiler_free(not_cond);
d3dcompiler_free(jump);
return NULL;
}
list_init(out_cond->then_instrs);
list_add_head(out_cond->then_instrs, &jump->node.entry);
return out_cond;
}
enum loop_type
{
LOOP_FOR,
LOOP_WHILE,
LOOP_DO_WHILE
};
static struct list *create_loop(enum loop_type type, struct list *init, struct list *cond,
struct list *iter, struct list *body, struct source_location *loc)
{
struct list *list = NULL;
struct hlsl_ir_loop *loop = NULL;
struct hlsl_ir_if *cond_jump = NULL;
list = d3dcompiler_alloc(sizeof(*list));
if (!list)
goto oom;
list_init(list);
if (init)
list_move_head(list, init);
loop = d3dcompiler_alloc(sizeof(*loop));
if (!loop)
goto oom;
loop->node.type = HLSL_IR_LOOP;
loop->node.loc = *loc;
list_add_tail(list, &loop->node.entry);
loop->body = d3dcompiler_alloc(sizeof(*loop->body));
if (!loop->body)
goto oom;
list_init(loop->body);
cond_jump = loop_condition(cond);
if (!cond_jump)
goto oom;
if (type != LOOP_DO_WHILE)
list_add_tail(loop->body, &cond_jump->node.entry);
list_move_tail(loop->body, body);
if (iter)
list_move_tail(loop->body, iter);
if (type == LOOP_DO_WHILE)
list_add_tail(loop->body, &cond_jump->node.entry);
d3dcompiler_free(init);
d3dcompiler_free(cond);
d3dcompiler_free(iter);
d3dcompiler_free(body);
return list;
oom:
ERR("Out of memory.\n");
if (loop)
d3dcompiler_free(loop->body);
d3dcompiler_free(loop);
d3dcompiler_free(cond_jump);
d3dcompiler_free(list);
free_instr_list(init);
free_instr_list(cond);
free_instr_list(iter);
free_instr_list(body);
return NULL;
}
d3dcompiler: Support simple variable initializers.
2012-09-19 19:46:14 +02:00
static unsigned int initializer_size(struct list *initializer)
{
unsigned int count = 0;
struct hlsl_ir_node *node;
LIST_FOR_EACH_ENTRY(node, initializer, struct hlsl_ir_node, entry)
{
count += components_count_type(node->data_type);
}
TRACE("Initializer size = %u\n", count);
return count;
}
d3dcompiler: Parse constructors.
2012-06-11 19:18:35 +02:00
static unsigned int components_count_expr_list(struct list *list)
{
struct hlsl_ir_node *node;
unsigned int count = 0;
LIST_FOR_EACH_ENTRY(node, list, struct hlsl_ir_node, entry)
{
count += components_count_type(node->data_type);
}
return count;
}
d3dcompiler: Parse swizzles.
2012-09-17 15:32:04 +02:00
static struct hlsl_ir_swizzle *new_swizzle(DWORD s, unsigned int components,
struct hlsl_ir_node *val, struct source_location *loc)
{
struct hlsl_ir_swizzle *swizzle = d3dcompiler_alloc(sizeof(*swizzle));
if (!swizzle)
return NULL;
swizzle->node.type = HLSL_IR_SWIZZLE;
swizzle->node.loc = *loc;
swizzle->node.data_type = new_hlsl_type(NULL, HLSL_CLASS_VECTOR, val->data_type->base_type, components, 1);
swizzle->val = val;
swizzle->swizzle = s;
return swizzle;
}
static struct hlsl_ir_swizzle *get_swizzle(struct hlsl_ir_node *value, const char *swizzle,
struct source_location *loc)
{
unsigned int len = strlen(swizzle), component = 0;
unsigned int i, set, swiz = 0;
BOOL valid;
if (value->data_type->type == HLSL_CLASS_MATRIX)
{
/* Matrix swizzle */
BOOL m_swizzle;
unsigned int inc, x, y;
if (len < 3 || swizzle[0] != '_')
return NULL;
m_swizzle = swizzle[1] == 'm';
inc = m_swizzle ? 4 : 3;
if (len % inc || len > inc * 4)
return NULL;
for (i = 0; i < len; i += inc)
{
if (swizzle[i] != '_')
return NULL;
if (m_swizzle)
{
if (swizzle[i + 1] != 'm')
return NULL;
x = swizzle[i + 2] - '0';
y = swizzle[i + 3] - '0';
}
else
{
x = swizzle[i + 1] - '1';
y = swizzle[i + 2] - '1';
}
if (x >= value->data_type->dimx || y >= value->data_type->dimy)
return NULL;
swiz |= (y << 4 | x) << component * 8;
component++;
}
return new_swizzle(swiz, component, value, loc);
}
/* Vector swizzle */
if (len > 4)
return NULL;
for (set = 0; set < 2; ++set)
{
valid = TRUE;
component = 0;
for (i = 0; i < len; ++i)
{
char c[2][4] = {{'x', 'y', 'z', 'w'}, {'r', 'g', 'b', 'a'}};
unsigned int s = 0;
for (s = 0; s < 4; ++s)
{
if (swizzle[i] == c[set][s])
break;
}
if (s == 4)
{
valid = FALSE;
break;
}
if (s >= value->data_type->dimx)
return NULL;
swiz |= s << component * 2;
component++;
}
if (valid)
return new_swizzle(swiz, component, value, loc);
}
return NULL;
}
d3dcompiler: Parse "typedef" statement.
2012-09-19 19:46:13 +02:00
static BOOL add_typedef(DWORD modifiers, struct hlsl_type *orig_type, struct list *list,
struct source_location *loc)
{
BOOL ret;
struct hlsl_type *type;
struct parse_variable_def *v, *v_next;
if (!check_type_modifiers(modifiers, loc))
{
LIST_FOR_EACH_ENTRY_SAFE(v, v_next, list, struct parse_variable_def, entry)
d3dcompiler_free(v);
d3dcompiler_free(list);
return FALSE;
}
LIST_FOR_EACH_ENTRY_SAFE(v, v_next, list, struct parse_variable_def, entry)
{
if (v->array_size)
type = new_array_type(orig_type, v->array_size);
else
type = clone_hlsl_type(orig_type);
if (!type)
{
ERR("Out of memory\n");
return FALSE;
}
d3dcompiler_free((void *)type->name);
type->name = v->name;
type->modifiers |= modifiers;
if (type->type != HLSL_CLASS_MATRIX)
check_invalid_matrix_modifiers(type->modifiers, &v->loc);
ret = add_type_to_scope(hlsl_ctx.cur_scope, type);
if (!ret)
{
hlsl_report_message(v->loc.file, v->loc.line, v->loc.col, HLSL_LEVEL_ERROR,
"redefinition of custom type '%s'", v->name);
}
d3dcompiler_free(v);
}
d3dcompiler_free(list);
return TRUE;
}
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
%}
d3dcompiler: Track the location of each lexer token.
2012-07-12 16:01:33 +02:00
%locations
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
%error-verbose
d3dcompiler: Parse "if/else" statement.
2012-09-19 19:46:11 +02:00
%expect 1
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
%union
{
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
struct hlsl_type *type;
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
INT intval;
d3dcompiler: Flesh out the lexer more.
2012-06-04 17:58:22 +02:00
FLOAT floatval;
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
BOOL boolval;
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
char *name;
DWORD modifiers;
d3dcompiler: Parse variable references in expressions.
2012-06-07 00:19:05 +02:00
struct hlsl_ir_var *var;
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
struct hlsl_ir_node *instr;
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
struct list *list;
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
struct hlsl_ir_function_decl *function;
struct parse_parameter parameter;
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
struct parse_variable_def *variable_def;
d3dcompiler: Parse "if/else" statement.
2012-09-19 19:46:11 +02:00
struct parse_if_body if_body;
d3dcompiler: Parse unary and prefix operators.
2012-07-20 16:37:38 +02:00
enum parse_unary_op unary_op;
d3dcompiler: Stub assignment parsing.
2012-07-20 16:37:40 +02:00
enum parse_assign_op assign_op;
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
}
d3dcompiler: Flesh out the lexer more.
2012-06-04 17:58:22 +02:00
%token KW_BLENDSTATE
%token KW_BREAK
%token KW_BUFFER
%token KW_CBUFFER
%token KW_COLUMN_MAJOR
%token KW_COMPILE
%token KW_CONST
%token KW_CONTINUE
%token KW_DEPTHSTENCILSTATE
%token KW_DEPTHSTENCILVIEW
%token KW_DISCARD
%token KW_DO
%token KW_DOUBLE
%token KW_ELSE
%token KW_EXTERN
%token KW_FALSE
%token KW_FOR
%token KW_GEOMETRYSHADER
%token KW_GROUPSHARED
%token KW_IF
%token KW_IN
%token KW_INLINE
%token KW_INOUT
%token KW_MATRIX
%token KW_NAMESPACE
%token KW_NOINTERPOLATION
%token KW_OUT
%token KW_PASS
%token KW_PIXELSHADER
%token KW_PRECISE
%token KW_RASTERIZERSTATE
%token KW_RENDERTARGETVIEW
%token KW_RETURN
%token KW_REGISTER
%token KW_ROW_MAJOR
%token KW_SAMPLER
%token KW_SAMPLER1D
%token KW_SAMPLER2D
%token KW_SAMPLER3D
%token KW_SAMPLERCUBE
%token KW_SAMPLER_STATE
%token KW_SAMPLERCOMPARISONSTATE
%token KW_SHARED
%token KW_STATEBLOCK
%token KW_STATEBLOCK_STATE
%token KW_STATIC
%token KW_STRING
%token KW_STRUCT
%token KW_SWITCH
%token KW_TBUFFER
%token KW_TECHNIQUE
%token KW_TECHNIQUE10
%token KW_TEXTURE
%token KW_TEXTURE1D
%token KW_TEXTURE1DARRAY
%token KW_TEXTURE2D
%token KW_TEXTURE2DARRAY
%token KW_TEXTURE2DMS
%token KW_TEXTURE2DMSARRAY
%token KW_TEXTURE3D
%token KW_TEXTURE3DARRAY
%token KW_TEXTURECUBE
%token KW_TRUE
%token KW_TYPEDEF
%token KW_UNIFORM
%token KW_VECTOR
%token KW_VERTEXSHADER
%token KW_VOID
%token KW_VOLATILE
%token KW_WHILE
%token OP_INC
%token OP_DEC
%token OP_AND
%token OP_OR
%token OP_EQ
%token OP_LEFTSHIFT
%token OP_LEFTSHIFTASSIGN
%token OP_RIGHTSHIFT
%token OP_RIGHTSHIFTASSIGN
%token OP_ELLIPSIS
%token OP_LE
%token OP_GE
%token OP_NE
%token OP_ADDASSIGN
%token OP_SUBASSIGN
%token OP_MULASSIGN
%token OP_DIVASSIGN
%token OP_MODASSIGN
%token OP_ANDASSIGN
%token OP_ORASSIGN
%token OP_XORASSIGN
%token OP_UNKNOWN1
%token OP_UNKNOWN2
%token OP_UNKNOWN3
%token OP_UNKNOWN4
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
%token <intval> PRE_LINE
d3dcompiler: Add identifiers parsing.
2012-06-04 17:58:23 +02:00
%token <name> VAR_IDENTIFIER TYPE_IDENTIFIER NEW_IDENTIFIER
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
%type <name> any_identifier var_identifier
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
%token <name> STRING
d3dcompiler: Flesh out the lexer more.
2012-06-04 17:58:22 +02:00
%token <floatval> C_FLOAT
%token <intval> C_INTEGER
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
%type <boolval> boolean
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
%type <type> base_type
%type <type> type
d3dcompiler: Make declaration_statement return a list.
2012-07-11 17:27:50 +02:00
%type <list> declaration_statement
d3dcompiler: Support simple variable initializers.
2012-09-19 19:46:14 +02:00
%type <list> declaration
d3dcompiler: Parse "typedef" statement.
2012-09-19 19:46:13 +02:00
%type <list> type_specs
%type <variable_def> type_spec
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
%type <list> complex_initializer
%type <list> initializer_expr_list
%type <instr> initializer_expr
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
%type <modifiers> var_modifiers
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
%type <list> parameters
%type <list> param_list
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
%type <instr> expr
d3dcompiler: Parse variable references in expressions.
2012-06-07 00:19:05 +02:00
%type <var> variable
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
%type <intval> array
d3dcompiler: Parse function definitions.
2012-06-11 19:18:34 +02:00
%type <list> statement
%type <list> statement_list
%type <list> compound_statement
d3dcompiler: Parse "return" statement.
2012-09-18 18:18:08 +02:00
%type <list> jump_statement
d3dcompiler: Parse "if/else" statement.
2012-09-19 19:46:11 +02:00
%type <list> selection_statement
d3dcompiler: Parse "while" loops.
2012-09-21 16:25:56 +02:00
%type <list> loop_statement
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
%type <function> func_declaration
%type <function> func_prototype
%type <parameter> parameter
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
%type <name> semantic
%type <variable_def> variable_def
%type <list> variables_def
d3dcompiler: Parse "if/else" statement.
2012-09-19 19:46:11 +02:00
%type <if_body> if_body
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
%type <instr> primary_expr
%type <instr> postfix_expr
%type <instr> unary_expr
%type <instr> mul_expr
%type <instr> add_expr
%type <instr> shift_expr
%type <instr> relational_expr
%type <instr> equality_expr
%type <instr> bitand_expr
%type <instr> bitxor_expr
%type <instr> bitor_expr
%type <instr> logicand_expr
%type <instr> logicor_expr
%type <instr> conditional_expr
%type <instr> assignment_expr
d3dcompiler: Parse function definitions.
2012-06-11 19:18:34 +02:00
%type <list> expr_statement
d3dcompiler: Parse unary and prefix operators.
2012-07-20 16:37:38 +02:00
%type <unary_op> unary_op
d3dcompiler: Stub assignment parsing.
2012-07-20 16:37:40 +02:00
%type <assign_op> assign_op
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
%type <modifiers> input_mod
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
%%
hlsl_prog: /* empty */
{
}
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
| hlsl_prog func_declaration
{
FIXME("Check that the function doesn't conflict with an already declared one.\n");
list_add_tail(&hlsl_ctx.functions, &$2->node.entry);
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
| hlsl_prog declaration_statement
{
TRACE("Declaration statement parsed.\n");
}
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
| hlsl_prog preproc_directive
{
}
preproc_directive: PRE_LINE STRING
{
Assorted spelling fixes.
2012-06-02 10:35:21 +02:00
TRACE("Updating line information to file %s, line %u\n", debugstr_a($2), $1);
d3dcompiler: Fix line info update.
2012-07-10 15:39:41 +02:00
hlsl_ctx.line_no = $1;
d3dcompiler: Track the location of each lexer token.
2012-07-12 16:01:33 +02:00
if (strcmp($2, hlsl_ctx.source_file))
{
const char **new_array;
hlsl_ctx.source_file = $2;
new_array = d3dcompiler_realloc(hlsl_ctx.source_files,
sizeof(*hlsl_ctx.source_files) * hlsl_ctx.source_files_count + 1);
if (new_array)
{
hlsl_ctx.source_files = new_array;
hlsl_ctx.source_files[hlsl_ctx.source_files_count++] = $2;
}
}
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
any_identifier: VAR_IDENTIFIER
| TYPE_IDENTIFIER
| NEW_IDENTIFIER
d3dcompiler: Parse function definitions.
2012-06-11 19:18:34 +02:00
func_declaration: func_prototype compound_statement
{
TRACE("Function %s parsed.\n", $1->name);
$$ = $1;
$$->body = $2;
pop_scope(&hlsl_ctx);
}
| func_prototype ';'
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
{
TRACE("Function prototype for %s.\n", $1->name);
$$ = $1;
pop_scope(&hlsl_ctx);
}
func_prototype: var_modifiers type var_identifier '(' parameters ')' semantic
{
d3dcompiler: Variables and functions can't have the same name.
2012-07-16 20:39:21 +02:00
if (get_variable(hlsl_ctx.globals, $3))
{
hlsl_report_message(hlsl_ctx.source_file, @3.first_line, @3.first_column,
HLSL_LEVEL_ERROR, "redefinition of '%s'\n", $3);
return 1;
}
d3dcompiler: Don't allow semantics on void functions.
2012-07-16 20:39:22 +02:00
if ($2->base_type == HLSL_TYPE_VOID && $7)
{
hlsl_report_message(hlsl_ctx.source_file, @7.first_line, @7.first_column,
HLSL_LEVEL_ERROR, "void function with a semantic");
}
d3dcompiler: Variables and functions can't have the same name.
2012-07-16 20:39:21 +02:00
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
$$ = new_func_decl($3, $2, $5);
if (!$$)
{
ERR("Out of memory.\n");
return -1;
}
$$->semantic = $7;
}
d3dcompiler: Parse function definitions.
2012-06-11 19:18:34 +02:00
compound_statement: '{' '}'
{
$$ = d3dcompiler_alloc(sizeof(*$$));
list_init($$);
}
| '{' scope_start statement_list '}'
{
pop_scope(&hlsl_ctx);
$$ = $3;
}
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
scope_start: /* Empty */
{
push_scope(&hlsl_ctx);
}
var_identifier: VAR_IDENTIFIER
| NEW_IDENTIFIER
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
semantic: /* Empty */
{
$$ = NULL;
}
| ':' any_identifier
{
$$ = $2;
}
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
parameters: scope_start
{
$$ = d3dcompiler_alloc(sizeof(*$$));
list_init($$);
}
| scope_start param_list
{
$$ = $2;
}
param_list: parameter
{
d3dcompiler: Pass the complete location to add_func_parameter().
2012-07-16 20:39:20 +02:00
struct source_location loc;
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
$$ = d3dcompiler_alloc(sizeof(*$$));
list_init($$);
d3dcompiler: Pass the complete location to add_func_parameter().
2012-07-16 20:39:20 +02:00
set_location(&loc, &@1);
if (!add_func_parameter($$, &$1, &loc))
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
{
ERR("Error adding function parameter %s.\n", $1.name);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
return -1;
}
}
| param_list ',' parameter
{
d3dcompiler: Pass the complete location to add_func_parameter().
2012-07-16 20:39:20 +02:00
struct source_location loc;
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
$$ = $1;
d3dcompiler: Pass the complete location to add_func_parameter().
2012-07-16 20:39:20 +02:00
set_location(&loc, &@3);
if (!add_func_parameter($$, &$3, &loc))
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
{
d3dcompiler: Pass the complete location to add_func_parameter().
2012-07-16 20:39:20 +02:00
hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
"duplicate parameter %s", $3.name);
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
return 1;
}
}
parameter: input_mod var_modifiers type any_identifier semantic
{
$$.modifiers = $1;
$$.modifiers |= $2;
$$.type = $3;
$$.name = $4;
$$.semantic = $5;
}
input_mod: /* Empty */
{
$$ = HLSL_MODIFIER_IN;
}
| KW_IN
{
$$ = HLSL_MODIFIER_IN;
}
| KW_OUT
{
$$ = HLSL_MODIFIER_OUT;
}
| KW_INOUT
{
$$ = HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT;
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
type: base_type
{
$$ = $1;
}
d3dcompiler: Parse vector and matrix declarations.
2012-06-11 19:18:31 +02:00
| KW_VECTOR '<' base_type ',' C_INTEGER '>'
{
if ($3->type != HLSL_CLASS_SCALAR)
{
hlsl_message("Line %u: vectors of non-scalar types are not allowed.\n",
hlsl_ctx.line_no);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
return 1;
}
if ($5 < 1 || $5 > 4)
{
hlsl_message("Line %u: vector size must be between 1 and 4.\n",
hlsl_ctx.line_no);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
return 1;
}
$$ = new_hlsl_type(NULL, HLSL_CLASS_VECTOR, $3->base_type, $5, 1);
}
| KW_MATRIX '<' base_type ',' C_INTEGER ',' C_INTEGER '>'
{
if ($3->type != HLSL_CLASS_SCALAR)
{
hlsl_message("Line %u: matrices of non-scalar types are not allowed.\n",
hlsl_ctx.line_no);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
return 1;
}
if ($5 < 1 || $5 > 4 || $7 < 1 || $7 > 4)
{
hlsl_message("Line %u: matrix dimensions must be between 1 and 4.\n",
hlsl_ctx.line_no);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
return 1;
}
$$ = new_hlsl_type(NULL, HLSL_CLASS_MATRIX, $3->base_type, $5, $7);
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
base_type: KW_VOID
{
d3dcompiler: "void" is not a plain scalar data type. It can't be used in expressions and the like. This change indirectly takes care of most of the checks.
2012-07-20 16:37:39 +02:00
$$ = new_hlsl_type(d3dcompiler_strdup("void"), HLSL_CLASS_OBJECT, HLSL_TYPE_VOID, 1, 1);
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
}
d3dcompiler: Parse sampler declarations.
2012-06-11 19:18:32 +02:00
| KW_SAMPLER
{
d3dcompiler: Type names have to be allocated on the heap.
2012-07-10 15:39:42 +02:00
$$ = new_hlsl_type(d3dcompiler_strdup("sampler"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
d3dcompiler: Parse sampler declarations.
2012-06-11 19:18:32 +02:00
$$->sampler_dim = HLSL_SAMPLER_DIM_GENERIC;
}
| KW_SAMPLER1D
{
d3dcompiler: Type names have to be allocated on the heap.
2012-07-10 15:39:42 +02:00
$$ = new_hlsl_type(d3dcompiler_strdup("sampler1D"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
d3dcompiler: Parse sampler declarations.
2012-06-11 19:18:32 +02:00
$$->sampler_dim = HLSL_SAMPLER_DIM_1D;
}
| KW_SAMPLER2D
{
d3dcompiler: Type names have to be allocated on the heap.
2012-07-10 15:39:42 +02:00
$$ = new_hlsl_type(d3dcompiler_strdup("sampler2D"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
d3dcompiler: Parse sampler declarations.
2012-06-11 19:18:32 +02:00
$$->sampler_dim = HLSL_SAMPLER_DIM_2D;
}
| KW_SAMPLER3D
{
d3dcompiler: Type names have to be allocated on the heap.
2012-07-10 15:39:42 +02:00
$$ = new_hlsl_type(d3dcompiler_strdup("sampler3D"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
d3dcompiler: Parse sampler declarations.
2012-06-11 19:18:32 +02:00
$$->sampler_dim = HLSL_SAMPLER_DIM_3D;
}
| KW_SAMPLERCUBE
{
d3dcompiler: Type names have to be allocated on the heap.
2012-07-10 15:39:42 +02:00
$$ = new_hlsl_type(d3dcompiler_strdup("samplerCUBE"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
d3dcompiler: Parse sampler declarations.
2012-06-11 19:18:32 +02:00
$$->sampler_dim = HLSL_SAMPLER_DIM_CUBE;
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
| 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);
d3dcompiler: Distinguish between scalars, vectors and matrices.
2012-06-07 00:19:02 +02:00
if (type->type != HLSL_CLASS_STRUCT)
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
{
d3dcompiler: Distinguish between scalars, vectors and matrices.
2012-06-07 00:19:02 +02:00
hlsl_message("Line %u: redefining %s as a structure.\n",
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
hlsl_ctx.line_no, $2);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
}
else
{
$$ = type;
}
d3dcompiler_free($2);
}
declaration_statement: declaration
{
d3dcompiler: Support simple variable initializers.
2012-09-19 19:46:14 +02:00
$$ = $1;
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
}
d3dcompiler: Parse "typedef" statement.
2012-09-19 19:46:13 +02:00
| typedef
{
$$ = d3dcompiler_alloc(sizeof(*$$));
if (!$$)
{
ERR("Out of memory\n");
return -1;
}
list_init($$);
}
typedef: KW_TYPEDEF var_modifiers type type_specs ';'
{
struct source_location loc;
set_location(&loc, &@1);
if (!add_typedef($2, $3, $4, &loc))
return 1;
}
type_specs: type_spec
{
$$ = d3dcompiler_alloc(sizeof(*$$));
list_init($$);
list_add_head($$, &$1->entry);
}
| type_specs ',' type_spec
{
$$ = $1;
list_add_tail($$, &$3->entry);
}
type_spec: any_identifier array
{
$$ = d3dcompiler_alloc(sizeof(*$$));
set_location(&$$->loc, &@1);
$$->name = $1;
$$->array_size = $2;
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
declaration: var_modifiers type variables_def ';'
{
d3dcompiler: Support simple variable initializers.
2012-09-19 19:46:14 +02:00
struct hlsl_type *type;
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
struct parse_variable_def *v, *v_next;
struct hlsl_ir_var *var;
d3dcompiler: Support simple variable initializers.
2012-09-19 19:46:14 +02:00
struct hlsl_ir_node *assignment;
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
BOOL ret, local = TRUE;
d3dcompiler: Support simple variable initializers.
2012-09-19 19:46:14 +02:00
$$ = d3dcompiler_alloc(sizeof(*$$));
list_init($$);
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
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)
d3dcompiler: Support simple variable initializers.
2012-09-19 19:46:14 +02:00
type = new_array_type($2, v->array_size);
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
else
d3dcompiler: Support simple variable initializers.
2012-09-19 19:46:14 +02:00
type = $2;
var->node.data_type = type;
d3dcompiler: Store (and begin to use) location information for variables.
2012-07-12 16:01:35 +02:00
var->node.loc = v->loc;
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
var->name = v->name;
var->modifiers = $1;
var->semantic = v->semantic;
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
if (hlsl_ctx.cur_scope == hlsl_ctx.globals)
{
var->modifiers |= HLSL_STORAGE_UNIFORM;
local = FALSE;
}
d3dcompiler: Don't allow const variables without initializers.
2012-07-18 16:25:12 +02:00
if (var->modifiers & HLSL_MODIFIER_CONST && !v->initializer)
{
hlsl_report_message(v->loc.file, v->loc.line, v->loc.col,
HLSL_LEVEL_ERROR, "const variable without initializer");
free_declaration(var);
d3dcompiler_free(v);
continue;
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
ret = declare_variable(var, local);
d3dcompiler: Don't allow const variables without initializers.
2012-07-18 16:25:12 +02:00
if (!ret)
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
free_declaration(var);
else
TRACE("Declared variable %s.\n", var->name);
d3dcompiler: Don't allow const variables without initializers.
2012-07-18 16:25:12 +02:00
if (v->initializer)
{
d3dcompiler: Support simple variable initializers.
2012-09-19 19:46:14 +02:00
unsigned int size = initializer_size(v->initializer);
struct hlsl_ir_node *node;
TRACE("Variable with initializer\n");
if (type->type <= HLSL_CLASS_LAST_NUMERIC
&& type->dimx * type->dimy != size
&& size != 1)
{
if (size < type->dimx * type->dimy)
{
hlsl_report_message(v->loc.file,
v->loc.line, v->loc.col, HLSL_LEVEL_ERROR,
"'%s' initializer does not match", v->name);
free_instr_list(v->initializer);
d3dcompiler_free(v);
continue;
}
}
if ((type->type == HLSL_CLASS_STRUCT || type->type == HLSL_CLASS_ARRAY)
&& components_count_type(type) != size)
{
hlsl_report_message(v->loc.file,
v->loc.line, v->loc.col, HLSL_LEVEL_ERROR,
"'%s' initializer does not match", v->name);
free_instr_list(v->initializer);
d3dcompiler_free(v);
continue;
}
if (type->type > HLSL_CLASS_LAST_NUMERIC)
{
FIXME("Initializers for non scalar/struct variables not supported yet\n");
free_instr_list(v->initializer);
d3dcompiler_free(v);
continue;
}
if (v->array_size > 0)
{
FIXME("Initializing arrays is not supported yet\n");
free_instr_list(v->initializer);
d3dcompiler_free(v);
continue;
}
if (list_count(v->initializer) > 1)
{
FIXME("Complex initializers are not supported yet.\n");
free_instr_list(v->initializer);
d3dcompiler_free(v);
continue;
}
node = LIST_ENTRY(list_head(v->initializer), struct hlsl_ir_node, entry);
assignment = make_assignment(&var->node, ASSIGN_OP_ASSIGN,
BWRITERSP_WRITEMASK_ALL, node);
list_add_tail($$, &assignment->entry);
d3dcompiler: Don't allow const variables without initializers.
2012-07-18 16:25:12 +02:00
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
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);
}
variable_def: any_identifier array semantic
{
$$ = d3dcompiler_alloc(sizeof(*$$));
d3dcompiler: Store (and begin to use) location information for variables.
2012-07-12 16:01:35 +02:00
set_location(&$$->loc, &@1);
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
$$->name = $1;
$$->array_size = $2;
$$->semantic = $3;
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
| any_identifier array semantic '=' complex_initializer
{
TRACE("Declaration with initializer.\n");
$$ = d3dcompiler_alloc(sizeof(*$$));
d3dcompiler: Store (and begin to use) location information for variables.
2012-07-12 16:01:35 +02:00
set_location(&$$->loc, &@1);
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
$$->name = $1;
$$->array_size = $2;
$$->semantic = $3;
$$->initializer = $5;
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
array: /* Empty */
{
$$ = 0;
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
| '[' expr ']'
{
FIXME("Array.\n");
$$ = 0;
free_instr($2);
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
var_modifiers: /* Empty */
{
$$ = 0;
}
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
| KW_EXTERN var_modifiers
{
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
$$ = add_modifier($2, HLSL_STORAGE_EXTERN, &@1);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
| KW_NOINTERPOLATION var_modifiers
{
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
$$ = add_modifier($2, HLSL_STORAGE_NOINTERPOLATION, &@1);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
| KW_PRECISE var_modifiers
{
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
$$ = add_modifier($2, HLSL_MODIFIER_PRECISE, &@1);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
| KW_SHARED var_modifiers
{
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
$$ = add_modifier($2, HLSL_STORAGE_SHARED, &@1);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
| KW_GROUPSHARED var_modifiers
{
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
$$ = add_modifier($2, HLSL_STORAGE_GROUPSHARED, &@1);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
| KW_STATIC var_modifiers
{
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
$$ = add_modifier($2, HLSL_STORAGE_STATIC, &@1);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
| KW_UNIFORM var_modifiers
{
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
$$ = add_modifier($2, HLSL_STORAGE_UNIFORM, &@1);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
| KW_VOLATILE var_modifiers
{
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
$$ = add_modifier($2, HLSL_STORAGE_VOLATILE, &@1);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
| KW_CONST var_modifiers
{
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
$$ = add_modifier($2, HLSL_MODIFIER_CONST, &@1);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
| KW_ROW_MAJOR var_modifiers
{
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
$$ = add_modifier($2, HLSL_MODIFIER_ROW_MAJOR, &@1);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
| KW_COLUMN_MAJOR var_modifiers
{
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
$$ = add_modifier($2, HLSL_MODIFIER_COLUMN_MAJOR, &@1);
d3dcompiler: Parse modifiers.
2012-06-07 00:19:03 +02:00
}
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
complex_initializer: initializer_expr
{
$$ = d3dcompiler_alloc(sizeof(*$$));
list_init($$);
list_add_head($$, &$1->entry);
}
| '{' initializer_expr_list '}'
{
$$ = $2;
}
initializer_expr: assignment_expr
{
$$ = $1;
}
initializer_expr_list: initializer_expr
{
$$ = d3dcompiler_alloc(sizeof(*$$));
list_init($$);
list_add_head($$, &$1->entry);
}
| initializer_expr_list ',' initializer_expr
{
$$ = $1;
list_add_tail($$, &$3->entry);
}
boolean: KW_TRUE
{
$$ = TRUE;
}
| KW_FALSE
{
$$ = FALSE;
}
d3dcompiler: Parse function definitions.
2012-06-11 19:18:34 +02:00
statement_list: statement
{
$$ = $1;
}
| statement_list statement
{
$$ = $1;
list_move_tail($$, $2);
d3dcompiler_free($2);
}
statement: declaration_statement
| expr_statement
| compound_statement
d3dcompiler: Parse "return" statement.
2012-09-18 18:18:08 +02:00
| jump_statement
d3dcompiler: Parse "if/else" statement.
2012-09-19 19:46:11 +02:00
| selection_statement
d3dcompiler: Parse "while" loops.
2012-09-21 16:25:56 +02:00
| loop_statement
d3dcompiler: Parse "return" statement.
2012-09-18 18:18:08 +02:00
/* FIXME: add rule for return with no value */
jump_statement: KW_RETURN expr ';'
d3dcompiler: Parse function definitions.
2012-06-11 19:18:34 +02:00
{
d3dcompiler: Parse "return" statement.
2012-09-18 18:18:08 +02:00
struct hlsl_ir_jump *jump = d3dcompiler_alloc(sizeof(*jump));
if (!jump)
{
ERR("Out of memory\n");
return -1;
}
jump->node.type = HLSL_IR_JUMP;
set_location(&jump->node.loc, &@1);
jump->type = HLSL_IR_JUMP_RETURN;
jump->node.data_type = $2->data_type;
jump->return_value = $2;
FIXME("Check for valued return on void function.\n");
FIXME("Implicit conversion to the return type if needed, "
"error out if conversion not possible.\n");
$$ = d3dcompiler_alloc(sizeof(*$$));
list_init($$);
list_add_tail($$, &jump->node.entry);
d3dcompiler: Parse function definitions.
2012-06-11 19:18:34 +02:00
}
d3dcompiler: Parse "if/else" statement.
2012-09-19 19:46:11 +02:00
selection_statement: KW_IF '(' expr ')' if_body
{
struct hlsl_ir_if *instr = d3dcompiler_alloc(sizeof(*instr));
if (!instr)
{
ERR("Out of memory\n");
return -1;
}
instr->node.type = HLSL_IR_IF;
set_location(&instr->node.loc, &@1);
instr->condition = $3;
instr->then_instrs = $5.then_instrs;
instr->else_instrs = $5.else_instrs;
if ($3->data_type->dimx > 1 || $3->data_type->dimy > 1)
{
hlsl_report_message(instr->node.loc.file, instr->node.loc.line,
instr->node.loc.col, HLSL_LEVEL_ERROR,
"if condition requires a scalar");
}
$$ = d3dcompiler_alloc(sizeof(*$$));
list_init($$);
list_add_head($$, &instr->node.entry);
}
if_body: statement
{
$$.then_instrs = $1;
$$.else_instrs = NULL;
}
| statement KW_ELSE statement
{
$$.then_instrs = $1;
$$.else_instrs = $3;
}
d3dcompiler: Parse "while" loops.
2012-09-21 16:25:56 +02:00
loop_statement: KW_WHILE '(' expr ')' statement
{
struct source_location loc;
struct list *cond = d3dcompiler_alloc(sizeof(*cond));
if (!cond)
{
ERR("Out of memory.\n");
return -1;
}
list_init(cond);
list_add_head(cond, &$3->entry);
set_location(&loc, &@1);
$$ = create_loop(LOOP_WHILE, NULL, cond, NULL, $5, &loc);
}
d3dcompiler: Parse "do-while" loop.
2012-09-21 16:25:57 +02:00
| KW_DO statement KW_WHILE '(' expr ')' ';'
{
struct source_location loc;
struct list *cond = d3dcompiler_alloc(sizeof(*cond));
if (!cond)
{
ERR("Out of memory.\n");
return -1;
}
list_init(cond);
list_add_head(cond, &$5->entry);
set_location(&loc, &@1);
$$ = create_loop(LOOP_DO_WHILE, NULL, cond, NULL, $2, &loc);
}
d3dcompiler: Parse "for" loops without variable declarations.
2012-09-21 16:25:58 +02:00
| KW_FOR '(' scope_start expr_statement expr_statement expr_statement ')' statement
{
struct source_location loc;
set_location(&loc, &@1);
$$ = create_loop(LOOP_FOR, $4, $5, $6, $8, &loc);
pop_scope(&hlsl_ctx);
}
d3dcompiler: Parse "for" loops with declarations.
2012-09-21 16:25:59 +02:00
| KW_FOR '(' scope_start declaration expr_statement expr_statement ')' statement
{
struct source_location loc;
set_location(&loc, &@1);
if (!$4)
hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_WARNING,
"no expressions in for loop initializer");
$$ = create_loop(LOOP_FOR, $4, $5, $6, $8, &loc);
pop_scope(&hlsl_ctx);
}
d3dcompiler: Parse "while" loops.
2012-09-21 16:25:56 +02:00
d3dcompiler: Parse function definitions.
2012-06-11 19:18:34 +02:00
expr_statement: ';'
{
$$ = d3dcompiler_alloc(sizeof(*$$));
list_init($$);
}
| expr ';'
{
$$ = d3dcompiler_alloc(sizeof(*$$));
list_init($$);
if ($1)
list_add_head($$, &$1->entry);
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
primary_expr: C_FLOAT
{
struct hlsl_ir_constant *c = d3dcompiler_alloc(sizeof(*c));
if (!c)
{
ERR("Out of memory.\n");
return -1;
}
c->node.type = HLSL_IR_CONSTANT;
d3dcompiler: Store location information in constants, variable dereferences and constructors.
2012-07-16 20:39:19 +02:00
set_location(&c->node.loc, &yylloc);
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
c->node.data_type = new_hlsl_type("float", HLSL_CLASS_SCALAR, HLSL_TYPE_FLOAT, 1, 1);
c->v.value.f[0] = $1;
$$ = &c->node;
}
| C_INTEGER
{
struct hlsl_ir_constant *c = d3dcompiler_alloc(sizeof(*c));
if (!c)
{
ERR("Out of memory.\n");
return -1;
}
c->node.type = HLSL_IR_CONSTANT;
d3dcompiler: Store location information in constants, variable dereferences and constructors.
2012-07-16 20:39:19 +02:00
set_location(&c->node.loc, &yylloc);
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
c->node.data_type = new_hlsl_type("int", HLSL_CLASS_SCALAR, HLSL_TYPE_INT, 1, 1);
c->v.value.i[0] = $1;
$$ = &c->node;
}
| boolean
{
struct hlsl_ir_constant *c = d3dcompiler_alloc(sizeof(*c));
if (!c)
{
ERR("Out of memory.\n");
return -1;
}
c->node.type = HLSL_IR_CONSTANT;
d3dcompiler: Store location information in constants, variable dereferences and constructors.
2012-07-16 20:39:19 +02:00
set_location(&c->node.loc, &yylloc);
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
c->node.data_type = new_hlsl_type("bool", HLSL_CLASS_SCALAR, HLSL_TYPE_BOOL, 1, 1);
c->v.value.b[0] = $1;
$$ = &c->node;
}
d3dcompiler: Parse variable references in expressions.
2012-06-07 00:19:05 +02:00
| variable
{
struct hlsl_ir_deref *deref = new_var_deref($1);
d3dcompiler: Store location information in constants, variable dereferences and constructors.
2012-07-16 20:39:19 +02:00
if (deref)
{
$$ = &deref->node;
set_location(&$$->loc, &@1);
}
else
$$ = NULL;
d3dcompiler: Parse variable references in expressions.
2012-06-07 00:19:05 +02:00
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
| '(' expr ')'
{
$$ = $2;
}
d3dcompiler: Parse variable references in expressions.
2012-06-07 00:19:05 +02:00
variable: VAR_IDENTIFIER
{
struct hlsl_ir_var *var;
var = get_variable(hlsl_ctx.cur_scope, $1);
if (!var)
{
hlsl_message("Line %d: variable '%s' not declared\n",
hlsl_ctx.line_no, $1);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
return 1;
}
$$ = var;
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
postfix_expr: primary_expr
{
$$ = $1;
}
d3dcompiler: Parse some postfix operators.
2012-07-20 16:37:37 +02:00
| postfix_expr OP_INC
{
struct hlsl_ir_node *operands[3];
struct source_location loc;
d3dcompiler: Postincrement/decrement expressions are const. Also check for const expressions used as l-values.
2012-09-17 15:32:05 +02:00
set_location(&loc, &@2);
if ($1->data_type->modifiers & HLSL_MODIFIER_CONST)
{
hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
"modifying a const expression");
return 1;
}
d3dcompiler: Parse some postfix operators.
2012-07-20 16:37:37 +02:00
operands[0] = $1;
operands[1] = operands[2] = NULL;
$$ = &new_expr(HLSL_IR_BINOP_POSTINC, operands, &loc)->node;
d3dcompiler: Postincrement/decrement expressions are const. Also check for const expressions used as l-values.
2012-09-17 15:32:05 +02:00
/* Post increment/decrement expressions are considered const */
$$->data_type = clone_hlsl_type($$->data_type);
$$->data_type->modifiers |= HLSL_MODIFIER_CONST;
d3dcompiler: Parse some postfix operators.
2012-07-20 16:37:37 +02:00
}
| postfix_expr OP_DEC
{
struct hlsl_ir_node *operands[3];
struct source_location loc;
d3dcompiler: Postincrement/decrement expressions are const. Also check for const expressions used as l-values.
2012-09-17 15:32:05 +02:00
set_location(&loc, &@2);
if ($1->data_type->modifiers & HLSL_MODIFIER_CONST)
{
hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
"modifying a const expression");
return 1;
}
d3dcompiler: Parse some postfix operators.
2012-07-20 16:37:37 +02:00
operands[0] = $1;
operands[1] = operands[2] = NULL;
$$ = &new_expr(HLSL_IR_BINOP_POSTDEC, operands, &loc)->node;
d3dcompiler: Postincrement/decrement expressions are const. Also check for const expressions used as l-values.
2012-09-17 15:32:05 +02:00
/* Post increment/decrement expressions are considered const */
$$->data_type = clone_hlsl_type($$->data_type);
$$->data_type->modifiers |= HLSL_MODIFIER_CONST;
d3dcompiler: Parse some postfix operators.
2012-07-20 16:37:37 +02:00
}
d3dcompiler: Parse swizzles.
2012-09-17 15:32:04 +02:00
| postfix_expr '.' any_identifier
{
struct source_location loc;
set_location(&loc, &@2);
if ($1->data_type->type <= HLSL_CLASS_LAST_NUMERIC)
{
struct hlsl_ir_swizzle *swizzle;
swizzle = get_swizzle($1, $3, &loc);
if (!swizzle)
{
hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
"invalid swizzle %s", debugstr_a($3));
return 1;
}
$$ = &swizzle->node;
}
else
{
hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
"invalid subscript %s", debugstr_a($3));
return 1;
}
}
d3dcompiler: Parse constructors.
2012-06-11 19:18:35 +02:00
/* "var_modifiers" doesn't make sense in this case, but it's needed
in the grammar to avoid shift/reduce conflicts. */
| var_modifiers type '(' initializer_expr_list ')'
{
struct hlsl_ir_constructor *constructor;
TRACE("%s constructor.\n", debug_hlsl_type($2));
if ($1)
{
hlsl_message("Line %u: unexpected modifier in a constructor.\n",
hlsl_ctx.line_no);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
return -1;
}
if ($2->type > HLSL_CLASS_LAST_NUMERIC)
{
hlsl_message("Line %u: constructors are allowed only for numeric data types.\n",
hlsl_ctx.line_no);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
return -1;
}
if ($2->dimx * $2->dimy != components_count_expr_list($4))
{
hlsl_message("Line %u: wrong number of components in constructor.\n",
hlsl_ctx.line_no);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
return -1;
}
constructor = d3dcompiler_alloc(sizeof(*constructor));
constructor->node.type = HLSL_IR_CONSTRUCTOR;
d3dcompiler: Store location information in constants, variable dereferences and constructors.
2012-07-16 20:39:19 +02:00
set_location(&constructor->node.loc, &@3);
d3dcompiler: Parse constructors.
2012-06-11 19:18:35 +02:00
constructor->node.data_type = $2;
constructor->arguments = $4;
$$ = &constructor->node;
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
unary_expr: postfix_expr
{
$$ = $1;
}
d3dcompiler: Parse unary and prefix operators.
2012-07-20 16:37:38 +02:00
| OP_INC unary_expr
{
struct hlsl_ir_node *operands[3];
struct source_location loc;
d3dcompiler: Postincrement/decrement expressions are const. Also check for const expressions used as l-values.
2012-09-17 15:32:05 +02:00
set_location(&loc, &@1);
if ($2->data_type->modifiers & HLSL_MODIFIER_CONST)
{
hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
"modifying a const expression");
return 1;
}
d3dcompiler: Parse unary and prefix operators.
2012-07-20 16:37:38 +02:00
operands[0] = $2;
operands[1] = operands[2] = NULL;
$$ = &new_expr(HLSL_IR_BINOP_PREINC, operands, &loc)->node;
}
| OP_DEC unary_expr
{
struct hlsl_ir_node *operands[3];
struct source_location loc;
d3dcompiler: Postincrement/decrement expressions are const. Also check for const expressions used as l-values.
2012-09-17 15:32:05 +02:00
set_location(&loc, &@1);
if ($2->data_type->modifiers & HLSL_MODIFIER_CONST)
{
hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
"modifying a const expression");
return 1;
}
d3dcompiler: Parse unary and prefix operators.
2012-07-20 16:37:38 +02:00
operands[0] = $2;
operands[1] = operands[2] = NULL;
$$ = &new_expr(HLSL_IR_BINOP_PREDEC, operands, &loc)->node;
}
| unary_op unary_expr
{
enum hlsl_ir_expr_op ops[] = {0, HLSL_IR_UNOP_NEG,
HLSL_IR_UNOP_LOGIC_NOT, HLSL_IR_UNOP_BIT_NOT};
struct hlsl_ir_node *operands[3];
struct source_location loc;
if ($1 == UNARY_OP_PLUS)
{
$$ = $2;
}
else
{
operands[0] = $2;
operands[1] = operands[2] = NULL;
set_location(&loc, &@1);
$$ = &new_expr(ops[$1], operands, &loc)->node;
}
}
d3dcompiler: Parse casts.
2012-09-19 19:46:15 +02:00
/* var_modifiers just to avoid shift/reduce conflicts */
| '(' var_modifiers type array ')' unary_expr
{
struct hlsl_ir_expr *expr;
struct hlsl_type *src_type = $6->data_type;
struct hlsl_type *dst_type;
struct source_location loc;
set_location(&loc, &@3);
if ($2)
{
hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
"unexpected modifier in a cast");
return 1;
}
d3dcompiler: Allow casts to arrays.
2012-09-21 16:25:55 +02:00
if ($4)
dst_type = new_array_type($3, $4);
else
dst_type = $3;
d3dcompiler: Parse casts.
2012-09-19 19:46:15 +02:00
if (!compatible_data_types(src_type, dst_type))
{
hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
"can't cast from %s to %s",
debug_hlsl_type(src_type), debug_hlsl_type(dst_type));
return 1;
}
expr = new_cast($6, dst_type, &loc);
$$ = expr ? &expr->node : NULL;
}
d3dcompiler: Parse unary and prefix operators.
2012-07-20 16:37:38 +02:00
unary_op: '+'
{
$$ = UNARY_OP_PLUS;
}
| '-'
{
$$ = UNARY_OP_MINUS;
}
| '!'
{
$$ = UNARY_OP_LOGICNOT;
}
| '~'
{
$$ = UNARY_OP_BITNOT;
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
mul_expr: unary_expr
{
$$ = $1;
}
d3dcompiler: Parse multiplicative expressions.
2012-07-18 16:25:14 +02:00
| mul_expr '*' unary_expr
{
struct source_location loc;
set_location(&loc, &@2);
$$ = &hlsl_mul($1, $3, &loc)->node;
}
| mul_expr '/' unary_expr
{
struct source_location loc;
set_location(&loc, &@2);
$$ = &hlsl_div($1, $3, &loc)->node;
}
| mul_expr '%' unary_expr
{
struct source_location loc;
set_location(&loc, &@2);
$$ = &hlsl_mod($1, $3, &loc)->node;
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
add_expr: mul_expr
{
$$ = $1;
}
d3dcompiler: Implement basic expressions parsing.
2012-07-16 20:39:23 +02:00
| add_expr '+' mul_expr
{
struct source_location loc;
set_location(&loc, &@2);
$$ = &hlsl_add($1, $3, &loc)->node;
}
| add_expr '-' mul_expr
{
struct source_location loc;
set_location(&loc, &@2);
$$ = &hlsl_sub($1, $3, &loc)->node;
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
shift_expr: add_expr
{
$$ = $1;
}
d3dcompiler: Parse relational operators, stub out more rules.
2012-07-18 16:25:15 +02:00
| shift_expr OP_LEFTSHIFT add_expr
{
FIXME("Left shift\n");
}
| shift_expr OP_RIGHTSHIFT add_expr
{
FIXME("Right shift\n");
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
relational_expr: shift_expr
{
$$ = $1;
}
d3dcompiler: Parse relational operators, stub out more rules.
2012-07-18 16:25:15 +02:00
| relational_expr '<' shift_expr
{
struct source_location loc;
set_location(&loc, &@2);
$$ = &hlsl_lt($1, $3, &loc)->node;
}
| relational_expr '>' shift_expr
{
struct source_location loc;
set_location(&loc, &@2);
$$ = &hlsl_gt($1, $3, &loc)->node;
}
| relational_expr OP_LE shift_expr
{
struct source_location loc;
set_location(&loc, &@2);
$$ = &hlsl_le($1, $3, &loc)->node;
}
| relational_expr OP_GE shift_expr
{
struct source_location loc;
set_location(&loc, &@2);
$$ = &hlsl_ge($1, $3, &loc)->node;
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
equality_expr: relational_expr
{
$$ = $1;
}
d3dcompiler: Parse relational operators, stub out more rules.
2012-07-18 16:25:15 +02:00
| equality_expr OP_EQ relational_expr
{
struct source_location loc;
set_location(&loc, &@2);
$$ = &hlsl_eq($1, $3, &loc)->node;
}
| equality_expr OP_NE relational_expr
{
struct source_location loc;
set_location(&loc, &@2);
$$ = &hlsl_ne($1, $3, &loc)->node;
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
bitand_expr: equality_expr
{
$$ = $1;
}
d3dcompiler: Parse relational operators, stub out more rules.
2012-07-18 16:25:15 +02:00
| bitand_expr '&' equality_expr
{
FIXME("bitwise AND\n");
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
bitxor_expr: bitand_expr
{
$$ = $1;
}
d3dcompiler: Parse relational operators, stub out more rules.
2012-07-18 16:25:15 +02:00
| bitxor_expr '^' bitand_expr
{
FIXME("bitwise XOR\n");
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
bitor_expr: bitxor_expr
{
$$ = $1;
}
d3dcompiler: Parse relational operators, stub out more rules.
2012-07-18 16:25:15 +02:00
| bitor_expr '|' bitxor_expr
{
FIXME("bitwise OR\n");
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
logicand_expr: bitor_expr
{
$$ = $1;
}
d3dcompiler: Parse relational operators, stub out more rules.
2012-07-18 16:25:15 +02:00
| logicand_expr OP_AND bitor_expr
{
FIXME("logic AND\n");
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
logicor_expr: logicand_expr
{
$$ = $1;
}
d3dcompiler: Parse relational operators, stub out more rules.
2012-07-18 16:25:15 +02:00
| logicor_expr OP_OR logicand_expr
{
FIXME("logic OR\n");
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
conditional_expr: logicor_expr
{
$$ = $1;
}
d3dcompiler: Parse relational operators, stub out more rules.
2012-07-18 16:25:15 +02:00
| logicor_expr '?' expr ':' assignment_expr
{
FIXME("ternary operator\n");
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
assignment_expr: conditional_expr
{
$$ = $1;
}
d3dcompiler: Stub assignment parsing.
2012-07-20 16:37:40 +02:00
| unary_expr assign_op assignment_expr
{
d3dcompiler: Postincrement/decrement expressions are const. Also check for const expressions used as l-values.
2012-09-17 15:32:05 +02:00
struct source_location loc;
set_location(&loc, &@2);
if ($1->data_type->modifiers & HLSL_MODIFIER_CONST)
{
hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
"l-value is const");
return 1;
}
d3dcompiler: Parse assignments.
2012-07-20 16:37:41 +02:00
$$ = make_assignment($1, $2, BWRITERSP_WRITEMASK_ALL, $3);
if (!$$)
return 1;
d3dcompiler: Postincrement/decrement expressions are const. Also check for const expressions used as l-values.
2012-09-17 15:32:05 +02:00
$$->loc = loc;
d3dcompiler: Stub assignment parsing.
2012-07-20 16:37:40 +02:00
}
assign_op: '='
{
$$ = ASSIGN_OP_ASSIGN;
}
| OP_ADDASSIGN
{
$$ = ASSIGN_OP_ADD;
}
| OP_SUBASSIGN
{
$$ = ASSIGN_OP_SUB;
}
| OP_MULASSIGN
{
$$ = ASSIGN_OP_MUL;
}
| OP_DIVASSIGN
{
$$ = ASSIGN_OP_DIV;
}
| OP_MODASSIGN
{
$$ = ASSIGN_OP_MOD;
}
| OP_LEFTSHIFTASSIGN
{
$$ = ASSIGN_OP_LSHIFT;
}
| OP_RIGHTSHIFTASSIGN
{
$$ = ASSIGN_OP_RSHIFT;
}
| OP_ANDASSIGN
{
$$ = ASSIGN_OP_AND;
}
| OP_ORASSIGN
{
$$ = ASSIGN_OP_OR;
}
| OP_XORASSIGN
{
$$ = ASSIGN_OP_XOR;
}
d3dcompiler: Parse variable initializers, basic expressions.
2012-06-07 00:19:04 +02:00
expr: assignment_expr
{
$$ = $1;
}
| expr ',' assignment_expr
{
FIXME("Comma expression\n");
}
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
%%
d3dcompiler: Store (and begin to use) location information for variables.
2012-07-12 16:01:35 +02:00
static void set_location(struct source_location *loc, const struct YYLTYPE *l)
{
loc->file = hlsl_ctx.source_file;
loc->line = l->first_line;
loc->col = l->first_column;
}
d3dcompiler: Use location information in add_modifier().
2012-07-12 16:01:36 +02:00
static DWORD add_modifier(DWORD modifiers, DWORD mod, const struct YYLTYPE *loc)
{
if (modifiers & mod)
{
hlsl_report_message(hlsl_ctx.source_file, loc->first_line, loc->first_column, HLSL_LEVEL_ERROR,
"modifier '%s' already specified", debug_modifiers(mod));
return modifiers;
}
if (mod & (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR)
&& modifiers & (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR))
{
hlsl_report_message(hlsl_ctx.source_file, loc->first_line, loc->first_column, HLSL_LEVEL_ERROR,
"more than one matrix majority keyword");
return modifiers;
}
return modifiers | mod;
}
d3dcompiler: Carry around both shader major and minor version.
2012-07-10 15:39:43 +02:00
struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD major, DWORD minor,
const char *entrypoint, char **messages)
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
{
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
struct hlsl_ir_function_decl *function;
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
struct hlsl_scope *scope, *next_scope;
struct hlsl_type *hlsl_type, *next_type;
struct hlsl_ir_var *var, *next_var;
d3dcompiler: Track the location of each lexer token.
2012-07-12 16:01:33 +02:00
unsigned int i;
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
d3dcompiler: Initialize and fix compilation messages generation.
2012-07-10 15:39:45 +02:00
hlsl_ctx.status = PARSE_SUCCESS;
hlsl_ctx.messages.size = hlsl_ctx.messages.capacity = 0;
d3dcompiler: Track the location of each lexer token.
2012-07-12 16:01:33 +02:00
hlsl_ctx.line_no = hlsl_ctx.column = 1;
d3dcompiler: Add a stub lexer.
2012-05-15 16:12:57 +02:00
hlsl_ctx.source_file = d3dcompiler_strdup("");
d3dcompiler: Track the location of each lexer token.
2012-07-12 16:01:33 +02:00
hlsl_ctx.source_files = d3dcompiler_alloc(sizeof(*hlsl_ctx.source_files));
if (hlsl_ctx.source_files)
hlsl_ctx.source_files[0] = hlsl_ctx.source_file;
hlsl_ctx.source_files_count = 1;
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
hlsl_ctx.cur_scope = NULL;
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
hlsl_ctx.matrix_majority = HLSL_COLUMN_MAJOR;
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
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;
d3dcompiler: Declare predefined data types.
2012-09-18 18:18:05 +02:00
declare_predefined_types(hlsl_ctx.globals);
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
hlsl_parse();
d3dcompiler: Parse function definitions.
2012-06-11 19:18:34 +02:00
if (TRACE_ON(hlsl_parser))
{
struct hlsl_ir_function_decl *func;
TRACE("IR dump.\n");
LIST_FOR_EACH_ENTRY(func, &hlsl_ctx.functions, struct hlsl_ir_function_decl, node.entry)
{
if (func->body)
debug_dump_ir_function(func);
}
}
d3dcompiler: Initialize and fix compilation messages generation.
2012-07-10 15:39:45 +02:00
TRACE("Compilation status = %d\n", hlsl_ctx.status);
if (messages)
{
if (hlsl_ctx.messages.size)
*messages = hlsl_ctx.messages.string;
else
*messages = NULL;
}
else
{
if (hlsl_ctx.messages.capacity)
d3dcompiler_free(hlsl_ctx.messages.string);
}
d3dcompiler: Track the location of each lexer token.
2012-07-12 16:01:33 +02:00
for (i = 0; i < hlsl_ctx.source_files_count; ++i)
d3dcompiler_free((void *)hlsl_ctx.source_files[i]);
d3dcompiler_free(hlsl_ctx.source_files);
d3dcompiler: Parse function declarations.
2012-06-11 19:18:33 +02:00
TRACE("Freeing functions IR.\n");
LIST_FOR_EACH_ENTRY(function, &hlsl_ctx.functions, struct hlsl_ir_function_decl, node.entry)
free_function(function);
d3dcompiler: Add a stub lexer.
2012-05-15 16:12:57 +02:00
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
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: Store data types in a RB tree for faster search.
2012-09-19 19:46:12 +02:00
wine_rb_destroy(&scope->types, NULL, NULL);
d3dcompiler: Parse variable declarations.
2012-06-04 17:58:24 +02:00
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);
}
d3dcompiler: Add a stub parser.
2012-05-15 16:12:56 +02:00
return NULL;
}