dlls/d3dcompiler_43/hlsl.y

   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 void hlsl_message(const char *fmt, ...)
  36 {
  37     va_list args;
  38
  39     va_start(args, fmt);
  40     compilation_message(&hlsl_ctx.messages, fmt, args);
  41     va_end(args);
  42 }
  43
  44 static const char *hlsl_get_error_level_name(enum hlsl_error_level level)
  45 {
  46     const char *names[] =
  47     {
  48         "error",
  49         "warning",
  50         "note",
  51     };
  52     return names[level];
  53 }
  54
  55 void hlsl_report_message(const char *filename, DWORD line, DWORD column,
  56         enum hlsl_error_level level, const char *fmt, ...)
  57 {
  58     va_list args;
  59     char *string = NULL;
  60     int rc, size = 0;
  61
  62     while (1)
  63     {
  64         va_start(args, fmt);
  65         rc = vsnprintf(string, size, fmt, args);
  66         va_end(args);
  67
  68         if (rc >= 0 && rc < size)
  69             break;
  70
  71         if (rc >= size)
  72             size = rc + 1;
  73         else
  74             size = size ? size * 2 : 32;
  75
  76         if (!string)
  77             string = d3dcompiler_alloc(size);
  78         else
  79             string = d3dcompiler_realloc(string, size);
  80         if (!string)
  81         {
  82             ERR("Error reallocating memory for a string.\n");
  83             return;
  84         }
  85     }
  86
  87     hlsl_message("%s:%u:%u: %s: %s\n", filename, line, column, hlsl_get_error_level_name(level), string);
  88     d3dcompiler_free(string);
  89
  90     if (level == HLSL_LEVEL_ERROR)
  91         set_parse_status(&hlsl_ctx.status, PARSE_ERR);
  92     else if (level == HLSL_LEVEL_WARNING)
  93         set_parse_status(&hlsl_ctx.status, PARSE_WARN);
  94 }
  95
  96 static void hlsl_error(const char *s)
  97 {
  98     hlsl_report_message(hlsl_ctx.source_file, hlsl_ctx.line_no, 1, HLSL_LEVEL_ERROR, "%s", s);
  99 }
 100
 101 static void debug_dump_decl(struct hlsl_type *type, DWORD modifiers, const char *declname, unsigned int line_no)
 102 {
 103     TRACE("Line %u: ", line_no);
 104     if (modifiers)
 105         TRACE("%s ", debug_modifiers(modifiers));
 106     TRACE("%s %s;\n", debug_hlsl_type(type), declname);
 107 }
 108
 109 static BOOL declare_variable(struct hlsl_ir_var *decl, BOOL local)
 110 {
 111     BOOL ret;
 112
 113     TRACE("Declaring variable %s.\n", decl->name);
 114     if (decl->node.data_type->type == HLSL_CLASS_MATRIX)
 115     {
 116         if (!(decl->modifiers & (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR)))
 117         {
 118             decl->modifiers |= hlsl_ctx.matrix_majority == HLSL_ROW_MAJOR
 119                     ? HLSL_MODIFIER_ROW_MAJOR : HLSL_MODIFIER_COLUMN_MAJOR;
 120         }
 121     }
 122     if (local)
 123     {
 124         DWORD invalid = decl->modifiers & (HLSL_STORAGE_EXTERN | HLSL_STORAGE_SHARED
 125                 | HLSL_STORAGE_GROUPSHARED | HLSL_STORAGE_UNIFORM);
 126         if (invalid)
 127         {
 128             hlsl_message("Line %u: modifier '%s' invalid for local variables.\n",
 129                     hlsl_ctx.line_no, debug_modifiers(invalid));
 130             set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 131         }
 132     }
 133     ret = add_declaration(hlsl_ctx.cur_scope, decl, local);
 134     if (ret == FALSE)
 135     {
 136         struct hlsl_ir_var *old = get_variable(hlsl_ctx.cur_scope, decl->name);
 137
 138         hlsl_message("Line %u: \"%s\" already declared.\n", hlsl_ctx.line_no, decl->name);
 139         hlsl_message("Line %u: \"%s\" was previously declared here.\n", old->node.line, decl->name);
 140         set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 141         return FALSE;
 142     }
 143     return TRUE;
 144 }
 145
 146 static DWORD add_modifier(DWORD modifiers, DWORD mod)
 147 {
 148     if (modifiers & mod)
 149     {
 150         hlsl_message("Line %u: modifier '%s' already specified.\n",
 151                      hlsl_ctx.line_no, debug_modifiers(mod));
 152         set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 153         return modifiers;
 154     }
 155     if (mod & (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR)
 156             && modifiers & (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR))
 157     {
 158         hlsl_message("Line %u: more than one matrix majority keyword.\n",
 159                 hlsl_ctx.line_no);
 160         set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 161         return modifiers;
 162     }
 163     return modifiers | mod;
 164 }
 165
 166 static unsigned int components_count_expr_list(struct list *list)
 167 {
 168     struct hlsl_ir_node *node;
 169     unsigned int count = 0;
 170
 171     LIST_FOR_EACH_ENTRY(node, list, struct hlsl_ir_node, entry)
 172     {
 173         count += components_count_type(node->data_type);
 174     }
 175     return count;
 176 }
 177
 178 %}
 179
 180 %error-verbose
 181
 182 %union
 183 {
 184     struct hlsl_type *type;
 185     INT intval;
 186     FLOAT floatval;
 187     BOOL boolval;
 188     char *name;
 189     DWORD modifiers;
 190     struct hlsl_ir_var *var;
 191     struct hlsl_ir_node *instr;
 192     struct list *list;
 193     struct hlsl_ir_function_decl *function;
 194     struct parse_parameter parameter;
 195     struct parse_variable_def *variable_def;
 196 }
 197
 198 %token KW_BLENDSTATE
 199 %token KW_BREAK
 200 %token KW_BUFFER
 201 %token KW_CBUFFER
 202 %token KW_COLUMN_MAJOR
 203 %token KW_COMPILE
 204 %token KW_CONST
 205 %token KW_CONTINUE
 206 %token KW_DEPTHSTENCILSTATE
 207 %token KW_DEPTHSTENCILVIEW
 208 %token KW_DISCARD
 209 %token KW_DO
 210 %token KW_DOUBLE
 211 %token KW_ELSE
 212 %token KW_EXTERN
 213 %token KW_FALSE
 214 %token KW_FOR
 215 %token KW_GEOMETRYSHADER
 216 %token KW_GROUPSHARED
 217 %token KW_IF
 218 %token KW_IN
 219 %token KW_INLINE
 220 %token KW_INOUT
 221 %token KW_MATRIX
 222 %token KW_NAMESPACE
 223 %token KW_NOINTERPOLATION
 224 %token KW_OUT
 225 %token KW_PASS
 226 %token KW_PIXELSHADER
 227 %token KW_PRECISE
 228 %token KW_RASTERIZERSTATE
 229 %token KW_RENDERTARGETVIEW
 230 %token KW_RETURN
 231 %token KW_REGISTER
 232 %token KW_ROW_MAJOR
 233 %token KW_SAMPLER
 234 %token KW_SAMPLER1D
 235 %token KW_SAMPLER2D
 236 %token KW_SAMPLER3D
 237 %token KW_SAMPLERCUBE
 238 %token KW_SAMPLER_STATE
 239 %token KW_SAMPLERCOMPARISONSTATE
 240 %token KW_SHARED
 241 %token KW_STATEBLOCK
 242 %token KW_STATEBLOCK_STATE
 243 %token KW_STATIC
 244 %token KW_STRING
 245 %token KW_STRUCT
 246 %token KW_SWITCH
 247 %token KW_TBUFFER
 248 %token KW_TECHNIQUE
 249 %token KW_TECHNIQUE10
 250 %token KW_TEXTURE
 251 %token KW_TEXTURE1D
 252 %token KW_TEXTURE1DARRAY
 253 %token KW_TEXTURE2D
 254 %token KW_TEXTURE2DARRAY
 255 %token KW_TEXTURE2DMS
 256 %token KW_TEXTURE2DMSARRAY
 257 %token KW_TEXTURE3D
 258 %token KW_TEXTURE3DARRAY
 259 %token KW_TEXTURECUBE
 260 %token KW_TRUE
 261 %token KW_TYPEDEF
 262 %token KW_UNIFORM
 263 %token KW_VECTOR
 264 %token KW_VERTEXSHADER
 265 %token KW_VOID
 266 %token KW_VOLATILE
 267 %token KW_WHILE
 268
 269 %token OP_INC
 270 %token OP_DEC
 271 %token OP_AND
 272 %token OP_OR
 273 %token OP_EQ
 274 %token OP_LEFTSHIFT
 275 %token OP_LEFTSHIFTASSIGN
 276 %token OP_RIGHTSHIFT
 277 %token OP_RIGHTSHIFTASSIGN
 278 %token OP_ELLIPSIS
 279 %token OP_LE
 280 %token OP_GE
 281 %token OP_NE
 282 %token OP_ADDASSIGN
 283 %token OP_SUBASSIGN
 284 %token OP_MULASSIGN
 285 %token OP_DIVASSIGN
 286 %token OP_MODASSIGN
 287 %token OP_ANDASSIGN
 288 %token OP_ORASSIGN
 289 %token OP_XORASSIGN
 290 %token OP_UNKNOWN1
 291 %token OP_UNKNOWN2
 292 %token OP_UNKNOWN3
 293 %token OP_UNKNOWN4
 294
 295 %token <intval> PRE_LINE
 296
 297 %token <name> VAR_IDENTIFIER TYPE_IDENTIFIER NEW_IDENTIFIER
 298 %type <name> any_identifier var_identifier
 299 %token <name> STRING
 300 %token <floatval> C_FLOAT
 301 %token <intval> C_INTEGER
 302 %type <boolval> boolean
 303 %type <type> base_type
 304 %type <type> type
 305 %type <list> declaration_statement
 306 %type <list> complex_initializer
 307 %type <list> initializer_expr_list
 308 %type <instr> initializer_expr
 309 %type <modifiers> var_modifiers
 310 %type <list> parameters
 311 %type <list> param_list
 312 %type <instr> expr
 313 %type <var> variable
 314 %type <intval> array
 315 %type <list> statement
 316 %type <list> statement_list
 317 %type <list> compound_statement
 318 %type <function> func_declaration
 319 %type <function> func_prototype
 320 %type <parameter> parameter
 321 %type <name> semantic
 322 %type <variable_def> variable_def
 323 %type <list> variables_def
 324 %type <instr> primary_expr
 325 %type <instr> postfix_expr
 326 %type <instr> unary_expr
 327 %type <instr> mul_expr
 328 %type <instr> add_expr
 329 %type <instr> shift_expr
 330 %type <instr> relational_expr
 331 %type <instr> equality_expr
 332 %type <instr> bitand_expr
 333 %type <instr> bitxor_expr
 334 %type <instr> bitor_expr
 335 %type <instr> logicand_expr
 336 %type <instr> logicor_expr
 337 %type <instr> conditional_expr
 338 %type <instr> assignment_expr
 339 %type <list> expr_statement
 340 %type <modifiers> input_mod
 341 %%
 342
 343 hlsl_prog:                /* empty */
 344                             {
 345                             }
 346                         | hlsl_prog func_declaration
 347                             {
 348                                 FIXME("Check that the function doesn't conflict with an already declared one.\n");
 349                                 list_add_tail(&hlsl_ctx.functions, &$2->node.entry);
 350                             }
 351                         | hlsl_prog declaration_statement
 352                             {
 353                                 TRACE("Declaration statement parsed.\n");
 354                             }
 355                         | hlsl_prog preproc_directive
 356                             {
 357                             }
 358
 359 preproc_directive:        PRE_LINE STRING
 360                             {
 361                                 TRACE("Updating line information to file %s, line %u\n", debugstr_a($2), $1);
 362                                 hlsl_ctx.line_no = $1;
 363                                 d3dcompiler_free(hlsl_ctx.source_file);
 364                                 hlsl_ctx.source_file = $2;
 365                             }
 366
 367 any_identifier:           VAR_IDENTIFIER
 368                         | TYPE_IDENTIFIER
 369                         | NEW_IDENTIFIER
 370
 371 func_declaration:         func_prototype compound_statement
 372                             {
 373                                 TRACE("Function %s parsed.\n", $1->name);
 374                                 $$ = $1;
 375                                 $$->body = $2;
 376                                 pop_scope(&hlsl_ctx);
 377                             }
 378                         | func_prototype ';'
 379                             {
 380                                 TRACE("Function prototype for %s.\n", $1->name);
 381                                 $$ = $1;
 382                                 pop_scope(&hlsl_ctx);
 383                             }
 384
 385 func_prototype:           var_modifiers type var_identifier '(' parameters ')' semantic
 386                             {
 387                                 $$ = new_func_decl($3, $2, $5);
 388                                 if (!$$)
 389                                 {
 390                                     ERR("Out of memory.\n");
 391                                     return -1;
 392                                 }
 393                                 $$->semantic = $7;
 394                             }
 395
 396 compound_statement:       '{' '}'
 397                             {
 398                                 $$ = d3dcompiler_alloc(sizeof(*$$));
 399                                 list_init($$);
 400                             }
 401                         | '{' scope_start statement_list '}'
 402                             {
 403                                 pop_scope(&hlsl_ctx);
 404                                 $$ = $3;
 405                             }
 406
 407 scope_start:              /* Empty */
 408                             {
 409                                 push_scope(&hlsl_ctx);
 410                             }
 411
 412 var_identifier:           VAR_IDENTIFIER
 413                         | NEW_IDENTIFIER
 414
 415 semantic:                 /* Empty */
 416                             {
 417                                 $$ = NULL;
 418                             }
 419                         | ':' any_identifier
 420                             {
 421                                 $$ = $2;
 422                             }
 423
 424 parameters:               scope_start
 425                             {
 426                                 $$ = d3dcompiler_alloc(sizeof(*$$));
 427                                 list_init($$);
 428                             }
 429                         | scope_start param_list
 430                             {
 431                                 $$ = $2;
 432                             }
 433
 434 param_list:               parameter
 435                             {
 436                                 $$ = d3dcompiler_alloc(sizeof(*$$));
 437                                 list_init($$);
 438                                 if (!add_func_parameter($$, &$1, hlsl_ctx.line_no))
 439                                 {
 440                                     ERR("Error adding function parameter %s.\n", $1.name);
 441                                     set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 442                                     return -1;
 443                                 }
 444                             }
 445                         | param_list ',' parameter
 446                             {
 447                                 $$ = $1;
 448                                 if (!add_func_parameter($$, &$3, hlsl_ctx.line_no))
 449                                 {
 450                                     hlsl_message("Line %u: duplicate parameter %s.\n",
 451                                             hlsl_ctx.line_no, $3.name);
 452                                     set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 453                                     return 1;
 454                                 }
 455                             }
 456
 457 parameter:                input_mod var_modifiers type any_identifier semantic
 458                             {
 459                                 $$.modifiers = $1;
 460                                 $$.modifiers |= $2;
 461                                 $$.type = $3;
 462                                 $$.name = $4;
 463                                 $$.semantic = $5;
 464                             }
 465
 466 input_mod:                /* Empty */
 467                             {
 468                                 $$ = HLSL_MODIFIER_IN;
 469                             }
 470                         | KW_IN
 471                             {
 472                                 $$ = HLSL_MODIFIER_IN;
 473                             }
 474                         | KW_OUT
 475                             {
 476                                 $$ = HLSL_MODIFIER_OUT;
 477                             }
 478                         | KW_INOUT
 479                             {
 480                                 $$ = HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT;
 481                             }
 482
 483 type:                     base_type
 484                             {
 485                                 $$ = $1;
 486                             }
 487                         | KW_VECTOR '<' base_type ',' C_INTEGER '>'
 488                             {
 489                                 if ($3->type != HLSL_CLASS_SCALAR)
 490                                 {
 491                                     hlsl_message("Line %u: vectors of non-scalar types are not allowed.\n",
 492                                             hlsl_ctx.line_no);
 493                                     set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 494                                     return 1;
 495                                 }
 496                                 if ($5 < 1 || $5 > 4)
 497                                 {
 498                                     hlsl_message("Line %u: vector size must be between 1 and 4.\n",
 499                                             hlsl_ctx.line_no);
 500                                     set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 501                                     return 1;
 502                                 }
 503
 504                                 $$ = new_hlsl_type(NULL, HLSL_CLASS_VECTOR, $3->base_type, $5, 1);
 505                             }
 506                         | KW_MATRIX '<' base_type ',' C_INTEGER ',' C_INTEGER '>'
 507                             {
 508                                 if ($3->type != HLSL_CLASS_SCALAR)
 509                                 {
 510                                     hlsl_message("Line %u: matrices of non-scalar types are not allowed.\n",
 511                                             hlsl_ctx.line_no);
 512                                     set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 513                                     return 1;
 514                                 }
 515                                 if ($5 < 1 || $5 > 4 || $7 < 1 || $7 > 4)
 516                                 {
 517                                     hlsl_message("Line %u: matrix dimensions must be between 1 and 4.\n",
 518                                             hlsl_ctx.line_no);
 519                                     set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 520                                     return 1;
 521                                 }
 522
 523                                 $$ = new_hlsl_type(NULL, HLSL_CLASS_MATRIX, $3->base_type, $5, $7);
 524                             }
 525
 526 base_type:                KW_VOID
 527                             {
 528                                 $$ = new_hlsl_type(d3dcompiler_strdup("void"), HLSL_CLASS_SCALAR, HLSL_TYPE_VOID, 1, 1);
 529                             }
 530                         | KW_SAMPLER
 531                             {
 532                                 $$ = new_hlsl_type(d3dcompiler_strdup("sampler"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
 533                                 $$->sampler_dim = HLSL_SAMPLER_DIM_GENERIC;
 534                             }
 535                         | KW_SAMPLER1D
 536                             {
 537                                 $$ = new_hlsl_type(d3dcompiler_strdup("sampler1D"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
 538                                 $$->sampler_dim = HLSL_SAMPLER_DIM_1D;
 539                             }
 540                         | KW_SAMPLER2D
 541                             {
 542                                 $$ = new_hlsl_type(d3dcompiler_strdup("sampler2D"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
 543                                 $$->sampler_dim = HLSL_SAMPLER_DIM_2D;
 544                             }
 545                         | KW_SAMPLER3D
 546                             {
 547                                 $$ = new_hlsl_type(d3dcompiler_strdup("sampler3D"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
 548                                 $$->sampler_dim = HLSL_SAMPLER_DIM_3D;
 549                             }
 550                         | KW_SAMPLERCUBE
 551                             {
 552                                 $$ = new_hlsl_type(d3dcompiler_strdup("samplerCUBE"), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
 553                                 $$->sampler_dim = HLSL_SAMPLER_DIM_CUBE;
 554                             }
 555                         | TYPE_IDENTIFIER
 556                             {
 557                                 struct hlsl_type *type;
 558
 559                                 TRACE("Type %s.\n", $1);
 560                                 type = get_type(hlsl_ctx.cur_scope, $1, TRUE);
 561                                 $$ = type;
 562                                 d3dcompiler_free($1);
 563                             }
 564                         | KW_STRUCT TYPE_IDENTIFIER
 565                             {
 566                                 struct hlsl_type *type;
 567
 568                                 TRACE("Struct type %s.\n", $2);
 569                                 type = get_type(hlsl_ctx.cur_scope, $2, TRUE);
 570                                 if (type->type != HLSL_CLASS_STRUCT)
 571                                 {
 572                                     hlsl_message("Line %u: redefining %s as a structure.\n",
 573                                             hlsl_ctx.line_no, $2);
 574                                     set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 575                                 }
 576                                 else
 577                                 {
 578                                     $$ = type;
 579                                 }
 580                                 d3dcompiler_free($2);
 581                             }
 582
 583 declaration_statement:    declaration
 584                             {
 585                                 $$ = d3dcompiler_alloc(sizeof(*$$));
 586                                 list_init($$);
 587                             }
 588
 589 declaration:              var_modifiers type variables_def ';'
 590                             {
 591                                 struct parse_variable_def *v, *v_next;
 592                                 struct hlsl_ir_var *var;
 593                                 BOOL ret, local = TRUE;
 594
 595                                 LIST_FOR_EACH_ENTRY_SAFE(v, v_next, $3, struct parse_variable_def, entry)
 596                                 {
 597                                     debug_dump_decl($2, $1, v->name, hlsl_ctx.line_no);
 598                                     var = d3dcompiler_alloc(sizeof(*var));
 599                                     var->node.type = HLSL_IR_VAR;
 600                                     if (v->array_size)
 601                                         var->node.data_type = new_array_type($2, v->array_size);
 602                                     else
 603                                         var->node.data_type = $2;
 604                                     var->name = v->name;
 605                                     var->modifiers = $1;
 606                                     var->semantic = v->semantic;
 607                                     var->node.line = hlsl_ctx.line_no;
 608                                     if (v->initializer)
 609                                     {
 610                                         FIXME("Variable with an initializer.\n");
 611                                         free_instr_list(v->initializer);
 612                                     }
 613
 614                                     if (hlsl_ctx.cur_scope == hlsl_ctx.globals)
 615                                     {
 616                                         var->modifiers |= HLSL_STORAGE_UNIFORM;
 617                                         local = FALSE;
 618                                     }
 619
 620                                     ret = declare_variable(var, local);
 621                                     if (ret == FALSE)
 622                                         free_declaration(var);
 623                                     else
 624                                         TRACE("Declared variable %s.\n", var->name);
 625                                     d3dcompiler_free(v);
 626                                 }
 627                                 d3dcompiler_free($3);
 628                             }
 629
 630 variables_def:            variable_def
 631                             {
 632                                 $$ = d3dcompiler_alloc(sizeof(*$$));
 633                                 list_init($$);
 634                                 list_add_head($$, &$1->entry);
 635                             }
 636                         | variables_def ',' variable_def
 637                             {
 638                                 $$ = $1;
 639                                 list_add_tail($$, &$3->entry);
 640                             }
 641
 642                           /* FIXME: Local variables can't have semantics. */
 643 variable_def:             any_identifier array semantic
 644                             {
 645                                 $$ = d3dcompiler_alloc(sizeof(*$$));
 646                                 $$->name = $1;
 647                                 $$->array_size = $2;
 648                                 $$->semantic = $3;
 649                             }
 650                         | any_identifier array semantic '=' complex_initializer
 651                             {
 652                                 TRACE("Declaration with initializer.\n");
 653                                 $$ = d3dcompiler_alloc(sizeof(*$$));
 654                                 $$->name = $1;
 655                                 $$->array_size = $2;
 656                                 $$->semantic = $3;
 657                                 $$->initializer = $5;
 658                             }
 659
 660 array:                    /* Empty */
 661                             {
 662                                 $$ = 0;
 663                             }
 664                         | '[' expr ']'
 665                             {
 666                                 FIXME("Array.\n");
 667                                 $$ = 0;
 668                                 free_instr($2);
 669                             }
 670
 671 var_modifiers:            /* Empty */
 672                             {
 673                                 $$ = 0;
 674                             }
 675                         | KW_EXTERN var_modifiers
 676                             {
 677                                 $$ = add_modifier($2, HLSL_STORAGE_EXTERN);
 678                             }
 679                         | KW_NOINTERPOLATION var_modifiers
 680                             {
 681                                 $$ = add_modifier($2, HLSL_STORAGE_NOINTERPOLATION);
 682                             }
 683                         | KW_PRECISE var_modifiers
 684                             {
 685                                 $$ = add_modifier($2, HLSL_MODIFIER_PRECISE);
 686                             }
 687                         | KW_SHARED var_modifiers
 688                             {
 689                                 $$ = add_modifier($2, HLSL_STORAGE_SHARED);
 690                             }
 691                         | KW_GROUPSHARED var_modifiers
 692                             {
 693                                 $$ = add_modifier($2, HLSL_STORAGE_GROUPSHARED);
 694                             }
 695                         | KW_STATIC var_modifiers
 696                             {
 697                                 $$ = add_modifier($2, HLSL_STORAGE_STATIC);
 698                             }
 699                         | KW_UNIFORM var_modifiers
 700                             {
 701                                 $$ = add_modifier($2, HLSL_STORAGE_UNIFORM);
 702                             }
 703                         | KW_VOLATILE var_modifiers
 704                             {
 705                                 $$ = add_modifier($2, HLSL_STORAGE_VOLATILE);
 706                             }
 707                         | KW_CONST var_modifiers
 708                             {
 709                                 $$ = add_modifier($2, HLSL_MODIFIER_CONST);
 710                             }
 711                         | KW_ROW_MAJOR var_modifiers
 712                             {
 713                                 $$ = add_modifier($2, HLSL_MODIFIER_ROW_MAJOR);
 714                             }
 715                         | KW_COLUMN_MAJOR var_modifiers
 716                             {
 717                                 $$ = add_modifier($2, HLSL_MODIFIER_COLUMN_MAJOR);
 718                             }
 719
 720 complex_initializer:      initializer_expr
 721                             {
 722                                 $$ = d3dcompiler_alloc(sizeof(*$$));
 723                                 list_init($$);
 724                                 list_add_head($$, &$1->entry);
 725                             }
 726                         | '{' initializer_expr_list '}'
 727                             {
 728                                 $$ = $2;
 729                             }
 730
 731 initializer_expr:         assignment_expr
 732                             {
 733                                 $$ = $1;
 734                             }
 735
 736 initializer_expr_list:    initializer_expr
 737                             {
 738                                 $$ = d3dcompiler_alloc(sizeof(*$$));
 739                                 list_init($$);
 740                                 list_add_head($$, &$1->entry);
 741                             }
 742                         | initializer_expr_list ',' initializer_expr
 743                             {
 744                                 $$ = $1;
 745                                 list_add_tail($$, &$3->entry);
 746                             }
 747
 748 boolean:                  KW_TRUE
 749                             {
 750                                 $$ = TRUE;
 751                             }
 752                         | KW_FALSE
 753                             {
 754                                 $$ = FALSE;
 755                             }
 756
 757 statement_list:           statement
 758                             {
 759                                 $$ = $1;
 760                             }
 761                         | statement_list statement
 762                             {
 763                                 $$ = $1;
 764                                 list_move_tail($$, $2);
 765                                 d3dcompiler_free($2);
 766                             }
 767
 768 statement:                declaration_statement
 769                             {
 770                                 $$ = $1;
 771                             }
 772                         | expr_statement
 773                             {
 774                                 $$ = $1;
 775                             }
 776                         | compound_statement
 777                             {
 778                                 $$ = $1;
 779                             }
 780
 781 expr_statement:           ';'
 782                             {
 783                                 $$ = d3dcompiler_alloc(sizeof(*$$));
 784                                 list_init($$);
 785                             }
 786                         | expr ';'
 787                             {
 788                                 $$ = d3dcompiler_alloc(sizeof(*$$));
 789                                 list_init($$);
 790                                 if ($1)
 791                                     list_add_head($$, &$1->entry);
 792                             }
 793
 794 primary_expr:             C_FLOAT
 795                             {
 796                                 struct hlsl_ir_constant *c = d3dcompiler_alloc(sizeof(*c));
 797                                 if (!c)
 798                                 {
 799                                     ERR("Out of memory.\n");
 800                                     return -1;
 801                                 }
 802                                 c->node.type = HLSL_IR_CONSTANT;
 803                                 c->node.data_type = new_hlsl_type("float", HLSL_CLASS_SCALAR, HLSL_TYPE_FLOAT, 1, 1);
 804                                 c->v.value.f[0] = $1;
 805                                 $$ = &c->node;
 806                             }
 807                         | C_INTEGER
 808                             {
 809                                 struct hlsl_ir_constant *c = d3dcompiler_alloc(sizeof(*c));
 810                                 if (!c)
 811                                 {
 812                                     ERR("Out of memory.\n");
 813                                     return -1;
 814                                 }
 815                                 c->node.type = HLSL_IR_CONSTANT;
 816                                 c->node.data_type = new_hlsl_type("int", HLSL_CLASS_SCALAR, HLSL_TYPE_INT, 1, 1);
 817                                 c->v.value.i[0] = $1;
 818                                 $$ = &c->node;
 819                             }
 820                         | boolean
 821                             {
 822                                 struct hlsl_ir_constant *c = d3dcompiler_alloc(sizeof(*c));
 823                                 if (!c)
 824                                 {
 825                                     ERR("Out of memory.\n");
 826                                     return -1;
 827                                 }
 828                                 c->node.type = HLSL_IR_CONSTANT;
 829                                 c->node.data_type = new_hlsl_type("bool", HLSL_CLASS_SCALAR, HLSL_TYPE_BOOL, 1, 1);
 830                                 c->v.value.b[0] = $1;
 831                                 $$ = &c->node;
 832                             }
 833                         | variable
 834                             {
 835                                 struct hlsl_ir_deref *deref = new_var_deref($1);
 836                                 $$ = deref ? &deref->node : NULL;
 837                             }
 838                         | '(' expr ')'
 839                             {
 840                                 $$ = $2;
 841                             }
 842
 843 variable:                 VAR_IDENTIFIER
 844                             {
 845                                 struct hlsl_ir_var *var;
 846                                 var = get_variable(hlsl_ctx.cur_scope, $1);
 847                                 if (!var)
 848                                 {
 849                                     hlsl_message("Line %d: variable '%s' not declared\n",
 850                                             hlsl_ctx.line_no, $1);
 851                                     set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 852                                     return 1;
 853                                 }
 854                                 $$ = var;
 855                             }
 856
 857 postfix_expr:             primary_expr
 858                             {
 859                                 $$ = $1;
 860                             }
 861                           /* "var_modifiers" doesn't make sense in this case, but it's needed
 862                              in the grammar to avoid shift/reduce conflicts. */
 863                         | var_modifiers type '(' initializer_expr_list ')'
 864                             {
 865                                 struct hlsl_ir_constructor *constructor;
 866
 867                                 TRACE("%s constructor.\n", debug_hlsl_type($2));
 868                                 if ($1)
 869                                 {
 870                                     hlsl_message("Line %u: unexpected modifier in a constructor.\n",
 871                                             hlsl_ctx.line_no);
 872                                     set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 873                                     return -1;
 874                                 }
 875                                 if ($2->type > HLSL_CLASS_LAST_NUMERIC)
 876                                 {
 877                                     hlsl_message("Line %u: constructors are allowed only for numeric data types.\n",
 878                                             hlsl_ctx.line_no);
 879                                     set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 880                                     return -1;
 881                                 }
 882                                 if ($2->dimx * $2->dimy != components_count_expr_list($4))
 883                                 {
 884                                     hlsl_message("Line %u: wrong number of components in constructor.\n",
 885                                             hlsl_ctx.line_no);
 886                                     set_parse_status(&hlsl_ctx.status, PARSE_ERR);
 887                                     return -1;
 888                                 }
 889
 890                                 constructor = d3dcompiler_alloc(sizeof(*constructor));
 891                                 constructor->node.type = HLSL_IR_CONSTRUCTOR;
 892                                 constructor->node.data_type = $2;
 893                                 constructor->arguments = $4;
 894
 895                                 $$ = &constructor->node;
 896                             }
 897
 898 unary_expr:               postfix_expr
 899                             {
 900                                 $$ = $1;
 901                             }
 902
 903 mul_expr:                 unary_expr
 904                             {
 905                                 $$ = $1;
 906                             }
 907
 908 add_expr:                 mul_expr
 909                             {
 910                                 $$ = $1;
 911                             }
 912
 913 shift_expr:               add_expr
 914                             {
 915                                 $$ = $1;
 916                             }
 917
 918 relational_expr:          shift_expr
 919                             {
 920                                 $$ = $1;
 921                             }
 922
 923 equality_expr:            relational_expr
 924                             {
 925                                 $$ = $1;
 926                             }
 927
 928 bitand_expr:              equality_expr
 929                             {
 930                                 $$ = $1;
 931                             }
 932
 933 bitxor_expr:              bitand_expr
 934                             {
 935                                 $$ = $1;
 936                             }
 937
 938 bitor_expr:               bitxor_expr
 939                             {
 940                                 $$ = $1;
 941                             }
 942
 943 logicand_expr:            bitor_expr
 944                             {
 945                                 $$ = $1;
 946                             }
 947
 948 logicor_expr:             logicand_expr
 949                             {
 950                                 $$ = $1;
 951                             }
 952
 953 conditional_expr:         logicor_expr
 954                             {
 955                                 $$ = $1;
 956                             }
 957
 958 assignment_expr:          conditional_expr
 959                             {
 960                                 $$ = $1;
 961                             }
 962
 963 expr:                     assignment_expr
 964                             {
 965                                 $$ = $1;
 966                             }
 967                         | expr ',' assignment_expr
 968                             {
 969                                 FIXME("Comma expression\n");
 970                             }
 971
 972 %%
 973
 974 struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD major, DWORD minor,
 975         const char *entrypoint, char **messages)
 976 {
 977     struct hlsl_ir_function_decl *function;
 978     struct hlsl_scope *scope, *next_scope;
 979     struct hlsl_type *hlsl_type, *next_type;
 980     struct hlsl_ir_var *var, *next_var;
 981
 982     hlsl_ctx.status = PARSE_SUCCESS;
 983     hlsl_ctx.messages.size = hlsl_ctx.messages.capacity = 0;
 984     hlsl_ctx.line_no = 1;
 985     hlsl_ctx.source_file = d3dcompiler_strdup("");
 986     hlsl_ctx.cur_scope = NULL;
 987     hlsl_ctx.matrix_majority = HLSL_COLUMN_MAJOR;
 988     list_init(&hlsl_ctx.scopes);
 989     list_init(&hlsl_ctx.types);
 990     list_init(&hlsl_ctx.functions);
 991
 992     push_scope(&hlsl_ctx);
 993     hlsl_ctx.globals = hlsl_ctx.cur_scope;
 994
 995     hlsl_parse();
 996
 997     if (TRACE_ON(hlsl_parser))
 998     {
 999         struct hlsl_ir_function_decl *func;
1000
1001         TRACE("IR dump.\n");
1002         LIST_FOR_EACH_ENTRY(func, &hlsl_ctx.functions, struct hlsl_ir_function_decl, node.entry)
1003         {
1004             if (func->body)
1005                 debug_dump_ir_function(func);
1006         }
1007     }
1008
1009     TRACE("Compilation status = %d\n", hlsl_ctx.status);
1010     if (messages)
1011     {
1012         if (hlsl_ctx.messages.size)
1013             *messages = hlsl_ctx.messages.string;
1014         else
1015             *messages = NULL;
1016     }
1017     else
1018     {
1019         if (hlsl_ctx.messages.capacity)
1020             d3dcompiler_free(hlsl_ctx.messages.string);
1021     }
1022
1023     d3dcompiler_free(hlsl_ctx.source_file);
1024     TRACE("Freeing functions IR.\n");
1025     LIST_FOR_EACH_ENTRY(function, &hlsl_ctx.functions, struct hlsl_ir_function_decl, node.entry)
1026         free_function(function);
1027
1028     TRACE("Freeing variables.\n");
1029     LIST_FOR_EACH_ENTRY_SAFE(scope, next_scope, &hlsl_ctx.scopes, struct hlsl_scope, entry)
1030     {
1031         LIST_FOR_EACH_ENTRY_SAFE(var, next_var, &scope->vars, struct hlsl_ir_var, scope_entry)
1032         {
1033             free_declaration(var);
1034         }
1035         d3dcompiler_free(scope);
1036     }
1037
1038     TRACE("Freeing types.\n");
1039     LIST_FOR_EACH_ENTRY_SAFE(hlsl_type, next_type, &hlsl_ctx.types, struct hlsl_type, entry)
1040     {
1041         free_hlsl_type(hlsl_type);
1042     }
1043
1044     return NULL;
1045 }