?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dcompiler: Parse "return" statement.
[wine.git] / dlls / d3dcompiler_43 / hlsl.y
blob75b57412821d85127bd291653a0962496e3f49cb
1 /*
2 * HLSL parser
3 *
4 * Copyright 2008 Stefan Dösinger
5 * Copyright 2012 Matteo Bruni for CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21 %{
22 #include "config.h"
23 #include "wine/debug.h"
24
25 #include <stdio.h>
26
27 #include "d3dcompiler_private.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(hlsl_parser);
30
31 int hlsl_lex(void);
32
33 struct hlsl_parse_ctx hlsl_ctx;
34
35 struct YYLTYPE;
36 static void set_location(struct source_location *loc, const struct YYLTYPE *l);
37
38 void hlsl_message(const char *fmt, ...)
39 {
40 va_list args;
41
42 va_start(args, fmt);
43 compilation_message(&hlsl_ctx.messages, fmt, args);
44 va_end(args);
45 }
46
47 static const char *hlsl_get_error_level_name(enum hlsl_error_level level)
48 {
49 const char *names[] =
50 {
51 "error",
52 "warning",
53 "note",
54 };
55 return names[level];
56 }
57
58 void hlsl_report_message(const char *filename, DWORD line, DWORD column,
59 enum hlsl_error_level level, const char *fmt, ...)
60 {
61 va_list args;
62 char *string = NULL;
63 int rc, size = 0;
64
65 while (1)
66 {
67 va_start(args, fmt);
68 rc = vsnprintf(string, size, fmt, args);
69 va_end(args);
70
71 if (rc >= 0 && rc < size)
72 break;
73
74 if (rc >= size)
75 size = rc + 1;
76 else
77 size = size ? size * 2 : 32;
78
79 if (!string)
80 string = d3dcompiler_alloc(size);
81 else
82 string = d3dcompiler_realloc(string, size);
83 if (!string)
84 {
85 ERR("Error reallocating memory for a string.\n");
86 return;
87 }
88 }
89
90 hlsl_message("%s:%u:%u: %s: %s\n", filename, line, column, hlsl_get_error_level_name(level), string);
91 d3dcompiler_free(string);
92
93 if (level == HLSL_LEVEL_ERROR)
94 set_parse_status(&hlsl_ctx.status, PARSE_ERR);
95 else if (level == HLSL_LEVEL_WARNING)
96 set_parse_status(&hlsl_ctx.status, PARSE_WARN);
97 }
98
99 static void hlsl_error(const char *s)
100 {
101 hlsl_report_message(hlsl_ctx.source_file, hlsl_ctx.line_no, hlsl_ctx.column, HLSL_LEVEL_ERROR, "%s", s);
102 }
103
104 static void debug_dump_decl(struct hlsl_type *type, DWORD modifiers, const char *declname, unsigned int line_no)
105 {
106 TRACE("Line %u: ", line_no);
107 if (modifiers)
108 TRACE("%s ", debug_modifiers(modifiers));
109 TRACE("%s %s;\n", debug_hlsl_type(type), declname);
110 }
111
112 static void check_invalid_matrix_modifiers(DWORD modifiers, struct source_location *loc)
113 {
114 if (modifiers & (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR))
115 {
116 hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR,
117 "'row_major' or 'column_major' modifiers are only allowed for matrices");
118 }
119 }
120
121 static BOOL declare_variable(struct hlsl_ir_var *decl, BOOL local)
122 {
123 BOOL ret;
124
125 TRACE("Declaring variable %s.\n", decl->name);
126 if (decl->node.data_type->type == HLSL_CLASS_MATRIX)
127 {
128 if (!(decl->modifiers & (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR)))
129 {
130 decl->modifiers |= hlsl_ctx.matrix_majority == HLSL_ROW_MAJOR
131 ? HLSL_MODIFIER_ROW_MAJOR : HLSL_MODIFIER_COLUMN_MAJOR;
132 }
133 }
134 else
135 check_invalid_matrix_modifiers(decl->modifiers, &decl->node.loc);
136
137 if (local)
138 {
139 DWORD invalid = decl->modifiers & (HLSL_STORAGE_EXTERN | HLSL_STORAGE_SHARED
140 | HLSL_STORAGE_GROUPSHARED | HLSL_STORAGE_UNIFORM);
141 if (invalid)
142 {
143 hlsl_report_message(decl->node.loc.file, decl->node.loc.line, decl->node.loc.col, HLSL_LEVEL_ERROR,
144 "modifier '%s' invalid for local variables", debug_modifiers(invalid));
145 }
146 if (decl->semantic)
147 {
148 hlsl_report_message(decl->node.loc.file, decl->node.loc.line, decl->node.loc.col, HLSL_LEVEL_ERROR,
149 "semantics are not allowed on local variables");
150 return FALSE;
151 }
152 }
153 else
154 {
155 if (find_function(decl->name))
156 {
157 hlsl_report_message(decl->node.loc.file, decl->node.loc.line, decl->node.loc.col, HLSL_LEVEL_ERROR,
158 "redefinition of '%s'", decl->name);
159 return FALSE;
160 }
161 }
162 ret = add_declaration(hlsl_ctx.cur_scope, decl, local);
163 if (!ret)
164 {
165 struct hlsl_ir_var *old = get_variable(hlsl_ctx.cur_scope, decl->name);
166
167 hlsl_report_message(decl->node.loc.file, decl->node.loc.line, decl->node.loc.col, HLSL_LEVEL_ERROR,
168 "\"%s\" already declared", decl->name);
169 hlsl_report_message(old->node.loc.file, old->node.loc.line, old->node.loc.col, HLSL_LEVEL_NOTE,
170 "\"%s\" was previously declared here", old->name);
171 return FALSE;
172 }
173 return TRUE;
174 }
175
176 static DWORD add_modifier(DWORD modifiers, DWORD mod, const struct YYLTYPE *loc);
177
178 BOOL add_type_to_scope(struct hlsl_scope *scope, struct hlsl_type *def)
179 {
180 if (get_type(scope, def->name, FALSE))
181 return FALSE;
182
183 list_add_tail(&scope->types, &def->scope_entry);
184 return TRUE;
185 }
186
187 static void declare_predefined_types(struct hlsl_scope *scope)
188 {
189 struct hlsl_type *type;
190 unsigned int x, y, bt;
191 static const char *names[] =
192 {
193 "float",
194 "half",
195 "double",
196 "int",
197 "uint",
198 "bool",
199 };
200 char name[10];
201
202 for (bt = 0; bt <= HLSL_TYPE_LAST_SCALAR; ++bt)
203 {
204 for (y = 1; y <= 4; ++y)
205 {
206 for (x = 1; x <= 4; ++x)
207 {
208 sprintf(name, "%s%ux%u", names[bt], x, y);
209 type = new_hlsl_type(d3dcompiler_strdup(name), HLSL_CLASS_MATRIX, bt, x, y);
210 add_type_to_scope(scope, type);
211
212 if (y == 1)
213 {
214 sprintf(name, "%s%u", names[bt], x);
215 type = new_hlsl_type(d3dcompiler_strdup(name), HLSL_CLASS_VECTOR, bt, x, y);
216 add_type_to_scope(scope, type);
217
218 if (x == 1)
219 {
220 sprintf(name, "%s", names[bt]);
221 type = new_hlsl_type(d3dcompiler_strdup(name), HLSL_CLASS_SCALAR, bt, x, y);
222 add_type_to_scope(scope, type);
223 }
224 }
225 }
226 }
227 }
228
229 /* DX8 effects predefined types */
230 type = new_hlsl_type(d3dcompiler_strdup("DWORD"), HLSL_CLASS_SCALAR, HLSL_TYPE_INT, 1, 1);
231 add_type_to_scope(scope, type);
232 type = new_hlsl_type(d3dcompiler_strdup("FLOAT"), HLSL_CLASS_SCALAR, HLSL_TYPE_FLOAT, 1, 1);
233 add_type_to_scope(scope, type);
234 type = new_hlsl_type(d3dcompiler_strdup("VECTOR"), HLSL_CLASS_VECTOR, HLSL_TYPE_FLOAT, 4, 1);
235 add_type_to_scope(scope, type);
236 type = new_hlsl_type(d3dcompiler_strdup("MATRIX"), HLSL_CLASS_MATRIX, HLSL_TYPE_FLOAT, 4, 4);
237 add_type_to_scope(scope, type);
238 type = new_hlsl_type(d3dcompiler_strdup("STRING"), HLSL_CLASS_OBJECT, HLSL_TYPE_STRING, 1, 1);
239 add_type_to_scope(scope, type);
240 type = new_hlsl_type(d3dcompiler_strdup("TEXTURE"), HLSL_CLASS_OBJECT, HLSL_TYPE_TEXTURE, 1, 1);
241 add_type_to_scope(scope, type);
242 type = new_hlsl_type(d3dcompiler_strdup("PIXELSHADER"), HLSL_CLASS_OBJECT, HLSL_TYPE_PIXELSHADER, 1, 1);
243 add_type_to_scope(scope, type);
244 type = new_hlsl_type(d3dcompiler_strdup("VERTEXSHADER"), HLSL_CLASS_OBJECT, HLSL_TYPE_VERTEXSHADER, 1, 1);
245 add_type_to_scope(scope, type);
246 }
247
248 static unsigned int components_count_expr_list(struct list *list)
249 {
250 struct hlsl_ir_node *node;
251 unsigned int count = 0;
252
253 LIST_FOR_EACH_ENTRY(node, list, struct hlsl_ir_node, entry)
254 {
255 count += components_count_type(node->data_type);
256 }
257 return count;
258 }
259
260 static struct hlsl_ir_swizzle *new_swizzle(DWORD s, unsigned int components,
261 struct hlsl_ir_node *val, struct source_location *loc)
262 {
263 struct hlsl_ir_swizzle *swizzle = d3dcompiler_alloc(sizeof(*swizzle));
264
265 if (!swizzle)
266 return NULL;
267 swizzle->node.type = HLSL_IR_SWIZZLE;
268 swizzle->node.loc = *loc;
269 swizzle->node.data_type = new_hlsl_type(NULL, HLSL_CLASS_VECTOR, val->data_type->base_type, components, 1);
270 swizzle->val = val;
271 swizzle->swizzle = s;
272 return swizzle;
273 }
274
275 static struct hlsl_ir_swizzle *get_swizzle(struct hlsl_ir_node *value, const char *swizzle,
276 struct source_location *loc)
277 {
278 unsigned int len = strlen(swizzle), component = 0;
279 unsigned int i, set, swiz = 0;
280 BOOL valid;
281
282 if (value->data_type->type == HLSL_CLASS_MATRIX)
283 {
284 /* Matrix swizzle */
285 BOOL m_swizzle;
286 unsigned int inc, x, y;
287
288 if (len < 3 || swizzle[0] != '_')
289 return NULL;
290 m_swizzle = swizzle[1] == 'm';
291 inc = m_swizzle ? 4 : 3;
292
293 if (len % inc || len > inc * 4)
294 return NULL;
295
296 for (i = 0; i < len; i += inc)
297 {
298 if (swizzle[i] != '_')
299 return NULL;
300 if (m_swizzle)
301 {
302 if (swizzle[i + 1] != 'm')
303 return NULL;
304 x = swizzle[i + 2] - '0';
305 y = swizzle[i + 3] - '0';
306 }
307 else
308 {
309 x = swizzle[i + 1] - '1';
310 y = swizzle[i + 2] - '1';
311 }
312
313 if (x >= value->data_type->dimx || y >= value->data_type->dimy)
314 return NULL;
315 swiz |= (y << 4 | x) << component * 8;
316 component++;
317 }
318 return new_swizzle(swiz, component, value, loc);
319 }
320
321 /* Vector swizzle */
322 if (len > 4)
323 return NULL;
324
325 for (set = 0; set < 2; ++set)
326 {
327 valid = TRUE;
328 component = 0;
329 for (i = 0; i < len; ++i)
330 {
331 char c[2][4] = {{'x', 'y', 'z', 'w'}, {'r', 'g', 'b', 'a'}};
332 unsigned int s = 0;
333
334 for (s = 0; s < 4; ++s)
335 {
336 if (swizzle[i] == c[set][s])
337 break;
338 }
339 if (s == 4)
340 {
341 valid = FALSE;
342 break;
343 }
344
345 if (s >= value->data_type->dimx)
346 return NULL;
347 swiz |= s << component * 2;
348 component++;
349 }
350 if (valid)
351 return new_swizzle(swiz, component, value, loc);
352 }
353
354 return NULL;
355 }
356
357 %}
358
359 %locations
360 %error-verbose
361
362 %union
363 {
364 struct hlsl_type *type;
365 INT intval;
366 FLOAT floatval;
367 BOOL boolval;
368 char *name;
369 DWORD modifiers;
370 struct hlsl_ir_var *var;
371 struct hlsl_ir_node *instr;
372 struct list *list;
373 struct hlsl_ir_function_decl *function;
374 struct parse_parameter parameter;
375 struct parse_variable_def *variable_def;
376 enum parse_unary_op unary_op;
377 enum parse_assign_op assign_op;
378 }
379
380 %token KW_BLENDSTATE
381 %token KW_BREAK
382 %token KW_BUFFER
383 %token KW_CBUFFER
384 %token KW_COLUMN_MAJOR
385 %token KW_COMPILE
386 %token KW_CONST
387 %token KW_CONTINUE
388 %token KW_DEPTHSTENCILSTATE
389 %token KW_DEPTHSTENCILVIEW
390 %token KW_DISCARD
391 %token KW_DO
392 %token KW_DOUBLE
393 %token KW_ELSE
394 %token KW_EXTERN
395 %token KW_FALSE
396 %token KW_FOR
397 %token KW_GEOMETRYSHADER
398 %token KW_GROUPSHARED
399 %token KW_IF
400 %token KW_IN
401 %token KW_INLINE
402 %token KW_INOUT
403 %token KW_MATRIX
404 %token KW_NAMESPACE
405 %token KW_NOINTERPOLATION
406 %token KW_OUT
407 %token KW_PASS
408 %token KW_PIXELSHADER
409 %token KW_PRECISE
410 %token KW_RASTERIZERSTATE
411 %token KW_RENDERTARGETVIEW
412 %token KW_RETURN
413 %token KW_REGISTER
414 %token KW_ROW_MAJOR
415 %token KW_SAMPLER
416 %token KW_SAMPLER1D
417 %token KW_SAMPLER2D
418 %token KW_SAMPLER3D
419 %token KW_SAMPLERCUBE
420 %token KW_SAMPLER_STATE
421 %token KW_SAMPLERCOMPARISONSTATE
422 %token KW_SHARED
423 %token KW_STATEBLOCK
424 %token KW_STATEBLOCK_STATE
425 %token KW_STATIC
426 %token KW_STRING
427 %token KW_STRUCT
428 %token KW_SWITCH
429 %token KW_TBUFFER
430 %token KW_TECHNIQUE
431 %token KW_TECHNIQUE10
432 %token KW_TEXTURE
433 %token KW_TEXTURE1D
434 %token KW_TEXTURE1DARRAY
435 %token KW_TEXTURE2D
436 %token KW_TEXTURE2DARRAY
437 %token KW_TEXTURE2DMS
438 %token KW_TEXTURE2DMSARRAY
439 %token KW_TEXTURE3D
440 %token KW_TEXTURE3DARRAY
441 %token KW_TEXTURECUBE
442 %token KW_TRUE
443 %token KW_TYPEDEF
444 %token KW_UNIFORM
445 %token KW_VECTOR
446 %token KW_VERTEXSHADER
447 %token KW_VOID
448 %token KW_VOLATILE
449 %token KW_WHILE
450
451 %token OP_INC
452 %token OP_DEC
453 %token OP_AND
454 %token OP_OR
455 %token OP_EQ
456 %token OP_LEFTSHIFT
457 %token OP_LEFTSHIFTASSIGN
458 %token OP_RIGHTSHIFT
459 %token OP_RIGHTSHIFTASSIGN
460 %token OP_ELLIPSIS
461 %token OP_LE
462 %token OP_GE
463 %token OP_NE
464 %token OP_ADDASSIGN
465 %token OP_SUBASSIGN
466 %token OP_MULASSIGN
467 %token OP_DIVASSIGN
468 %token OP_MODASSIGN
469 %token OP_ANDASSIGN
470 %token OP_ORASSIGN
471 %token OP_XORASSIGN
472 %token OP_UNKNOWN1
473 %token OP_UNKNOWN2
474 %token OP_UNKNOWN3
475 %token OP_UNKNOWN4
476
477 %token <intval> PRE_LINE
478
479 %token <name> VAR_IDENTIFIER TYPE_IDENTIFIER NEW_IDENTIFIER
480 %type <name> any_identifier var_identifier
481 %token <name> STRING
482 %token <floatval> C_FLOAT
483 %token <intval> C_INTEGER
484 %type <boolval> boolean
485 %type <type> base_type
486 %type <type> type
487 %type <list> declaration_statement
488 %type <list> complex_initializer
489 %type <list> initializer_expr_list
490 %type <instr> initializer_expr
491 %type <modifiers> var_modifiers
492 %type <list> parameters
493 %type <list> param_list
494 %type <instr> expr
495 %type <var> variable
496 %type <intval> array
497 %type <list> statement
498 %type <list> statement_list
499 %type <list> compound_statement
500 %type <list> jump_statement
501 %type <function> func_declaration
502 %type <function> func_prototype
503 %type <parameter> parameter
504 %type <name> semantic
505 %type <variable_def> variable_def
506 %type <list> variables_def
507 %type <instr> primary_expr
508 %type <instr> postfix_expr
509 %type <instr> unary_expr
510 %type <instr> mul_expr
511 %type <instr> add_expr
512 %type <instr> shift_expr
513 %type <instr> relational_expr
514 %type <instr> equality_expr
515 %type <instr> bitand_expr
516 %type <instr> bitxor_expr
517 %type <instr> bitor_expr
518 %type <instr> logicand_expr
519 %type <instr> logicor_expr
520 %type <instr> conditional_expr
521 %type <instr> assignment_expr
522 %type <list> expr_statement
523 %type <unary_op> unary_op
524 %type <assign_op> assign_op
525 %type <modifiers> input_mod
526 %%
527
528 hlsl_prog: /* empty */
529 {
530 }
531 | hlsl_prog func_declaration
532 {
533 FIXME("Check that the function doesn't conflict with an already declared one.\n");
534 list_add_tail(&hlsl_ctx.functions, &$2->node.entry);
535 }
536 | hlsl_prog declaration_statement
537 {
538 TRACE("Declaration statement parsed.\n");
539 }
540 | hlsl_prog preproc_directive
541 {
542 }
543
544 preproc_directive: PRE_LINE STRING
545 {
546 TRACE("Updating line information to file %s, line %u\n", debugstr_a($2), $1);
547 hlsl_ctx.line_no = $1;
548 if (strcmp($2, hlsl_ctx.source_file))
549 {
550 const char **new_array;
551
552 hlsl_ctx.source_file = $2;
553 new_array = d3dcompiler_realloc(hlsl_ctx.source_files,
554 sizeof(*hlsl_ctx.source_files) * hlsl_ctx.source_files_count + 1);
555 if (new_array)
556 {
557 hlsl_ctx.source_files = new_array;
558 hlsl_ctx.source_files[hlsl_ctx.source_files_count++] = $2;
559 }
560 }
561 }
562
563 any_identifier: VAR_IDENTIFIER
564 | TYPE_IDENTIFIER
565 | NEW_IDENTIFIER
566
567 func_declaration: func_prototype compound_statement
568 {
569 TRACE("Function %s parsed.\n", $1->name);
570 $$ = $1;
571 $$->body = $2;
572 pop_scope(&hlsl_ctx);
573 }
574 | func_prototype ';'
575 {
576 TRACE("Function prototype for %s.\n", $1->name);
577 $$ = $1;
578 pop_scope(&hlsl_ctx);
579 }
580
581 func_prototype: var_modifiers type var_identifier '(' parameters ')' semantic
582 {
583 if (get_variable(hlsl_ctx.globals, $3))
584 {
585 hlsl_report_message(hlsl_ctx.source_file, @3.first_line, @3.first_column,
586 HLSL_LEVEL_ERROR, "redefinition of '%s'\n", $3);
587 return 1;
588 }
589 if ($2->base_type == HLSL_TYPE_VOID && $7)
590 {
591 hlsl_report_message(hlsl_ctx.source_file, @7.first_line, @7.first_column,
592 HLSL_LEVEL_ERROR, "void function with a semantic");
593 }
594
595 $$ = new_func_decl($3, $2, $5);
596 if (!$$)
597 {
598 ERR("Out of memory.\n");
599 return -1;
600 }
601 $$->semantic = $7;
602 }
603
604 compound_statement: '{' '}'
605 {
606 $$ = d3dcompiler_alloc(sizeof(*$$));
607 list_init($$);
608 }
609 | '{' scope_start statement_list '}'
610 {
611 pop_scope(&hlsl_ctx);
612 $$ = $3;
613 }
614
615 scope_start: /* Empty */
616 {
617 push_scope(&hlsl_ctx);
618 }
619
620 var_identifier: VAR_IDENTIFIER
621 | NEW_IDENTIFIER
622
623 semantic: /* Empty */
624 {
625 $$ = NULL;
626 }
627 | ':' any_identifier
628 {
629 $$ = $2;
630 }
631
632 parameters: scope_start
633 {
634 $$ = d3dcompiler_alloc(sizeof(*$$));
635 list_init($$);
636 }
637 | scope_start param_list
638 {
639 $$ = $2;
640 }
641
642 param_list: parameter
643 {
644 struct source_location loc;
645
646 $$ = d3dcompiler_alloc(sizeof(*$$));
647 list_init($$);
648 set_location(&loc, &@1);
649 if (!add_func_parameter($$, &$1, &loc))
650 {
651 ERR("Error adding function parameter %s.\n", $1.name);
652 set_parse_status(&hlsl_ctx.status, PARSE_ERR);
653 return -1;
654 }
655 }
656 | param_list ',' parameter
657 {
658 struct source_location loc;
659
660 $$ = $1;
661 set_location(&loc, &@3);
662 if (!add_func_parameter($$, &$3, &loc))
663 {
664 hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
665 "duplicate parameter %s", $3.name);
666 return 1;
667 }
668 }
669
670 parameter: input_mod var_modifiers type any_identifier semantic
671 {
672 $$.modifiers = $1;
673 $$.modifiers |= $2;
674 $$.type = $3;
675 $$.name = $4;
676 $$.semantic = $5;
677 }
678
679 input_mod: /* Empty */
680 {
681 $$ = HLSL_MODIFIER_IN;
682 }
683 | KW_IN
684 {
685 $$ = HLSL_MODIFIER_IN;
686 }
687 | KW_OUT
688 {
689 $$ = HLSL_MODIFIER_OUT;
690 }
691 | KW_INOUT
692 {
693 $$ = HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT;
694 }
695
696 type: base_type
697 {
698 $$ = $1;
699 }
700 | KW_VECTOR '<' base_type ',' C_INTEGER '>'
701 {
702 if ($3->type != HLSL_CLASS_SCALAR)
703 {
704 hlsl_message("Line %u: vectors of non-scalar types are not allowed.\n",
705 hlsl_ctx.line_no);
706 set_parse_status(&hlsl_ctx.status, PARSE_ERR);
707 return 1;
708 }
709 if ($5 < 1 || $5 > 4)
710 {
711 hlsl_message("Line %u: vector size must be between 1 and 4.\n",
712 hlsl_ctx.line_no);
713 set_parse_status(&hlsl_ctx.status, PARSE_ERR);
714 return 1;
715 }
716
717 $$ = new_hlsl_type(NULL, HLSL_CLASS_VECTOR, $3->base_type, $5, 1);
718 }
719 | KW_MATRIX '<' base_type ',' C_INTEGER ',' C_INTEGER '>'
720 {
721 if ($3->type != HLSL_CLASS_SCALAR)
722 {
723 hlsl_message("Line %u: matrices of non-scalar types are not allowed.\n",
724 hlsl_ctx.line_no);
725 set_parse_status(&hlsl_ctx.status, PARSE_ERR);
726 return 1;
727 }
728 if ($5 < 1 || $5 > 4 || $7 < 1 || $7 > 4)
729 {
730 hlsl_message("Line %u: matrix dimensions must be between 1 and 4.\n",
731 hlsl_ctx.line_no);
732 set_parse_status(&hlsl_ctx.status, PARSE_ERR);
733 return 1;
734 }
735
736 $$ = new_hlsl_type(NULL, HLSL_CLASS_MATRIX, $3->base_type, $5, $7);
737 }
738
739 base_type: KW_VOID
740 {
741 $$ = new_hlsl_type(d3dcompiler_strdup("void"), HLSL_CLASS_OBJECT, HLSL_TYPE_VOID, 1, 1);
742 }
743 | KW_SAMPLER
744 {
745 $$ = new_hlsl_type(d3dcompiler_strdup("sampler"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
746 $$->sampler_dim = HLSL_SAMPLER_DIM_GENERIC;
747 }
748 | KW_SAMPLER1D
749 {
750 $$ = new_hlsl_type(d3dcompiler_strdup("sampler1D"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
751 $$->sampler_dim = HLSL_SAMPLER_DIM_1D;
752 }
753 | KW_SAMPLER2D
754 {
755 $$ = new_hlsl_type(d3dcompiler_strdup("sampler2D"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
756 $$->sampler_dim = HLSL_SAMPLER_DIM_2D;
757 }
758 | KW_SAMPLER3D
759 {
760 $$ = new_hlsl_type(d3dcompiler_strdup("sampler3D"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
761 $$->sampler_dim = HLSL_SAMPLER_DIM_3D;
762 }
763 | KW_SAMPLERCUBE
764 {
765 $$ = new_hlsl_type(d3dcompiler_strdup("samplerCUBE"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
766 $$->sampler_dim = HLSL_SAMPLER_DIM_CUBE;
767 }
768 | TYPE_IDENTIFIER
769 {
770 struct hlsl_type *type;
771
772 TRACE("Type %s.\n", $1);
773 type = get_type(hlsl_ctx.cur_scope, $1, TRUE);
774 $$ = type;
775 d3dcompiler_free($1);
776 }
777 | KW_STRUCT TYPE_IDENTIFIER
778 {
779 struct hlsl_type *type;
780
781 TRACE("Struct type %s.\n", $2);
782 type = get_type(hlsl_ctx.cur_scope, $2, TRUE);
783 if (type->type != HLSL_CLASS_STRUCT)
784 {
785 hlsl_message("Line %u: redefining %s as a structure.\n",
786 hlsl_ctx.line_no, $2);
787 set_parse_status(&hlsl_ctx.status, PARSE_ERR);
788 }
789 else
790 {
791 $$ = type;
792 }
793 d3dcompiler_free($2);
794 }
795
796 declaration_statement: declaration
797 {
798 $$ = d3dcompiler_alloc(sizeof(*$$));
799 list_init($$);
800 }
801
802 declaration: var_modifiers type variables_def ';'
803 {
804 struct parse_variable_def *v, *v_next;
805 struct hlsl_ir_var *var;
806 BOOL ret, local = TRUE;
807
808 LIST_FOR_EACH_ENTRY_SAFE(v, v_next, $3, struct parse_variable_def, entry)
809 {
810 debug_dump_decl($2, $1, v->name, hlsl_ctx.line_no);
811 var = d3dcompiler_alloc(sizeof(*var));
812 var->node.type = HLSL_IR_VAR;
813 if (v->array_size)
814 var->node.data_type = new_array_type($2, v->array_size);
815 else
816 var->node.data_type = $2;
817 var->node.loc = v->loc;
818 var->name = v->name;
819 var->modifiers = $1;
820 var->semantic = v->semantic;
821
822 if (hlsl_ctx.cur_scope == hlsl_ctx.globals)
823 {
824 var->modifiers |= HLSL_STORAGE_UNIFORM;
825 local = FALSE;
826 }
827
828 if (var->modifiers & HLSL_MODIFIER_CONST && !v->initializer)
829 {
830 hlsl_report_message(v->loc.file, v->loc.line, v->loc.col,
831 HLSL_LEVEL_ERROR, "const variable without initializer");
832 free_declaration(var);
833 d3dcompiler_free(v);
834 continue;
835 }
836
837 ret = declare_variable(var, local);
838 if (!ret)
839 free_declaration(var);
840 else
841 TRACE("Declared variable %s.\n", var->name);
842
843 if (v->initializer)
844 {
845 FIXME("Variable with an initializer.\n");
846 free_instr_list(v->initializer);
847 }
848
849 d3dcompiler_free(v);
850 }
851 d3dcompiler_free($3);
852 }
853
854 variables_def: variable_def
855 {
856 $$ = d3dcompiler_alloc(sizeof(*$$));
857 list_init($$);
858 list_add_head($$, &$1->entry);
859 }
860 | variables_def ',' variable_def
861 {
862 $$ = $1;
863 list_add_tail($$, &$3->entry);
864 }
865
866 variable_def: any_identifier array semantic
867 {
868 $$ = d3dcompiler_alloc(sizeof(*$$));
869 set_location(&$$->loc, &@1);
870 $$->name = $1;
871 $$->array_size = $2;
872 $$->semantic = $3;
873 }
874 | any_identifier array semantic '=' complex_initializer
875 {
876 TRACE("Declaration with initializer.\n");
877 $$ = d3dcompiler_alloc(sizeof(*$$));
878 set_location(&$$->loc, &@1);
879 $$->name = $1;
880 $$->array_size = $2;
881 $$->semantic = $3;
882 $$->initializer = $5;
883 }
884
885 array: /* Empty */
886 {
887 $$ = 0;
888 }
889 | '[' expr ']'
890 {
891 FIXME("Array.\n");
892 $$ = 0;
893 free_instr($2);
894 }
895
896 var_modifiers: /* Empty */
897 {
898 $$ = 0;
899 }
900 | KW_EXTERN var_modifiers
901 {
902 $$ = add_modifier($2, HLSL_STORAGE_EXTERN, &@1);
903 }
904 | KW_NOINTERPOLATION var_modifiers
905 {
906 $$ = add_modifier($2, HLSL_STORAGE_NOINTERPOLATION, &@1);
907 }
908 | KW_PRECISE var_modifiers
909 {
910 $$ = add_modifier($2, HLSL_MODIFIER_PRECISE, &@1);
911 }
912 | KW_SHARED var_modifiers
913 {
914 $$ = add_modifier($2, HLSL_STORAGE_SHARED, &@1);
915 }
916 | KW_GROUPSHARED var_modifiers
917 {
918 $$ = add_modifier($2, HLSL_STORAGE_GROUPSHARED, &@1);
919 }
920 | KW_STATIC var_modifiers
921 {
922 $$ = add_modifier($2, HLSL_STORAGE_STATIC, &@1);
923 }
924 | KW_UNIFORM var_modifiers
925 {
926 $$ = add_modifier($2, HLSL_STORAGE_UNIFORM, &@1);
927 }
928 | KW_VOLATILE var_modifiers
929 {
930 $$ = add_modifier($2, HLSL_STORAGE_VOLATILE, &@1);
931 }
932 | KW_CONST var_modifiers
933 {
934 $$ = add_modifier($2, HLSL_MODIFIER_CONST, &@1);
935 }
936 | KW_ROW_MAJOR var_modifiers
937 {
938 $$ = add_modifier($2, HLSL_MODIFIER_ROW_MAJOR, &@1);
939 }
940 | KW_COLUMN_MAJOR var_modifiers
941 {
942 $$ = add_modifier($2, HLSL_MODIFIER_COLUMN_MAJOR, &@1);
943 }
944
945 complex_initializer: initializer_expr
946 {
947 $$ = d3dcompiler_alloc(sizeof(*$$));
948 list_init($$);
949 list_add_head($$, &$1->entry);
950 }
951 | '{' initializer_expr_list '}'
952 {
953 $$ = $2;
954 }
955
956 initializer_expr: assignment_expr
957 {
958 $$ = $1;
959 }
960
961 initializer_expr_list: initializer_expr
962 {
963 $$ = d3dcompiler_alloc(sizeof(*$$));
964 list_init($$);
965 list_add_head($$, &$1->entry);
966 }
967 | initializer_expr_list ',' initializer_expr
968 {
969 $$ = $1;
970 list_add_tail($$, &$3->entry);
971 }
972
973 boolean: KW_TRUE
974 {
975 $$ = TRUE;
976 }
977 | KW_FALSE
978 {
979 $$ = FALSE;
980 }
981
982 statement_list: statement
983 {
984 $$ = $1;
985 }
986 | statement_list statement
987 {
988 $$ = $1;
989 list_move_tail($$, $2);
990 d3dcompiler_free($2);
991 }
992
993 statement: declaration_statement
994 | expr_statement
995 | compound_statement
996 | jump_statement
997
998 /* FIXME: add rule for return with no value */
999 jump_statement: KW_RETURN expr ';'
1000 {
1001 struct hlsl_ir_jump *jump = d3dcompiler_alloc(sizeof(*jump));
1002 if (!jump)
1003 {
1004 ERR("Out of memory\n");
1005 return -1;
1006 }
1007 jump->node.type = HLSL_IR_JUMP;
1008 set_location(&jump->node.loc, &@1);
1009 jump->type = HLSL_IR_JUMP_RETURN;
1010 jump->node.data_type = $2->data_type;
1011 jump->return_value = $2;
1012
1013 FIXME("Check for valued return on void function.\n");
1014 FIXME("Implicit conversion to the return type if needed, "
1015 "error out if conversion not possible.\n");
1016
1017 $$ = d3dcompiler_alloc(sizeof(*$$));
1018 list_init($$);
1019 list_add_tail($$, &jump->node.entry);
1020 }
1021
1022 expr_statement: ';'
1023 {
1024 $$ = d3dcompiler_alloc(sizeof(*$$));
1025 list_init($$);
1026 }
1027 | expr ';'
1028 {
1029 $$ = d3dcompiler_alloc(sizeof(*$$));
1030 list_init($$);
1031 if ($1)
1032 list_add_head($$, &$1->entry);
1033 }
1034
1035 primary_expr: C_FLOAT
1036 {
1037 struct hlsl_ir_constant *c = d3dcompiler_alloc(sizeof(*c));
1038 if (!c)
1039 {
1040 ERR("Out of memory.\n");
1041 return -1;
1042 }
1043 c->node.type = HLSL_IR_CONSTANT;
1044 set_location(&c->node.loc, &yylloc);
1045 c->node.data_type = new_hlsl_type("float", HLSL_CLASS_SCALAR, HLSL_TYPE_FLOAT, 1, 1);
1046 c->v.value.f[0] = $1;
1047 $$ = &c->node;
1048 }
1049 | C_INTEGER
1050 {
1051 struct hlsl_ir_constant *c = d3dcompiler_alloc(sizeof(*c));
1052 if (!c)
1053 {
1054 ERR("Out of memory.\n");
1055 return -1;
1056 }
1057 c->node.type = HLSL_IR_CONSTANT;
1058 set_location(&c->node.loc, &yylloc);
1059 c->node.data_type = new_hlsl_type("int", HLSL_CLASS_SCALAR, HLSL_TYPE_INT, 1, 1);
1060 c->v.value.i[0] = $1;
1061 $$ = &c->node;
1062 }
1063 | boolean
1064 {
1065 struct hlsl_ir_constant *c = d3dcompiler_alloc(sizeof(*c));
1066 if (!c)
1067 {
1068 ERR("Out of memory.\n");
1069 return -1;
1070 }
1071 c->node.type = HLSL_IR_CONSTANT;
1072 set_location(&c->node.loc, &yylloc);
1073 c->node.data_type = new_hlsl_type("bool", HLSL_CLASS_SCALAR, HLSL_TYPE_BOOL, 1, 1);
1074 c->v.value.b[0] = $1;
1075 $$ = &c->node;
1076 }
1077 | variable
1078 {
1079 struct hlsl_ir_deref *deref = new_var_deref($1);
1080 if (deref)
1081 {
1082 $$ = &deref->node;
1083 set_location(&$$->loc, &@1);
1084 }
1085 else
1086 $$ = NULL;
1087 }
1088 | '(' expr ')'
1089 {
1090 $$ = $2;
1091 }
1092
1093 variable: VAR_IDENTIFIER
1094 {
1095 struct hlsl_ir_var *var;
1096 var = get_variable(hlsl_ctx.cur_scope, $1);
1097 if (!var)
1098 {
1099 hlsl_message("Line %d: variable '%s' not declared\n",
1100 hlsl_ctx.line_no, $1);
1101 set_parse_status(&hlsl_ctx.status, PARSE_ERR);
1102 return 1;
1103 }
1104 $$ = var;
1105 }
1106
1107 postfix_expr: primary_expr
1108 {
1109 $$ = $1;
1110 }
1111 | postfix_expr OP_INC
1112 {
1113 struct hlsl_ir_node *operands[3];
1114 struct source_location loc;
1115
1116 set_location(&loc, &@2);
1117 if ($1->data_type->modifiers & HLSL_MODIFIER_CONST)
1118 {
1119 hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
1120 "modifying a const expression");
1121 return 1;
1122 }
1123 operands[0] = $1;
1124 operands[1] = operands[2] = NULL;
1125 $$ = &new_expr(HLSL_IR_BINOP_POSTINC, operands, &loc)->node;
1126 /* Post increment/decrement expressions are considered const */
1127 $$->data_type = clone_hlsl_type($$->data_type);
1128 $$->data_type->modifiers |= HLSL_MODIFIER_CONST;
1129 }
1130 | postfix_expr OP_DEC
1131 {
1132 struct hlsl_ir_node *operands[3];
1133 struct source_location loc;
1134
1135 set_location(&loc, &@2);
1136 if ($1->data_type->modifiers & HLSL_MODIFIER_CONST)
1137 {
1138 hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
1139 "modifying a const expression");
1140 return 1;
1141 }
1142 operands[0] = $1;
1143 operands[1] = operands[2] = NULL;
1144 $$ = &new_expr(HLSL_IR_BINOP_POSTDEC, operands, &loc)->node;
1145 /* Post increment/decrement expressions are considered const */
1146 $$->data_type = clone_hlsl_type($$->data_type);
1147 $$->data_type->modifiers |= HLSL_MODIFIER_CONST;
1148 }
1149 | postfix_expr '.' any_identifier
1150 {
1151 struct source_location loc;
1152
1153 set_location(&loc, &@2);
1154 if ($1->data_type->type <= HLSL_CLASS_LAST_NUMERIC)
1155 {
1156 struct hlsl_ir_swizzle *swizzle;
1157
1158 swizzle = get_swizzle($1, $3, &loc);
1159 if (!swizzle)
1160 {
1161 hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
1162 "invalid swizzle %s", debugstr_a($3));
1163 return 1;
1164 }
1165 $$ = &swizzle->node;
1166 }
1167 else
1168 {
1169 hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
1170 "invalid subscript %s", debugstr_a($3));
1171 return 1;
1172 }
1173 }
1174 /* "var_modifiers" doesn't make sense in this case, but it's needed
1175 in the grammar to avoid shift/reduce conflicts. */
1176 | var_modifiers type '(' initializer_expr_list ')'
1177 {
1178 struct hlsl_ir_constructor *constructor;
1179
1180 TRACE("%s constructor.\n", debug_hlsl_type($2));
1181 if ($1)
1182 {
1183 hlsl_message("Line %u: unexpected modifier in a constructor.\n",
1184 hlsl_ctx.line_no);
1185 set_parse_status(&hlsl_ctx.status, PARSE_ERR);
1186 return -1;
1187 }
1188 if ($2->type > HLSL_CLASS_LAST_NUMERIC)
1189 {
1190 hlsl_message("Line %u: constructors are allowed only for numeric data types.\n",
1191 hlsl_ctx.line_no);
1192 set_parse_status(&hlsl_ctx.status, PARSE_ERR);
1193 return -1;
1194 }
1195 if ($2->dimx * $2->dimy != components_count_expr_list($4))
1196 {
1197 hlsl_message("Line %u: wrong number of components in constructor.\n",
1198 hlsl_ctx.line_no);
1199 set_parse_status(&hlsl_ctx.status, PARSE_ERR);
1200 return -1;
1201 }
1202
1203 constructor = d3dcompiler_alloc(sizeof(*constructor));
1204 constructor->node.type = HLSL_IR_CONSTRUCTOR;
1205 set_location(&constructor->node.loc, &@3);
1206 constructor->node.data_type = $2;
1207 constructor->arguments = $4;
1208
1209 $$ = &constructor->node;
1210 }
1211
1212 unary_expr: postfix_expr
1213 {
1214 $$ = $1;
1215 }
1216 | OP_INC unary_expr
1217 {
1218 struct hlsl_ir_node *operands[3];
1219 struct source_location loc;
1220
1221 set_location(&loc, &@1);
1222 if ($2->data_type->modifiers & HLSL_MODIFIER_CONST)
1223 {
1224 hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
1225 "modifying a const expression");
1226 return 1;
1227 }
1228 operands[0] = $2;
1229 operands[1] = operands[2] = NULL;
1230 $$ = &new_expr(HLSL_IR_BINOP_PREINC, operands, &loc)->node;
1231 }
1232 | OP_DEC unary_expr
1233 {
1234 struct hlsl_ir_node *operands[3];
1235 struct source_location loc;
1236
1237 set_location(&loc, &@1);
1238 if ($2->data_type->modifiers & HLSL_MODIFIER_CONST)
1239 {
1240 hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
1241 "modifying a const expression");
1242 return 1;
1243 }
1244 operands[0] = $2;
1245 operands[1] = operands[2] = NULL;
1246 $$ = &new_expr(HLSL_IR_BINOP_PREDEC, operands, &loc)->node;
1247 }
1248 | unary_op unary_expr
1249 {
1250 enum hlsl_ir_expr_op ops[] = {0, HLSL_IR_UNOP_NEG,
1251 HLSL_IR_UNOP_LOGIC_NOT, HLSL_IR_UNOP_BIT_NOT};
1252 struct hlsl_ir_node *operands[3];
1253 struct source_location loc;
1254
1255 if ($1 == UNARY_OP_PLUS)
1256 {
1257 $$ = $2;
1258 }
1259 else
1260 {
1261 operands[0] = $2;
1262 operands[1] = operands[2] = NULL;
1263 set_location(&loc, &@1);
1264 $$ = &new_expr(ops[$1], operands, &loc)->node;
1265 }
1266 }
1267
1268 unary_op: '+'
1269 {
1270 $$ = UNARY_OP_PLUS;
1271 }
1272 | '-'
1273 {
1274 $$ = UNARY_OP_MINUS;
1275 }
1276 | '!'
1277 {
1278 $$ = UNARY_OP_LOGICNOT;
1279 }
1280 | '~'
1281 {
1282 $$ = UNARY_OP_BITNOT;
1283 }
1284
1285 mul_expr: unary_expr
1286 {
1287 $$ = $1;
1288 }
1289 | mul_expr '*' unary_expr
1290 {
1291 struct source_location loc;
1292
1293 set_location(&loc, &@2);
1294 $$ = &hlsl_mul($1, $3, &loc)->node;
1295 }
1296 | mul_expr '/' unary_expr
1297 {
1298 struct source_location loc;
1299
1300 set_location(&loc, &@2);
1301 $$ = &hlsl_div($1, $3, &loc)->node;
1302 }
1303 | mul_expr '%' unary_expr
1304 {
1305 struct source_location loc;
1306
1307 set_location(&loc, &@2);
1308 $$ = &hlsl_mod($1, $3, &loc)->node;
1309 }
1310
1311 add_expr: mul_expr
1312 {
1313 $$ = $1;
1314 }
1315 | add_expr '+' mul_expr
1316 {
1317 struct source_location loc;
1318
1319 set_location(&loc, &@2);
1320 $$ = &hlsl_add($1, $3, &loc)->node;
1321 }
1322 | add_expr '-' mul_expr
1323 {
1324 struct source_location loc;
1325
1326 set_location(&loc, &@2);
1327 $$ = &hlsl_sub($1, $3, &loc)->node;
1328 }
1329
1330 shift_expr: add_expr
1331 {
1332 $$ = $1;
1333 }
1334 | shift_expr OP_LEFTSHIFT add_expr
1335 {
1336 FIXME("Left shift\n");
1337 }
1338 | shift_expr OP_RIGHTSHIFT add_expr
1339 {
1340 FIXME("Right shift\n");
1341 }
1342
1343 relational_expr: shift_expr
1344 {
1345 $$ = $1;
1346 }
1347 | relational_expr '<' shift_expr
1348 {
1349 struct source_location loc;
1350
1351 set_location(&loc, &@2);
1352 $$ = &hlsl_lt($1, $3, &loc)->node;
1353 }
1354 | relational_expr '>' shift_expr
1355 {
1356 struct source_location loc;
1357
1358 set_location(&loc, &@2);
1359 $$ = &hlsl_gt($1, $3, &loc)->node;
1360 }
1361 | relational_expr OP_LE shift_expr
1362 {
1363 struct source_location loc;
1364
1365 set_location(&loc, &@2);
1366 $$ = &hlsl_le($1, $3, &loc)->node;
1367 }
1368 | relational_expr OP_GE shift_expr
1369 {
1370 struct source_location loc;
1371
1372 set_location(&loc, &@2);
1373 $$ = &hlsl_ge($1, $3, &loc)->node;
1374 }
1375
1376 equality_expr: relational_expr
1377 {
1378 $$ = $1;
1379 }
1380 | equality_expr OP_EQ relational_expr
1381 {
1382 struct source_location loc;
1383
1384 set_location(&loc, &@2);
1385 $$ = &hlsl_eq($1, $3, &loc)->node;
1386 }
1387 | equality_expr OP_NE relational_expr
1388 {
1389 struct source_location loc;
1390
1391 set_location(&loc, &@2);
1392 $$ = &hlsl_ne($1, $3, &loc)->node;
1393 }
1394
1395 bitand_expr: equality_expr
1396 {
1397 $$ = $1;
1398 }
1399 | bitand_expr '&' equality_expr
1400 {
1401 FIXME("bitwise AND\n");
1402 }
1403
1404 bitxor_expr: bitand_expr
1405 {
1406 $$ = $1;
1407 }
1408 | bitxor_expr '^' bitand_expr
1409 {
1410 FIXME("bitwise XOR\n");
1411 }
1412
1413 bitor_expr: bitxor_expr
1414 {
1415 $$ = $1;
1416 }
1417 | bitor_expr '|' bitxor_expr
1418 {
1419 FIXME("bitwise OR\n");
1420 }
1421
1422 logicand_expr: bitor_expr
1423 {
1424 $$ = $1;
1425 }
1426 | logicand_expr OP_AND bitor_expr
1427 {
1428 FIXME("logic AND\n");
1429 }
1430
1431 logicor_expr: logicand_expr
1432 {
1433 $$ = $1;
1434 }
1435 | logicor_expr OP_OR logicand_expr
1436 {
1437 FIXME("logic OR\n");
1438 }
1439
1440 conditional_expr: logicor_expr
1441 {
1442 $$ = $1;
1443 }
1444 | logicor_expr '?' expr ':' assignment_expr
1445 {
1446 FIXME("ternary operator\n");
1447 }
1448
1449 assignment_expr: conditional_expr
1450 {
1451 $$ = $1;
1452 }
1453 | unary_expr assign_op assignment_expr
1454 {
1455 struct source_location loc;
1456
1457 set_location(&loc, &@2);
1458 if ($1->data_type->modifiers & HLSL_MODIFIER_CONST)
1459 {
1460 hlsl_report_message(loc.file, loc.line, loc.col, HLSL_LEVEL_ERROR,
1461 "l-value is const");
1462 return 1;
1463 }
1464 $$ = make_assignment($1, $2, BWRITERSP_WRITEMASK_ALL, $3);
1465 if (!$$)
1466 return 1;
1467 $$->loc = loc;
1468 }
1469
1470 assign_op: '='
1471 {
1472 $$ = ASSIGN_OP_ASSIGN;
1473 }
1474 | OP_ADDASSIGN
1475 {
1476 $$ = ASSIGN_OP_ADD;
1477 }
1478 | OP_SUBASSIGN
1479 {
1480 $$ = ASSIGN_OP_SUB;
1481 }
1482 | OP_MULASSIGN
1483 {
1484 $$ = ASSIGN_OP_MUL;
1485 }
1486 | OP_DIVASSIGN
1487 {
1488 $$ = ASSIGN_OP_DIV;
1489 }
1490 | OP_MODASSIGN
1491 {
1492 $$ = ASSIGN_OP_MOD;
1493 }
1494 | OP_LEFTSHIFTASSIGN
1495 {
1496 $$ = ASSIGN_OP_LSHIFT;
1497 }
1498 | OP_RIGHTSHIFTASSIGN
1499 {
1500 $$ = ASSIGN_OP_RSHIFT;
1501 }
1502 | OP_ANDASSIGN
1503 {
1504 $$ = ASSIGN_OP_AND;
1505 }
1506 | OP_ORASSIGN
1507 {
1508 $$ = ASSIGN_OP_OR;
1509 }
1510 | OP_XORASSIGN
1511 {
1512 $$ = ASSIGN_OP_XOR;
1513 }
1514
1515 expr: assignment_expr
1516 {
1517 $$ = $1;
1518 }
1519 | expr ',' assignment_expr
1520 {
1521 FIXME("Comma expression\n");
1522 }
1523
1524 %%
1525
1526 static void set_location(struct source_location *loc, const struct YYLTYPE *l)
1527 {
1528 loc->file = hlsl_ctx.source_file;
1529 loc->line = l->first_line;
1530 loc->col = l->first_column;
1531 }
1532
1533 static DWORD add_modifier(DWORD modifiers, DWORD mod, const struct YYLTYPE *loc)
1534 {
1535 if (modifiers & mod)
1536 {
1537 hlsl_report_message(hlsl_ctx.source_file, loc->first_line, loc->first_column, HLSL_LEVEL_ERROR,
1538 "modifier '%s' already specified", debug_modifiers(mod));
1539 return modifiers;
1540 }
1541 if (mod & (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR)
1542 && modifiers & (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR))
1543 {
1544 hlsl_report_message(hlsl_ctx.source_file, loc->first_line, loc->first_column, HLSL_LEVEL_ERROR,
1545 "more than one matrix majority keyword");
1546 return modifiers;
1547 }
1548 return modifiers | mod;
1549 }
1550
1551 struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD major, DWORD minor,
1552 const char *entrypoint, char **messages)
1553 {
1554 struct hlsl_ir_function_decl *function;
1555 struct hlsl_scope *scope, *next_scope;
1556 struct hlsl_type *hlsl_type, *next_type;
1557 struct hlsl_ir_var *var, *next_var;
1558 unsigned int i;
1559
1560 hlsl_ctx.status = PARSE_SUCCESS;
1561 hlsl_ctx.messages.size = hlsl_ctx.messages.capacity = 0;
1562 hlsl_ctx.line_no = hlsl_ctx.column = 1;
1563 hlsl_ctx.source_file = d3dcompiler_strdup("");
1564 hlsl_ctx.source_files = d3dcompiler_alloc(sizeof(*hlsl_ctx.source_files));
1565 if (hlsl_ctx.source_files)
1566 hlsl_ctx.source_files[0] = hlsl_ctx.source_file;
1567 hlsl_ctx.source_files_count = 1;
1568 hlsl_ctx.cur_scope = NULL;
1569 hlsl_ctx.matrix_majority = HLSL_COLUMN_MAJOR;
1570 list_init(&hlsl_ctx.scopes);
1571 list_init(&hlsl_ctx.types);
1572 list_init(&hlsl_ctx.functions);
1573
1574 push_scope(&hlsl_ctx);
1575 hlsl_ctx.globals = hlsl_ctx.cur_scope;
1576 declare_predefined_types(hlsl_ctx.globals);
1577
1578 hlsl_parse();
1579
1580 if (TRACE_ON(hlsl_parser))
1581 {
1582 struct hlsl_ir_function_decl *func;
1583
1584 TRACE("IR dump.\n");
1585 LIST_FOR_EACH_ENTRY(func, &hlsl_ctx.functions, struct hlsl_ir_function_decl, node.entry)
1586 {
1587 if (func->body)
1588 debug_dump_ir_function(func);
1589 }
1590 }
1591
1592 TRACE("Compilation status = %d\n", hlsl_ctx.status);
1593 if (messages)
1594 {
1595 if (hlsl_ctx.messages.size)
1596 *messages = hlsl_ctx.messages.string;
1597 else
1598 *messages = NULL;
1599 }
1600 else
1601 {
1602 if (hlsl_ctx.messages.capacity)
1603 d3dcompiler_free(hlsl_ctx.messages.string);
1604 }
1605
1606 for (i = 0; i < hlsl_ctx.source_files_count; ++i)
1607 d3dcompiler_free((void *)hlsl_ctx.source_files[i]);
1608 d3dcompiler_free(hlsl_ctx.source_files);
1609
1610 TRACE("Freeing functions IR.\n");
1611 LIST_FOR_EACH_ENTRY(function, &hlsl_ctx.functions, struct hlsl_ir_function_decl, node.entry)
1612 free_function(function);
1613
1614 TRACE("Freeing variables.\n");
1615 LIST_FOR_EACH_ENTRY_SAFE(scope, next_scope, &hlsl_ctx.scopes, struct hlsl_scope, entry)
1616 {
1617 LIST_FOR_EACH_ENTRY_SAFE(var, next_var, &scope->vars, struct hlsl_ir_var, scope_entry)
1618 {
1619 free_declaration(var);
1620 }
1621 d3dcompiler_free(scope);
1622 }
1623
1624 TRACE("Freeing types.\n");
1625 LIST_FOR_EACH_ENTRY_SAFE(hlsl_type, next_type, &hlsl_ctx.types, struct hlsl_type, entry)
1626 {
1627 free_hlsl_type(hlsl_type);
1628 }
1629
1630 return NULL;
1631 }
Windows API implementation