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 "wine/debug.h"
  23
  24 #include <limits.h>
  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 struct source_location get_location(const struct YYLTYPE *l);
  37
  38 void WINAPIV hlsl_message(const char *fmt, ...)
  39 {
  40     __ms_va_list args;
  41
  42     __ms_va_start(args, fmt);
  43     compilation_message(&hlsl_ctx.messages, fmt, args);
  44     __ms_va_end(args);
  45 }
  46
  47 static const char *hlsl_get_error_level_name(enum hlsl_error_level level)
  48 {
  49     static const char * const names[] =
  50     {
  51         "error",
  52         "warning",
  53         "note",
  54     };
  55     return names[level];
  56 }
  57
  58 void WINAPIV hlsl_report_message(const struct source_location loc,
  59         enum hlsl_error_level level, const char *fmt, ...)
  60 {
  61     __ms_va_list args;
  62     char *string = NULL;
  63     int rc, size = 0;
  64
  65     while (1)
  66     {
  67         __ms_va_start(args, fmt);
  68         rc = vsnprintf(string, size, fmt, args);
  69         __ms_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", loc.file, loc.line, loc.col,
  91             hlsl_get_error_level_name(level), string);
  92     d3dcompiler_free(string);
  93
  94     if (level == HLSL_LEVEL_ERROR)
  95         set_parse_status(&hlsl_ctx.status, PARSE_ERR);
  96     else if (level == HLSL_LEVEL_WARNING)
  97         set_parse_status(&hlsl_ctx.status, PARSE_WARN);
  98 }
  99
 100 static void hlsl_error(const char *s)
 101 {
 102     const struct source_location loc =
 103     {
 104         .file = hlsl_ctx.source_file,
 105         .line = hlsl_ctx.line_no,
 106         .col = hlsl_ctx.column,
 107     };
 108     hlsl_report_message(loc, HLSL_LEVEL_ERROR, "%s", s);
 109 }
 110
 111 static void debug_dump_decl(struct hlsl_type *type, DWORD modifiers, const char *declname, unsigned int line_no)
 112 {
 113     TRACE("Line %u: ", line_no);
 114     if (modifiers)
 115         TRACE("%s ", debug_modifiers(modifiers));
 116     TRACE("%s %s;\n", debug_hlsl_type(type), declname);
 117 }
 118
 119 static void check_invalid_matrix_modifiers(DWORD modifiers, struct source_location loc)
 120 {
 121     if (modifiers & HLSL_MODIFIERS_MAJORITY_MASK)
 122     {
 123         hlsl_report_message(loc, HLSL_LEVEL_ERROR,
 124                 "'row_major' or 'column_major' modifiers are only allowed for matrices");
 125     }
 126 }
 127
 128 static BOOL type_is_single_reg(const struct hlsl_type *type)
 129 {
 130     return type->type == HLSL_CLASS_SCALAR || type->type == HLSL_CLASS_VECTOR;
 131 }
 132
 133 static BOOL declare_variable(struct hlsl_ir_var *decl, BOOL local)
 134 {
 135     BOOL ret;
 136
 137     TRACE("Declaring variable %s.\n", decl->name);
 138     if (decl->data_type->type != HLSL_CLASS_MATRIX)
 139         check_invalid_matrix_modifiers(decl->modifiers, decl->loc);
 140
 141     if (local)
 142     {
 143         DWORD invalid = decl->modifiers & (HLSL_STORAGE_EXTERN | HLSL_STORAGE_SHARED
 144                 | HLSL_STORAGE_GROUPSHARED | HLSL_STORAGE_UNIFORM);
 145         if (invalid)
 146         {
 147             hlsl_report_message(decl->loc, HLSL_LEVEL_ERROR,
 148                     "modifier '%s' invalid for local variables", debug_modifiers(invalid));
 149         }
 150         if (decl->semantic)
 151         {
 152             hlsl_report_message(decl->loc, HLSL_LEVEL_ERROR,
 153                     "semantics are not allowed on local variables");
 154             return FALSE;
 155         }
 156     }
 157     else
 158     {
 159         if (find_function(decl->name))
 160         {
 161             hlsl_report_message(decl->loc, HLSL_LEVEL_ERROR, "redefinition of '%s'", decl->name);
 162             return FALSE;
 163         }
 164     }
 165     ret = add_declaration(hlsl_ctx.cur_scope, decl, local);
 166     if (!ret)
 167     {
 168         struct hlsl_ir_var *old = get_variable(hlsl_ctx.cur_scope, decl->name);
 169
 170         hlsl_report_message(decl->loc, HLSL_LEVEL_ERROR, "\"%s\" already declared", decl->name);
 171         hlsl_report_message(old->loc, HLSL_LEVEL_NOTE, "\"%s\" was previously declared here", old->name);
 172         return FALSE;
 173     }
 174     return TRUE;
 175 }
 176
 177 static DWORD add_modifiers(DWORD modifiers, DWORD mod, const struct source_location loc)
 178 {
 179     if (modifiers & mod)
 180     {
 181         hlsl_report_message(loc, HLSL_LEVEL_ERROR, "modifier '%s' already specified", debug_modifiers(mod));
 182         return modifiers;
 183     }
 184     if ((mod & HLSL_MODIFIERS_MAJORITY_MASK) && (modifiers & HLSL_MODIFIERS_MAJORITY_MASK))
 185     {
 186         hlsl_report_message(loc, HLSL_LEVEL_ERROR, "more than one matrix majority keyword");
 187         return modifiers;
 188     }
 189     return modifiers | mod;
 190 }
 191
 192 static BOOL add_type_to_scope(struct hlsl_scope *scope, struct hlsl_type *def)
 193 {
 194     if (get_type(scope, def->name, FALSE))
 195         return FALSE;
 196
 197     wine_rb_put(&scope->types, def->name, &def->scope_entry);
 198     return TRUE;
 199 }
 200
 201 static void declare_predefined_types(struct hlsl_scope *scope)
 202 {
 203     struct hlsl_type *type;
 204     unsigned int x, y, bt;
 205     static const char * const names[] =
 206     {
 207         "float",
 208         "half",
 209         "double",
 210         "int",
 211         "uint",
 212         "bool",
 213     };
 214     char name[10];
 215
 216     static const char *const sampler_names[] =
 217     {
 218         "sampler",
 219         "sampler1D",
 220         "sampler2D",
 221         "sampler3D",
 222         "samplerCUBE"
 223     };
 224
 225     for (bt = 0; bt <= HLSL_TYPE_LAST_SCALAR; ++bt)
 226     {
 227         for (y = 1; y <= 4; ++y)
 228         {
 229             for (x = 1; x <= 4; ++x)
 230             {
 231                 sprintf(name, "%s%ux%u", names[bt], y, x);
 232                 type = new_hlsl_type(d3dcompiler_strdup(name), HLSL_CLASS_MATRIX, bt, x, y);
 233                 add_type_to_scope(scope, type);
 234
 235                 if (y == 1)
 236                 {
 237                     sprintf(name, "%s%u", names[bt], x);
 238                     type = new_hlsl_type(d3dcompiler_strdup(name), HLSL_CLASS_VECTOR, bt, x, y);
 239                     add_type_to_scope(scope, type);
 240                     hlsl_ctx.builtin_types.vector[bt][x - 1] = type;
 241
 242                     if (x == 1)
 243                     {
 244                         sprintf(name, "%s", names[bt]);
 245                         type = new_hlsl_type(d3dcompiler_strdup(name), HLSL_CLASS_SCALAR, bt, x, y);
 246                         add_type_to_scope(scope, type);
 247                         hlsl_ctx.builtin_types.scalar[bt] = type;
 248                     }
 249                 }
 250             }
 251         }
 252     }
 253
 254     for (bt = 0; bt <= HLSL_SAMPLER_DIM_MAX; ++bt)
 255     {
 256         type = new_hlsl_type(d3dcompiler_strdup(sampler_names[bt]), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);
 257         type->sampler_dim = bt;
 258         hlsl_ctx.builtin_types.sampler[bt] = type;
 259     }
 260
 261     hlsl_ctx.builtin_types.Void = new_hlsl_type(d3dcompiler_strdup("void"), HLSL_CLASS_OBJECT, HLSL_TYPE_VOID, 1, 1);
 262
 263     /* DX8 effects predefined types */
 264     type = new_hlsl_type(d3dcompiler_strdup("DWORD"), HLSL_CLASS_SCALAR, HLSL_TYPE_INT, 1, 1);
 265     add_type_to_scope(scope, type);
 266     type = new_hlsl_type(d3dcompiler_strdup("FLOAT"), HLSL_CLASS_SCALAR, HLSL_TYPE_FLOAT, 1, 1);
 267     add_type_to_scope(scope, type);
 268     type = new_hlsl_type(d3dcompiler_strdup("VECTOR"), HLSL_CLASS_VECTOR, HLSL_TYPE_FLOAT, 4, 1);
 269     add_type_to_scope(scope, type);
 270     type = new_hlsl_type(d3dcompiler_strdup("MATRIX"), HLSL_CLASS_MATRIX, HLSL_TYPE_FLOAT, 4, 4);
 271     add_type_to_scope(scope, type);
 272     type = new_hlsl_type(d3dcompiler_strdup("STRING"), HLSL_CLASS_OBJECT, HLSL_TYPE_STRING, 1, 1);
 273     add_type_to_scope(scope, type);
 274     type = new_hlsl_type(d3dcompiler_strdup("TEXTURE"), HLSL_CLASS_OBJECT, HLSL_TYPE_TEXTURE, 1, 1);
 275     add_type_to_scope(scope, type);
 276     type = new_hlsl_type(d3dcompiler_strdup("PIXELSHADER"), HLSL_CLASS_OBJECT, HLSL_TYPE_PIXELSHADER, 1, 1);
 277     add_type_to_scope(scope, type);
 278     type = new_hlsl_type(d3dcompiler_strdup("VERTEXSHADER"), HLSL_CLASS_OBJECT, HLSL_TYPE_VERTEXSHADER, 1, 1);
 279     add_type_to_scope(scope, type);
 280 }
 281
 282 static BOOL type_is_void(const struct hlsl_type *type)
 283 {
 284     return type->type == HLSL_CLASS_OBJECT && type->base_type == HLSL_TYPE_VOID;
 285 }
 286
 287 static BOOL append_conditional_break(struct list *cond_list)
 288 {
 289     struct hlsl_ir_node *condition, *not;
 290     struct hlsl_ir_jump *jump;
 291     struct hlsl_ir_if *iff;
 292
 293     /* E.g. "for (i = 0; ; ++i)". */
 294     if (!list_count(cond_list))
 295         return TRUE;
 296
 297     condition = node_from_list(cond_list);
 298     if (!(not = new_unary_expr(HLSL_IR_UNOP_LOGIC_NOT, condition, condition->loc)))
 299     {
 300         ERR("Out of memory.\n");
 301         return FALSE;
 302     }
 303     list_add_tail(cond_list, &not->entry);
 304
 305     if (!(iff = d3dcompiler_alloc(sizeof(*iff))))
 306     {
 307         ERR("Out of memory.\n");
 308         return FALSE;
 309     }
 310     init_node(&iff->node, HLSL_IR_IF, NULL, condition->loc);
 311     iff->condition = not;
 312     list_add_tail(cond_list, &iff->node.entry);
 313
 314     if (!(iff->then_instrs = d3dcompiler_alloc(sizeof(*iff->then_instrs))))
 315     {
 316         ERR("Out of memory.\n");
 317         return FALSE;
 318     }
 319     list_init(iff->then_instrs);
 320
 321     if (!(jump = d3dcompiler_alloc(sizeof(*jump))))
 322     {
 323         ERR("Out of memory.\n");
 324         return FALSE;
 325     }
 326     init_node(&jump->node, HLSL_IR_JUMP, NULL, condition->loc);
 327     jump->type = HLSL_IR_JUMP_BREAK;
 328     list_add_head(iff->then_instrs, &jump->node.entry);
 329     return TRUE;
 330 }
 331
 332 enum loop_type
 333 {
 334     LOOP_FOR,
 335     LOOP_WHILE,
 336     LOOP_DO_WHILE
 337 };
 338
 339 static struct list *create_loop(enum loop_type type, struct list *init, struct list *cond,
 340         struct list *iter, struct list *body, struct source_location loc)
 341 {
 342     struct list *list = NULL;
 343     struct hlsl_ir_loop *loop = NULL;
 344     struct hlsl_ir_if *cond_jump = NULL;
 345
 346     list = d3dcompiler_alloc(sizeof(*list));
 347     if (!list)
 348         goto oom;
 349     list_init(list);
 350
 351     if (init)
 352         list_move_head(list, init);
 353
 354     loop = d3dcompiler_alloc(sizeof(*loop));
 355     if (!loop)
 356         goto oom;
 357     init_node(&loop->node, HLSL_IR_LOOP, NULL, loc);
 358     list_add_tail(list, &loop->node.entry);
 359     loop->body = d3dcompiler_alloc(sizeof(*loop->body));
 360     if (!loop->body)
 361         goto oom;
 362     list_init(loop->body);
 363
 364     if (!append_conditional_break(cond))
 365         goto oom;
 366
 367     if (type != LOOP_DO_WHILE)
 368         list_move_tail(loop->body, cond);
 369
 370     list_move_tail(loop->body, body);
 371
 372     if (iter)
 373         list_move_tail(loop->body, iter);
 374
 375     if (type == LOOP_DO_WHILE)
 376         list_move_tail(loop->body, cond);
 377
 378     d3dcompiler_free(init);
 379     d3dcompiler_free(cond);
 380     d3dcompiler_free(body);
 381     return list;
 382
 383 oom:
 384     ERR("Out of memory.\n");
 385     if (loop)
 386         d3dcompiler_free(loop->body);
 387     d3dcompiler_free(loop);
 388     d3dcompiler_free(cond_jump);
 389     d3dcompiler_free(list);
 390     free_instr_list(init);
 391     free_instr_list(cond);
 392     free_instr_list(iter);
 393     free_instr_list(body);
 394     return NULL;
 395 }
 396
 397 static unsigned int initializer_size(const struct parse_initializer *initializer)
 398 {
 399     unsigned int count = 0, i;
 400
 401     for (i = 0; i < initializer->args_count; ++i)
 402     {
 403         count += components_count_type(initializer->args[i]->data_type);
 404     }
 405     TRACE("Initializer size = %u.\n", count);
 406     return count;
 407 }
 408
 409 static void free_parse_initializer(struct parse_initializer *initializer)
 410 {
 411     free_instr_list(initializer->instrs);
 412     d3dcompiler_free(initializer->args);
 413 }
 414
 415 static struct hlsl_ir_swizzle *new_swizzle(DWORD s, unsigned int components,
 416         struct hlsl_ir_node *val, struct source_location *loc)
 417 {
 418     struct hlsl_ir_swizzle *swizzle = d3dcompiler_alloc(sizeof(*swizzle));
 419
 420     if (!swizzle)
 421         return NULL;
 422     init_node(&swizzle->node, HLSL_IR_SWIZZLE,
 423             new_hlsl_type(NULL, HLSL_CLASS_VECTOR, val->data_type->base_type, components, 1), *loc);
 424     swizzle->val = val;
 425     swizzle->swizzle = s;
 426     return swizzle;
 427 }
 428
 429 static struct hlsl_ir_swizzle *get_swizzle(struct hlsl_ir_node *value, const char *swizzle,
 430         struct source_location *loc)
 431 {
 432     unsigned int len = strlen(swizzle), component = 0;
 433     unsigned int i, set, swiz = 0;
 434     BOOL valid;
 435
 436     if (value->data_type->type == HLSL_CLASS_MATRIX)
 437     {
 438         /* Matrix swizzle */
 439         BOOL m_swizzle;
 440         unsigned int inc, x, y;
 441
 442         if (len < 3 || swizzle[0] != '_')
 443             return NULL;
 444         m_swizzle = swizzle[1] == 'm';
 445         inc = m_swizzle ? 4 : 3;
 446
 447         if (len % inc || len > inc * 4)
 448             return NULL;
 449
 450         for (i = 0; i < len; i += inc)
 451         {
 452             if (swizzle[i] != '_')
 453                 return NULL;
 454             if (m_swizzle)
 455             {
 456                 if (swizzle[i + 1] != 'm')
 457                     return NULL;
 458                 y = swizzle[i + 2] - '0';
 459                 x = swizzle[i + 3] - '0';
 460             }
 461             else
 462             {
 463                 y = swizzle[i + 1] - '1';
 464                 x = swizzle[i + 2] - '1';
 465             }
 466
 467             if (x >= value->data_type->dimx || y >= value->data_type->dimy)
 468                 return NULL;
 469             swiz |= (y << 4 | x) << component * 8;
 470             component++;
 471         }
 472         return new_swizzle(swiz, component, value, loc);
 473     }
 474
 475     /* Vector swizzle */
 476     if (len > 4)
 477         return NULL;
 478
 479     for (set = 0; set < 2; ++set)
 480     {
 481         valid = TRUE;
 482         component = 0;
 483         for (i = 0; i < len; ++i)
 484         {
 485             char c[2][4] = {{'x', 'y', 'z', 'w'}, {'r', 'g', 'b', 'a'}};
 486             unsigned int s = 0;
 487
 488             for (s = 0; s < 4; ++s)
 489             {
 490                 if (swizzle[i] == c[set][s])
 491                     break;
 492             }
 493             if (s == 4)
 494             {
 495                 valid = FALSE;
 496                 break;
 497             }
 498
 499             if (s >= value->data_type->dimx)
 500                 return NULL;
 501             swiz |= s << component * 2;
 502             component++;
 503         }
 504         if (valid)
 505             return new_swizzle(swiz, component, value, loc);
 506     }
 507
 508     return NULL;
 509 }
 510
 511 static struct hlsl_ir_var *new_synthetic_var(const char *name, struct hlsl_type *type,
 512         const struct source_location loc)
 513 {
 514     struct hlsl_ir_var *var;
 515
 516     if (!(var = d3dcompiler_alloc(sizeof(*var))))
 517     {
 518         hlsl_ctx.status = PARSE_ERR;
 519         return NULL;
 520     }
 521
 522     var->name = strdup(name);
 523     var->data_type = type;
 524     var->loc = loc;
 525     list_add_tail(&hlsl_ctx.globals->vars, &var->scope_entry);
 526     return var;
 527 }
 528
 529 static struct hlsl_ir_assignment *new_assignment(struct hlsl_ir_var *var, struct hlsl_ir_node *offset,
 530         struct hlsl_ir_node *rhs, unsigned int writemask, struct source_location loc)
 531 {
 532     struct hlsl_ir_assignment *assign;
 533
 534     if (!writemask && type_is_single_reg(rhs->data_type))
 535         writemask = (1 << rhs->data_type->dimx) - 1;
 536
 537     if (!(assign = d3dcompiler_alloc(sizeof(*assign))))
 538         return NULL;
 539
 540     init_node(&assign->node, HLSL_IR_ASSIGNMENT, NULL, loc);
 541     assign->lhs.var = var;
 542     assign->lhs.offset = offset;
 543     assign->rhs = rhs;
 544     assign->writemask = writemask;
 545     return assign;
 546 }
 547
 548 static struct hlsl_ir_assignment *make_simple_assignment(struct hlsl_ir_var *lhs, struct hlsl_ir_node *rhs)
 549 {
 550     return new_assignment(lhs, NULL, rhs, 0, rhs->loc);
 551 }
 552
 553 static struct hlsl_ir_jump *new_return(struct hlsl_ir_node *return_value, struct source_location loc)
 554 {
 555     struct hlsl_type *return_type = hlsl_ctx.cur_function->return_type;
 556     struct hlsl_ir_jump *jump;
 557
 558     if (return_value)
 559     {
 560         struct hlsl_ir_assignment *assignment;
 561
 562         if (!(return_value = implicit_conversion(return_value, return_type, &loc)))
 563             return NULL;
 564
 565         if (!(assignment = make_simple_assignment(hlsl_ctx.cur_function->return_var, return_value)))
 566             return NULL;
 567         list_add_after(&return_value->entry, &assignment->node.entry);
 568     }
 569     else if (!type_is_void(return_type))
 570     {
 571         hlsl_report_message(loc, HLSL_LEVEL_ERROR, "non-void function must return a value");
 572         return NULL;
 573     }
 574
 575     if (!(jump = d3dcompiler_alloc(sizeof(*jump))))
 576     {
 577         ERR("Out of memory\n");
 578         return NULL;
 579     }
 580     init_node(&jump->node, HLSL_IR_JUMP, NULL, loc);
 581     jump->type = HLSL_IR_JUMP_RETURN;
 582
 583     return jump;
 584 }
 585
 586 static struct hlsl_ir_constant *new_uint_constant(unsigned int n, const struct source_location loc)
 587 {
 588     struct hlsl_ir_constant *c;
 589
 590     if (!(c = d3dcompiler_alloc(sizeof(*c))))
 591         return NULL;
 592     init_node(&c->node, HLSL_IR_CONSTANT, hlsl_ctx.builtin_types.scalar[HLSL_TYPE_UINT], loc);
 593     c->v.value.u[0] = n;
 594     return c;
 595 }
 596
 597 static struct hlsl_ir_load *new_var_load(struct hlsl_ir_var *var, const struct source_location loc)
 598 {
 599     struct hlsl_ir_load *load = d3dcompiler_alloc(sizeof(*load));
 600
 601     if (!load)
 602     {
 603         ERR("Out of memory.\n");
 604         return NULL;
 605     }
 606     init_node(&load->node, HLSL_IR_LOAD, var->data_type, loc);
 607     load->src.var = var;
 608     return load;
 609 }
 610
 611 static struct hlsl_ir_load *new_load(struct hlsl_ir_node *var_node, struct hlsl_ir_node *offset,
 612         struct hlsl_type *data_type, const struct source_location loc)
 613 {
 614     struct hlsl_ir_node *add = NULL;
 615     struct hlsl_ir_load *load;
 616     struct hlsl_ir_var *var;
 617
 618     if (var_node->type == HLSL_IR_LOAD)
 619     {
 620         const struct hlsl_deref *src = &load_from_node(var_node)->src;
 621
 622         var = src->var;
 623         if (src->offset)
 624         {
 625             if (!(add = new_binary_expr(HLSL_IR_BINOP_ADD, src->offset, offset, loc)))
 626                 return NULL;
 627             list_add_after(&offset->entry, &add->entry);
 628             offset = add;
 629         }
 630     }
 631     else
 632     {
 633         struct hlsl_ir_assignment *assign;
 634         char name[27];
 635
 636         sprintf(name, "<deref-%p>", var_node);
 637         if (!(var = new_synthetic_var(name, var_node->data_type, var_node->loc)))
 638             return NULL;
 639
 640         TRACE("Synthesized variable %p for %s node.\n", var, debug_node_type(var_node->type));
 641
 642         if (!(assign = make_simple_assignment(var, var_node)))
 643             return NULL;
 644
 645         list_add_after(&var_node->entry, &assign->node.entry);
 646     }
 647
 648     if (!(load = d3dcompiler_alloc(sizeof(*load))))
 649         return NULL;
 650     init_node(&load->node, HLSL_IR_LOAD, data_type, loc);
 651     load->src.var = var;
 652     load->src.offset = offset;
 653     list_add_after(&offset->entry, &load->node.entry);
 654     return load;
 655 }
 656
 657 static struct hlsl_ir_load *new_record_load(struct hlsl_ir_node *record,
 658         const struct hlsl_struct_field *field, const struct source_location loc)
 659 {
 660     struct hlsl_ir_constant *c;
 661
 662     if (!(c = new_uint_constant(field->reg_offset * 4, loc)))
 663         return NULL;
 664     list_add_after(&record->entry, &c->node.entry);
 665
 666     return new_load(record, &c->node, field->type, loc);
 667 }
 668
 669 static struct hlsl_ir_load *new_array_load(struct hlsl_ir_node *array,
 670         struct hlsl_ir_node *index, const struct source_location loc)
 671 {
 672     const struct hlsl_type *expr_type = array->data_type;
 673     struct hlsl_type *data_type;
 674     struct hlsl_ir_constant *c;
 675     struct hlsl_ir_node *mul;
 676
 677     TRACE("Array load from type %s.\n", debug_hlsl_type(expr_type));
 678
 679     if (expr_type->type == HLSL_CLASS_ARRAY)
 680     {
 681         data_type = expr_type->e.array.type;
 682     }
 683     else if (expr_type->type == HLSL_CLASS_MATRIX || expr_type->type == HLSL_CLASS_VECTOR)
 684     {
 685         /* This needs to be lowered now, while we still have type information. */
 686         FIXME("Index of matrix or vector type.\n");
 687         return NULL;
 688     }
 689     else
 690     {
 691         if (expr_type->type == HLSL_CLASS_SCALAR)
 692             hlsl_report_message(loc, HLSL_LEVEL_ERROR, "array-indexed expression is scalar");
 693         else
 694             hlsl_report_message(loc, HLSL_LEVEL_ERROR, "expression is not array-indexable");
 695         return NULL;
 696     }
 697
 698     if (!(c = new_uint_constant(data_type->reg_size * 4, loc)))
 699         return NULL;
 700     list_add_after(&index->entry, &c->node.entry);
 701     if (!(mul = new_binary_expr(HLSL_IR_BINOP_MUL, index, &c->node, loc)))
 702         return NULL;
 703     list_add_after(&c->node.entry, &mul->entry);
 704     index = mul;
 705
 706     return new_load(array, index, data_type, loc);
 707 }
 708
 709 static void struct_var_initializer(struct list *list, struct hlsl_ir_var *var,
 710         struct parse_initializer *initializer)
 711 {
 712     struct hlsl_type *type = var->data_type;
 713     struct hlsl_struct_field *field;
 714     unsigned int i = 0;
 715
 716     if (initializer_size(initializer) != components_count_type(type))
 717     {
 718         hlsl_report_message(var->loc, HLSL_LEVEL_ERROR, "structure initializer mismatch");
 719         free_parse_initializer(initializer);
 720         return;
 721     }
 722
 723     list_move_tail(list, initializer->instrs);
 724     d3dcompiler_free(initializer->instrs);
 725
 726     LIST_FOR_EACH_ENTRY(field, type->e.elements, struct hlsl_struct_field, entry)
 727     {
 728         struct hlsl_ir_node *node = initializer->args[i];
 729         struct hlsl_ir_assignment *assign;
 730         struct hlsl_ir_constant *c;
 731
 732         if (i++ >= initializer->args_count)
 733             break;
 734
 735         if (components_count_type(field->type) == components_count_type(node->data_type))
 736         {
 737             if (!(c = new_uint_constant(field->reg_offset * 4, node->loc)))
 738                 break;
 739             list_add_tail(list, &c->node.entry);
 740
 741             if (!(assign = new_assignment(var, &c->node, node, 0, node->loc)))
 742                 break;
 743             list_add_tail(list, &assign->node.entry);
 744         }
 745         else
 746             FIXME("Initializing with \"mismatched\" fields is not supported yet.\n");
 747     }
 748
 749     d3dcompiler_free(initializer->args);
 750 }
 751
 752 static void free_parse_variable_def(struct parse_variable_def *v)
 753 {
 754     free_parse_initializer(&v->initializer);
 755     d3dcompiler_free(v->name);
 756     d3dcompiler_free((void *)v->semantic);
 757     d3dcompiler_free(v->reg_reservation);
 758     d3dcompiler_free(v);
 759 }
 760
 761 static struct list *declare_vars(struct hlsl_type *basic_type, DWORD modifiers, struct list *var_list)
 762 {
 763     struct hlsl_type *type;
 764     struct parse_variable_def *v, *v_next;
 765     struct hlsl_ir_var *var;
 766     struct hlsl_ir_node *assignment;
 767     BOOL ret, local = TRUE;
 768     struct list *statements_list = d3dcompiler_alloc(sizeof(*statements_list));
 769
 770     if (basic_type->type == HLSL_CLASS_MATRIX)
 771         assert(basic_type->modifiers & HLSL_MODIFIERS_MAJORITY_MASK);
 772
 773     if (!statements_list)
 774     {
 775         ERR("Out of memory.\n");
 776         LIST_FOR_EACH_ENTRY_SAFE(v, v_next, var_list, struct parse_variable_def, entry)
 777             free_parse_variable_def(v);
 778         d3dcompiler_free(var_list);
 779         return NULL;
 780     }
 781     list_init(statements_list);
 782
 783     if (!var_list)
 784         return statements_list;
 785
 786     LIST_FOR_EACH_ENTRY_SAFE(v, v_next, var_list, struct parse_variable_def, entry)
 787     {
 788         var = d3dcompiler_alloc(sizeof(*var));
 789         if (!var)
 790         {
 791             ERR("Out of memory.\n");
 792             free_parse_variable_def(v);
 793             continue;
 794         }
 795         if (v->array_size)
 796             type = new_array_type(basic_type, v->array_size);
 797         else
 798             type = basic_type;
 799         var->data_type = type;
 800         var->loc = v->loc;
 801         var->name = v->name;
 802         var->modifiers = modifiers;
 803         var->semantic = v->semantic;
 804         var->reg_reservation = v->reg_reservation;
 805         debug_dump_decl(type, modifiers, v->name, v->loc.line);
 806
 807         if (hlsl_ctx.cur_scope == hlsl_ctx.globals)
 808         {
 809             var->modifiers |= HLSL_STORAGE_UNIFORM;
 810             local = FALSE;
 811         }
 812
 813         if (type->modifiers & HLSL_MODIFIER_CONST && !(var->modifiers & HLSL_STORAGE_UNIFORM) && !v->initializer.args_count)
 814         {
 815             hlsl_report_message(v->loc, HLSL_LEVEL_ERROR, "const variable without initializer");
 816             free_declaration(var);
 817             d3dcompiler_free(v);
 818             continue;
 819         }
 820
 821         ret = declare_variable(var, local);
 822         if (!ret)
 823         {
 824             free_declaration(var);
 825             d3dcompiler_free(v);
 826             continue;
 827         }
 828         TRACE("Declared variable %s.\n", var->name);
 829
 830         if (v->initializer.args_count)
 831         {
 832             unsigned int size = initializer_size(&v->initializer);
 833             struct hlsl_ir_load *load;
 834
 835             TRACE("Variable with initializer.\n");
 836             if (type->type <= HLSL_CLASS_LAST_NUMERIC
 837                     && type->dimx * type->dimy != size && size != 1)
 838             {
 839                 if (size < type->dimx * type->dimy)
 840                 {
 841                     hlsl_report_message(v->loc, HLSL_LEVEL_ERROR,
 842                             "'%s' initializer does not match", v->name);
 843                     free_parse_initializer(&v->initializer);
 844                     d3dcompiler_free(v);
 845                     continue;
 846                 }
 847             }
 848             if ((type->type == HLSL_CLASS_STRUCT || type->type == HLSL_CLASS_ARRAY)
 849                     && components_count_type(type) != size)
 850             {
 851                 hlsl_report_message(v->loc, HLSL_LEVEL_ERROR,
 852                         "'%s' initializer does not match", v->name);
 853                 free_parse_initializer(&v->initializer);
 854                 d3dcompiler_free(v);
 855                 continue;
 856             }
 857
 858             if (type->type == HLSL_CLASS_STRUCT)
 859             {
 860                 struct_var_initializer(statements_list, var, &v->initializer);
 861                 d3dcompiler_free(v);
 862                 continue;
 863             }
 864             if (type->type > HLSL_CLASS_LAST_NUMERIC)
 865             {
 866                 FIXME("Initializers for non scalar/struct variables not supported yet.\n");
 867                 free_parse_initializer(&v->initializer);
 868                 d3dcompiler_free(v);
 869                 continue;
 870             }
 871             if (v->array_size > 0)
 872             {
 873                 FIXME("Initializing arrays is not supported yet.\n");
 874                 free_parse_initializer(&v->initializer);
 875                 d3dcompiler_free(v);
 876                 continue;
 877             }
 878             if (v->initializer.args_count > 1)
 879             {
 880                 FIXME("Complex initializers are not supported yet.\n");
 881                 free_parse_initializer(&v->initializer);
 882                 d3dcompiler_free(v);
 883                 continue;
 884             }
 885
 886             list_move_tail(statements_list, v->initializer.instrs);
 887             d3dcompiler_free(v->initializer.instrs);
 888
 889             load = new_var_load(var, var->loc);
 890             list_add_tail(statements_list, &load->node.entry);
 891             assignment = make_assignment(&load->node, ASSIGN_OP_ASSIGN, v->initializer.args[0]);
 892             d3dcompiler_free(v->initializer.args);
 893             list_add_tail(statements_list, &assignment->entry);
 894         }
 895         d3dcompiler_free(v);
 896     }
 897     d3dcompiler_free(var_list);
 898     return statements_list;
 899 }
 900
 901 static BOOL add_struct_field(struct list *fields, struct hlsl_struct_field *field)
 902 {
 903     struct hlsl_struct_field *f;
 904
 905     LIST_FOR_EACH_ENTRY(f, fields, struct hlsl_struct_field, entry)
 906     {
 907         if (!strcmp(f->name, field->name))
 908             return FALSE;
 909     }
 910     list_add_tail(fields, &field->entry);
 911     return TRUE;
 912 }
 913
 914 BOOL is_row_major(const struct hlsl_type *type)
 915 {
 916     /* Default to column-major if the majority isn't explicitly set, which can
 917      * happen for anonymous nodes. */
 918     return !!(type->modifiers & HLSL_MODIFIER_ROW_MAJOR);
 919 }
 920
 921 static struct hlsl_type *apply_type_modifiers(struct hlsl_type *type,
 922         unsigned int *modifiers, struct source_location loc)
 923 {
 924     unsigned int default_majority = 0;
 925     struct hlsl_type *new_type;
 926
 927     /* This function is only used for declarations (i.e. variables and struct
 928      * fields), which should inherit the matrix majority. We only explicitly set
 929      * the default majority for declarations—typedefs depend on this—but we
 930      * want to always set it, so that an hlsl_type object is never used to
 931      * represent two different majorities (and thus can be used to store its
 932      * register size, etc.) */
 933     if (!(*modifiers & HLSL_MODIFIERS_MAJORITY_MASK)
 934             && !(type->modifiers & HLSL_MODIFIERS_MAJORITY_MASK)
 935             && type->type == HLSL_CLASS_MATRIX)
 936     {
 937         if (hlsl_ctx.matrix_majority == HLSL_COLUMN_MAJOR)
 938             default_majority = HLSL_MODIFIER_COLUMN_MAJOR;
 939         else
 940             default_majority = HLSL_MODIFIER_ROW_MAJOR;
 941     }
 942
 943     if (!default_majority && !(*modifiers & HLSL_TYPE_MODIFIERS_MASK))
 944         return type;
 945
 946     if (!(new_type = clone_hlsl_type(type, default_majority)))
 947         return NULL;
 948
 949     new_type->modifiers = add_modifiers(new_type->modifiers, *modifiers, loc);
 950     *modifiers &= ~HLSL_TYPE_MODIFIERS_MASK;
 951
 952     if (new_type->type == HLSL_CLASS_MATRIX)
 953         new_type->reg_size = is_row_major(new_type) ? new_type->dimy : new_type->dimx;
 954     return new_type;
 955 }
 956
 957 static struct list *gen_struct_fields(struct hlsl_type *type, DWORD modifiers, struct list *fields)
 958 {
 959     struct parse_variable_def *v, *v_next;
 960     struct hlsl_struct_field *field;
 961     struct list *list;
 962
 963     if (type->type == HLSL_CLASS_MATRIX)
 964         assert(type->modifiers & HLSL_MODIFIERS_MAJORITY_MASK);
 965
 966     list = d3dcompiler_alloc(sizeof(*list));
 967     if (!list)
 968     {
 969         ERR("Out of memory.\n");
 970         return NULL;
 971     }
 972     list_init(list);
 973     LIST_FOR_EACH_ENTRY_SAFE(v, v_next, fields, struct parse_variable_def, entry)
 974     {
 975         debug_dump_decl(type, 0, v->name, v->loc.line);
 976         field = d3dcompiler_alloc(sizeof(*field));
 977         if (!field)
 978         {
 979             ERR("Out of memory.\n");
 980             d3dcompiler_free(v);
 981             return list;
 982         }
 983         if (v->array_size)
 984             field->type = new_array_type(type, v->array_size);
 985         else
 986             field->type = type;
 987         field->name = v->name;
 988         field->modifiers = modifiers;
 989         field->semantic = v->semantic;
 990         if (v->initializer.args_count)
 991         {
 992             hlsl_report_message(v->loc, HLSL_LEVEL_ERROR, "struct field with an initializer.\n");
 993             free_parse_initializer(&v->initializer);
 994         }
 995         list_add_tail(list, &field->entry);
 996         d3dcompiler_free(v);
 997     }
 998     d3dcompiler_free(fields);
 999     return list;
1000 }
1001
1002 static DWORD get_array_size(const struct hlsl_type *type)
1003 {
1004     if (type->type == HLSL_CLASS_ARRAY)
1005         return get_array_size(type->e.array.type) * type->e.array.elements_count;
1006     return 1;
1007 }
1008
1009 static struct hlsl_type *new_struct_type(const char *name, struct list *fields)
1010 {
1011     struct hlsl_type *type = d3dcompiler_alloc(sizeof(*type));
1012     struct hlsl_struct_field *field;
1013     unsigned int reg_size = 0;
1014
1015     if (!type)
1016     {
1017         ERR("Out of memory.\n");
1018         return NULL;
1019     }
1020     type->type = HLSL_CLASS_STRUCT;
1021     type->base_type = HLSL_TYPE_VOID;
1022     type->name = name;
1023     type->dimx = 0;
1024     type->dimy = 1;
1025     type->e.elements = fields;
1026
1027     LIST_FOR_EACH_ENTRY(field, fields, struct hlsl_struct_field, entry)
1028     {
1029         field->reg_offset = reg_size;
1030         reg_size += field->type->reg_size;
1031         type->dimx += field->type->dimx * field->type->dimy * get_array_size(field->type);
1032     }
1033     type->reg_size = reg_size;
1034
1035     list_add_tail(&hlsl_ctx.types, &type->entry);
1036
1037     return type;
1038 }
1039
1040 static BOOL add_typedef(DWORD modifiers, struct hlsl_type *orig_type, struct list *list)
1041 {
1042     BOOL ret;
1043     struct hlsl_type *type;
1044     struct parse_variable_def *v, *v_next;
1045
1046     LIST_FOR_EACH_ENTRY_SAFE(v, v_next, list, struct parse_variable_def, entry)
1047     {
1048         if (v->array_size)
1049             type = new_array_type(orig_type, v->array_size);
1050         else
1051             type = clone_hlsl_type(orig_type, 0);
1052         if (!type)
1053         {
1054             ERR("Out of memory\n");
1055             return FALSE;
1056         }
1057         d3dcompiler_free((void *)type->name);
1058         type->name = v->name;
1059         type->modifiers |= modifiers;
1060
1061         if (type->type != HLSL_CLASS_MATRIX)
1062             check_invalid_matrix_modifiers(type->modifiers, v->loc);
1063         else
1064             type->reg_size = is_row_major(type) ? type->dimy : type->dimx;
1065
1066         if ((type->modifiers & HLSL_MODIFIER_COLUMN_MAJOR)
1067                 && (type->modifiers & HLSL_MODIFIER_ROW_MAJOR))
1068             hlsl_report_message(v->loc, HLSL_LEVEL_ERROR, "more than one matrix majority keyword");
1069
1070         ret = add_type_to_scope(hlsl_ctx.cur_scope, type);
1071         if (!ret)
1072         {
1073             hlsl_report_message(v->loc, HLSL_LEVEL_ERROR,
1074                     "redefinition of custom type '%s'", v->name);
1075         }
1076         d3dcompiler_free(v);
1077     }
1078     d3dcompiler_free(list);
1079     return TRUE;
1080 }
1081
1082 static BOOL add_func_parameter(struct list *list, struct parse_parameter *param, const struct source_location loc)
1083 {
1084     struct hlsl_ir_var *decl = d3dcompiler_alloc(sizeof(*decl));
1085
1086     if (param->type->type == HLSL_CLASS_MATRIX)
1087         assert(param->type->modifiers & HLSL_MODIFIERS_MAJORITY_MASK);
1088
1089     if (!decl)
1090     {
1091         ERR("Out of memory.\n");
1092         return FALSE;
1093     }
1094     decl->data_type = param->type;
1095     decl->loc = loc;
1096     decl->name = param->name;
1097     decl->semantic = param->semantic;
1098     decl->reg_reservation = param->reg_reservation;
1099     decl->modifiers = param->modifiers;
1100
1101     if (!add_declaration(hlsl_ctx.cur_scope, decl, FALSE))
1102     {
1103         free_declaration(decl);
1104         return FALSE;
1105     }
1106     list_add_tail(list, &decl->param_entry);
1107     return TRUE;
1108 }
1109
1110 static struct reg_reservation *parse_reg_reservation(const char *reg_string)
1111 {
1112     struct reg_reservation *reg_res;
1113     enum bwritershader_param_register_type type;
1114     DWORD regnum = 0;
1115
1116     switch (reg_string[0])
1117     {
1118         case 'c':
1119             type = BWRITERSPR_CONST;
1120             break;
1121         case 'i':
1122             type = BWRITERSPR_CONSTINT;
1123             break;
1124         case 'b':
1125             type = BWRITERSPR_CONSTBOOL;
1126             break;
1127         case 's':
1128             type = BWRITERSPR_SAMPLER;
1129             break;
1130         default:
1131             FIXME("Unsupported register type.\n");
1132             return NULL;
1133      }
1134
1135     if (!sscanf(reg_string + 1, "%u", &regnum))
1136     {
1137         FIXME("Unsupported register reservation syntax.\n");
1138         return NULL;
1139     }
1140
1141     reg_res = d3dcompiler_alloc(sizeof(*reg_res));
1142     if (!reg_res)
1143     {
1144         ERR("Out of memory.\n");
1145         return NULL;
1146     }
1147     reg_res->type = type;
1148     reg_res->regnum = regnum;
1149     return reg_res;
1150 }
1151
1152 static const struct hlsl_ir_function_decl *get_overloaded_func(struct wine_rb_tree *funcs, char *name,
1153         struct list *params, BOOL exact_signature)
1154 {
1155     struct hlsl_ir_function *func;
1156     struct wine_rb_entry *entry;
1157
1158     entry = wine_rb_get(funcs, name);
1159     if (entry)
1160     {
1161         func = WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry);
1162
1163         entry = wine_rb_get(&func->overloads, params);
1164         if (!entry)
1165         {
1166             if (!exact_signature)
1167                 FIXME("No exact match, search for a compatible overloaded function (if any).\n");
1168             return NULL;
1169         }
1170         return WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function_decl, entry);
1171     }
1172     return NULL;
1173 }
1174
1175 static struct hlsl_ir_function_decl *get_func_entry(const char *name)
1176 {
1177     struct hlsl_ir_function_decl *decl;
1178     struct hlsl_ir_function *func;
1179     struct wine_rb_entry *entry;
1180
1181     if ((entry = wine_rb_get(&hlsl_ctx.functions, name)))
1182     {
1183         func = WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry);
1184         WINE_RB_FOR_EACH_ENTRY(decl, &func->overloads, struct hlsl_ir_function_decl, entry)
1185             return decl;
1186     }
1187
1188     return NULL;
1189 }
1190
1191 static struct list *append_unop(struct list *list, struct hlsl_ir_node *node)
1192 {
1193     list_add_tail(list, &node->entry);
1194     return list;
1195 }
1196
1197 static struct list *append_binop(struct list *first, struct list *second, struct hlsl_ir_node *node)
1198 {
1199     list_move_tail(first, second);
1200     d3dcompiler_free(second);
1201     list_add_tail(first, &node->entry);
1202     return first;
1203 }
1204
1205 static struct list *make_list(struct hlsl_ir_node *node)
1206 {
1207     struct list *list;
1208
1209     if (!(list = d3dcompiler_alloc(sizeof(*list))))
1210     {
1211         ERR("Out of memory.\n");
1212         free_instr(node);
1213         return NULL;
1214     }
1215     list_init(list);
1216     list_add_tail(list, &node->entry);
1217     return list;
1218 }
1219
1220 static unsigned int evaluate_array_dimension(struct hlsl_ir_node *node)
1221 {
1222     if (node->data_type->type != HLSL_CLASS_SCALAR)
1223         return 0;
1224
1225     switch (node->type)
1226     {
1227     case HLSL_IR_CONSTANT:
1228     {
1229         struct hlsl_ir_constant *constant = constant_from_node(node);
1230
1231         switch (constant->node.data_type->base_type)
1232         {
1233         case HLSL_TYPE_UINT:
1234             return constant->v.value.u[0];
1235         case HLSL_TYPE_INT:
1236             return constant->v.value.i[0];
1237         case HLSL_TYPE_FLOAT:
1238             return constant->v.value.f[0];
1239         case HLSL_TYPE_DOUBLE:
1240             return constant->v.value.d[0];
1241         case HLSL_TYPE_BOOL:
1242             return constant->v.value.b[0];
1243         default:
1244             WARN("Invalid type %s.\n", debug_base_type(constant->node.data_type));
1245             return 0;
1246         }
1247     }
1248     case HLSL_IR_CONSTRUCTOR:
1249     case HLSL_IR_EXPR:
1250     case HLSL_IR_LOAD:
1251     case HLSL_IR_SWIZZLE:
1252         FIXME("Unhandled type %s.\n", debug_node_type(node->type));
1253         return 0;
1254     case HLSL_IR_ASSIGNMENT:
1255     default:
1256         WARN("Invalid node type %s.\n", debug_node_type(node->type));
1257         return 0;
1258     }
1259 }
1260
1261 static struct hlsl_ir_function_decl *new_func_decl(struct hlsl_type *return_type,
1262         struct list *parameters, const char *semantic, struct source_location loc)
1263 {
1264     struct hlsl_ir_function_decl *decl;
1265
1266     if (!(decl = d3dcompiler_alloc(sizeof(*decl))))
1267         return NULL;
1268     decl->return_type = return_type;
1269     decl->parameters = parameters;
1270     decl->semantic = semantic;
1271     decl->loc = loc;
1272
1273     if (!type_is_void(return_type))
1274     {
1275         struct hlsl_ir_var *return_var;
1276         char name[28];
1277
1278         sprintf(name, "<retval-%p>", decl);
1279         if (!(return_var = new_synthetic_var(name, return_type, loc)))
1280         {
1281             d3dcompiler_free(decl);
1282             return NULL;
1283         }
1284         decl->return_var = return_var;
1285     }
1286
1287     return decl;
1288 }
1289
1290 %}
1291
1292 %locations
1293 %define parse.error verbose
1294 %expect 1
1295
1296 %union
1297 {
1298     struct hlsl_type *type;
1299     INT intval;
1300     FLOAT floatval;
1301     BOOL boolval;
1302     char *name;
1303     DWORD modifiers;
1304     struct hlsl_ir_node *instr;
1305     struct list *list;
1306     struct parse_function function;
1307     struct parse_parameter parameter;
1308     struct parse_initializer initializer;
1309     struct parse_variable_def *variable_def;
1310     struct parse_if_body if_body;
1311     enum parse_unary_op unary_op;
1312     enum parse_assign_op assign_op;
1313     struct reg_reservation *reg_reservation;
1314     struct parse_colon_attribute colon_attribute;
1315 }
1316
1317 %token KW_BLENDSTATE
1318 %token KW_BREAK
1319 %token KW_BUFFER
1320 %token KW_CBUFFER
1321 %token KW_COLUMN_MAJOR
1322 %token KW_COMPILE
1323 %token KW_CONST
1324 %token KW_CONTINUE
1325 %token KW_DEPTHSTENCILSTATE
1326 %token KW_DEPTHSTENCILVIEW
1327 %token KW_DISCARD
1328 %token KW_DO
1329 %token KW_DOUBLE
1330 %token KW_ELSE
1331 %token KW_EXTERN
1332 %token KW_FALSE
1333 %token KW_FOR
1334 %token KW_GEOMETRYSHADER
1335 %token KW_GROUPSHARED
1336 %token KW_IF
1337 %token KW_IN
1338 %token KW_INLINE
1339 %token KW_INOUT
1340 %token KW_MATRIX
1341 %token KW_NAMESPACE
1342 %token KW_NOINTERPOLATION
1343 %token KW_OUT
1344 %token KW_PASS
1345 %token KW_PIXELSHADER
1346 %token KW_PRECISE
1347 %token KW_RASTERIZERSTATE
1348 %token KW_RENDERTARGETVIEW
1349 %token KW_RETURN
1350 %token KW_REGISTER
1351 %token KW_ROW_MAJOR
1352 %token KW_SAMPLER
1353 %token KW_SAMPLER1D
1354 %token KW_SAMPLER2D
1355 %token KW_SAMPLER3D
1356 %token KW_SAMPLERCUBE
1357 %token KW_SAMPLER_STATE
1358 %token KW_SAMPLERCOMPARISONSTATE
1359 %token KW_SHARED
1360 %token KW_STATEBLOCK
1361 %token KW_STATEBLOCK_STATE
1362 %token KW_STATIC
1363 %token KW_STRING
1364 %token KW_STRUCT
1365 %token KW_SWITCH
1366 %token KW_TBUFFER
1367 %token KW_TECHNIQUE
1368 %token KW_TECHNIQUE10
1369 %token KW_TEXTURE
1370 %token KW_TEXTURE1D
1371 %token KW_TEXTURE1DARRAY
1372 %token KW_TEXTURE2D
1373 %token KW_TEXTURE2DARRAY
1374 %token KW_TEXTURE2DMS
1375 %token KW_TEXTURE2DMSARRAY
1376 %token KW_TEXTURE3D
1377 %token KW_TEXTURE3DARRAY
1378 %token KW_TEXTURECUBE
1379 %token KW_TRUE
1380 %token KW_TYPEDEF
1381 %token KW_UNIFORM
1382 %token KW_VECTOR
1383 %token KW_VERTEXSHADER
1384 %token KW_VOID
1385 %token KW_VOLATILE
1386 %token KW_WHILE
1387
1388 %token OP_INC
1389 %token OP_DEC
1390 %token OP_AND
1391 %token OP_OR
1392 %token OP_EQ
1393 %token OP_LEFTSHIFT
1394 %token OP_LEFTSHIFTASSIGN
1395 %token OP_RIGHTSHIFT
1396 %token OP_RIGHTSHIFTASSIGN
1397 %token OP_ELLIPSIS
1398 %token OP_LE
1399 %token OP_GE
1400 %token OP_NE
1401 %token OP_ADDASSIGN
1402 %token OP_SUBASSIGN
1403 %token OP_MULASSIGN
1404 %token OP_DIVASSIGN
1405 %token OP_MODASSIGN
1406 %token OP_ANDASSIGN
1407 %token OP_ORASSIGN
1408 %token OP_XORASSIGN
1409 %token OP_UNKNOWN1
1410 %token OP_UNKNOWN2
1411 %token OP_UNKNOWN3
1412 %token OP_UNKNOWN4
1413
1414 %token <intval> PRE_LINE
1415
1416 %token <name> VAR_IDENTIFIER TYPE_IDENTIFIER NEW_IDENTIFIER
1417 %type <name> any_identifier var_identifier
1418 %token <name> STRING
1419 %token <floatval> C_FLOAT
1420 %token <intval> C_INTEGER
1421 %type <boolval> boolean
1422 %type <type> base_type
1423 %type <type> type
1424 %type <list> declaration_statement
1425 %type <list> declaration
1426 %type <list> struct_declaration
1427 %type <type> struct_spec
1428 %type <type> named_struct_spec
1429 %type <type> unnamed_struct_spec
1430 %type <type> field_type
1431 %type <type> typedef_type
1432 %type <list> type_specs
1433 %type <variable_def> type_spec
1434 %type <initializer> complex_initializer
1435 %type <initializer> initializer_expr_list
1436 %type <list> initializer_expr
1437 %type <modifiers> var_modifiers
1438 %type <list> field
1439 %type <list> parameters
1440 %type <list> param_list
1441 %type <list> expr
1442 %type <intval> array
1443 %type <list> statement
1444 %type <list> statement_list
1445 %type <list> compound_statement
1446 %type <list> jump_statement
1447 %type <list> selection_statement
1448 %type <list> loop_statement
1449 %type <function> func_declaration
1450 %type <function> func_prototype
1451 %type <list> fields_list
1452 %type <parameter> parameter
1453 %type <colon_attribute> colon_attribute
1454 %type <name> semantic
1455 %type <reg_reservation> register_opt
1456 %type <variable_def> variable_def
1457 %type <list> variables_def
1458 %type <list> variables_def_optional
1459 %type <if_body> if_body
1460 %type <list> primary_expr
1461 %type <list> postfix_expr
1462 %type <list> unary_expr
1463 %type <list> mul_expr
1464 %type <list> add_expr
1465 %type <list> shift_expr
1466 %type <list> relational_expr
1467 %type <list> equality_expr
1468 %type <list> bitand_expr
1469 %type <list> bitxor_expr
1470 %type <list> bitor_expr
1471 %type <list> logicand_expr
1472 %type <list> logicor_expr
1473 %type <list> conditional_expr
1474 %type <list> assignment_expr
1475 %type <list> expr_statement
1476 %type <unary_op> unary_op
1477 %type <assign_op> assign_op
1478 %type <modifiers> input_mods
1479 %type <modifiers> input_mod
1480 %%
1481
1482 hlsl_prog:                /* empty */
1483                             {
1484                             }
1485                         | hlsl_prog func_declaration
1486                             {
1487                                 const struct hlsl_ir_function_decl *decl;
1488
1489                                 decl = get_overloaded_func(&hlsl_ctx.functions, $2.name, $2.decl->parameters, TRUE);
1490                                 if (decl && !decl->func->intrinsic)
1491                                 {
1492                                     if (decl->body && $2.decl->body)
1493                                     {
1494                                         hlsl_report_message($2.decl->loc, HLSL_LEVEL_ERROR,
1495                                                 "redefinition of function %s", debugstr_a($2.name));
1496                                         YYABORT;
1497                                     }
1498                                     else if (!compare_hlsl_types(decl->return_type, $2.decl->return_type))
1499                                     {
1500                                         hlsl_report_message($2.decl->loc, HLSL_LEVEL_ERROR,
1501                                                 "redefining function %s with a different return type",
1502                                                 debugstr_a($2.name));
1503                                         hlsl_report_message(decl->loc, HLSL_LEVEL_NOTE,
1504                                                 "%s previously declared here",
1505                                                 debugstr_a($2.name));
1506                                         YYABORT;
1507                                     }
1508                                 }
1509
1510                                 if (type_is_void($2.decl->return_type) && $2.decl->semantic)
1511                                 {
1512                                     hlsl_report_message($2.decl->loc, HLSL_LEVEL_ERROR,
1513                                             "void function with a semantic");
1514                                 }
1515
1516                                 TRACE("Adding function '%s' to the function list.\n", $2.name);
1517                                 add_function_decl(&hlsl_ctx.functions, $2.name, $2.decl, FALSE);
1518                             }
1519                         | hlsl_prog declaration_statement
1520                             {
1521                                 TRACE("Declaration statement parsed.\n");
1522                             }
1523                         | hlsl_prog preproc_directive
1524                             {
1525                             }
1526                         | hlsl_prog ';'
1527                             {
1528                                 TRACE("Skipping stray semicolon.\n");
1529                             }
1530
1531 preproc_directive:        PRE_LINE STRING
1532                             {
1533                                 const char **new_array = NULL;
1534
1535                                 TRACE("Updating line information to file %s, line %u\n", debugstr_a($2), $1);
1536                                 hlsl_ctx.line_no = $1;
1537                                 if (strcmp($2, hlsl_ctx.source_file))
1538                                     new_array = d3dcompiler_realloc(hlsl_ctx.source_files,
1539                                             sizeof(*hlsl_ctx.source_files) * (hlsl_ctx.source_files_count + 1));
1540
1541                                 if (new_array)
1542                                 {
1543                                     hlsl_ctx.source_files = new_array;
1544                                     hlsl_ctx.source_files[hlsl_ctx.source_files_count++] = $2;
1545                                     hlsl_ctx.source_file = $2;
1546                                 }
1547                                 else
1548                                 {
1549                                     d3dcompiler_free($2);
1550                                 }
1551                             }
1552
1553 struct_declaration:       var_modifiers struct_spec variables_def_optional ';'
1554                             {
1555                                 struct hlsl_type *type;
1556                                 DWORD modifiers = $1;
1557
1558                                 if (!$3)
1559                                 {
1560                                     if (!$2->name)
1561                                     {
1562                                         hlsl_report_message(get_location(&@2), HLSL_LEVEL_ERROR,
1563                                                 "anonymous struct declaration with no variables");
1564                                     }
1565                                     if (modifiers)
1566                                     {
1567                                         hlsl_report_message(get_location(&@1), HLSL_LEVEL_ERROR,
1568                                                 "modifier not allowed on struct type declaration");
1569                                     }
1570                                 }
1571
1572                                 if (!(type = apply_type_modifiers($2, &modifiers, get_location(&@1))))
1573                                     YYABORT;
1574                                 $$ = declare_vars(type, modifiers, $3);
1575                             }
1576
1577 struct_spec:              named_struct_spec
1578                         | unnamed_struct_spec
1579
1580 named_struct_spec:        KW_STRUCT any_identifier '{' fields_list '}'
1581                             {
1582                                 BOOL ret;
1583
1584                                 TRACE("Structure %s declaration.\n", debugstr_a($2));
1585                                 $$ = new_struct_type($2, $4);
1586
1587                                 if (get_variable(hlsl_ctx.cur_scope, $2))
1588                                 {
1589                                     hlsl_report_message(get_location(&@2),
1590                                             HLSL_LEVEL_ERROR, "redefinition of '%s'", $2);
1591                                     YYABORT;
1592                                 }
1593
1594                                 ret = add_type_to_scope(hlsl_ctx.cur_scope, $$);
1595                                 if (!ret)
1596                                 {
1597                                     hlsl_report_message(get_location(&@2),
1598                                             HLSL_LEVEL_ERROR, "redefinition of struct '%s'", $2);
1599                                     YYABORT;
1600                                 }
1601                             }
1602
1603 unnamed_struct_spec:      KW_STRUCT '{' fields_list '}'
1604                             {
1605                                 TRACE("Anonymous structure declaration.\n");
1606                                 $$ = new_struct_type(NULL, $3);
1607                             }
1608
1609 any_identifier:           VAR_IDENTIFIER
1610                         | TYPE_IDENTIFIER
1611                         | NEW_IDENTIFIER
1612
1613 fields_list:              /* Empty */
1614                             {
1615                                 $$ = d3dcompiler_alloc(sizeof(*$$));
1616                                 list_init($$);
1617                             }
1618                         | fields_list field
1619                             {
1620                                 BOOL ret;
1621                                 struct hlsl_struct_field *field, *next;
1622
1623                                 $$ = $1;
1624                                 LIST_FOR_EACH_ENTRY_SAFE(field, next, $2, struct hlsl_struct_field, entry)
1625                                 {
1626                                     ret = add_struct_field($$, field);
1627                                     if (ret == FALSE)
1628                                     {
1629                                         hlsl_report_message(get_location(&@2),
1630                                                 HLSL_LEVEL_ERROR, "redefinition of '%s'", field->name);
1631                                         d3dcompiler_free(field);
1632                                     }
1633                                 }
1634                                 d3dcompiler_free($2);
1635                             }
1636
1637 field_type:               type
1638                         | unnamed_struct_spec
1639
1640 field:                    var_modifiers field_type variables_def ';'
1641                             {
1642                                 struct hlsl_type *type;
1643                                 DWORD modifiers = $1;
1644
1645                                 if (!(type = apply_type_modifiers($2, &modifiers, get_location(&@1))))
1646                                     YYABORT;
1647                                 $$ = gen_struct_fields(type, modifiers, $3);
1648                             }
1649
1650 func_declaration:         func_prototype compound_statement
1651                             {
1652                                 TRACE("Function %s parsed.\n", $1.name);
1653                                 $$ = $1;
1654                                 $$.decl->body = $2;
1655                                 pop_scope(&hlsl_ctx);
1656                             }
1657                         | func_prototype ';'
1658                             {
1659                                 TRACE("Function prototype for %s.\n", $1.name);
1660                                 $$ = $1;
1661                                 pop_scope(&hlsl_ctx);
1662                             }
1663
1664                         /* var_modifiers is necessary to avoid shift/reduce conflicts. */
1665 func_prototype:           var_modifiers type var_identifier '(' parameters ')' colon_attribute
1666                             {
1667                                 if ($1)
1668                                 {
1669                                     hlsl_report_message(get_location(&@1), HLSL_LEVEL_ERROR,
1670                                             "unexpected modifiers on a function");
1671                                     YYABORT;
1672                                 }
1673                                 if (get_variable(hlsl_ctx.globals, $3))
1674                                 {
1675                                     hlsl_report_message(get_location(&@3),
1676                                             HLSL_LEVEL_ERROR, "redefinition of '%s'\n", $3);
1677                                     YYABORT;
1678                                 }
1679                                 if (type_is_void($2) && $7.semantic)
1680                                 {
1681                                     hlsl_report_message(get_location(&@7),
1682                                             HLSL_LEVEL_ERROR, "void function with a semantic");
1683                                 }
1684
1685                                 if ($7.reg_reservation)
1686                                 {
1687                                     FIXME("Unexpected register reservation for a function.\n");
1688                                     d3dcompiler_free($7.reg_reservation);
1689                                 }
1690                                 if (!($$.decl = new_func_decl($2, $5, $7.semantic, get_location(&@3))))
1691                                 {
1692                                     ERR("Out of memory.\n");
1693                                     YYABORT;
1694                                 }
1695                                 $$.name = $3;
1696                                 hlsl_ctx.cur_function = $$.decl;
1697                             }
1698
1699 compound_statement:       '{' '}'
1700                             {
1701                                 $$ = d3dcompiler_alloc(sizeof(*$$));
1702                                 list_init($$);
1703                             }
1704                         | '{' scope_start statement_list '}'
1705                             {
1706                                 pop_scope(&hlsl_ctx);
1707                                 $$ = $3;
1708                             }
1709
1710 scope_start:              /* Empty */
1711                             {
1712                                 push_scope(&hlsl_ctx);
1713                             }
1714
1715 var_identifier:           VAR_IDENTIFIER
1716                         | NEW_IDENTIFIER
1717
1718 colon_attribute:          /* Empty */
1719                             {
1720                                 $$.semantic = NULL;
1721                                 $$.reg_reservation = NULL;
1722                             }
1723                         | semantic
1724                             {
1725                                 $$.semantic = $1;
1726                                 $$.reg_reservation = NULL;
1727                             }
1728                         | register_opt
1729                             {
1730                                 $$.semantic = NULL;
1731                                 $$.reg_reservation = $1;
1732                             }
1733
1734 semantic:                 ':' any_identifier
1735                             {
1736                                 $$ = $2;
1737                             }
1738
1739                           /* FIXME: Writemasks */
1740 register_opt:             ':' KW_REGISTER '(' any_identifier ')'
1741                             {
1742                                 $$ = parse_reg_reservation($4);
1743                                 d3dcompiler_free($4);
1744                             }
1745                         | ':' KW_REGISTER '(' any_identifier ',' any_identifier ')'
1746                             {
1747                                 FIXME("Ignoring shader target %s in a register reservation.\n", debugstr_a($4));
1748                                 d3dcompiler_free($4);
1749
1750                                 $$ = parse_reg_reservation($6);
1751                                 d3dcompiler_free($6);
1752                             }
1753
1754 parameters:               scope_start
1755                             {
1756                                 $$ = d3dcompiler_alloc(sizeof(*$$));
1757                                 list_init($$);
1758                             }
1759                         | scope_start param_list
1760                             {
1761                                 $$ = $2;
1762                             }
1763
1764 param_list:               parameter
1765                             {
1766                                 $$ = d3dcompiler_alloc(sizeof(*$$));
1767                                 list_init($$);
1768                                 if (!add_func_parameter($$, &$1, get_location(&@1)))
1769                                 {
1770                                     ERR("Error adding function parameter %s.\n", $1.name);
1771                                     set_parse_status(&hlsl_ctx.status, PARSE_ERR);
1772                                     YYABORT;
1773                                 }
1774                             }
1775                         | param_list ',' parameter
1776                             {
1777                                 $$ = $1;
1778                                 if (!add_func_parameter($$, &$3, get_location(&@3)))
1779                                 {
1780                                     hlsl_report_message(get_location(&@3), HLSL_LEVEL_ERROR,
1781                                             "duplicate parameter %s", $3.name);
1782                                     YYABORT;
1783                                 }
1784                             }
1785
1786 parameter:                input_mods var_modifiers type any_identifier colon_attribute
1787                             {
1788                                 struct hlsl_type *type;
1789                                 DWORD modifiers = $2;
1790
1791                                 if (!(type = apply_type_modifiers($3, &modifiers, get_location(&@2))))
1792                                     YYABORT;
1793
1794                                 $$.modifiers = $1 ? $1 : HLSL_STORAGE_IN;
1795                                 $$.modifiers |= modifiers;
1796                                 $$.type = type;
1797                                 $$.name = $4;
1798                                 $$.semantic = $5.semantic;
1799                                 $$.reg_reservation = $5.reg_reservation;
1800                             }
1801
1802 input_mods:               /* Empty */
1803                             {
1804                                 $$ = 0;
1805                             }
1806                         | input_mods input_mod
1807                             {
1808                                 if ($1 & $2)
1809                                 {
1810                                     hlsl_report_message(get_location(&@2), HLSL_LEVEL_ERROR,
1811                                             "duplicate input-output modifiers");
1812                                     YYABORT;
1813                                 }
1814                                 $$ = $1 | $2;
1815                             }
1816
1817 input_mod:                KW_IN
1818                             {
1819                                 $$ = HLSL_STORAGE_IN;
1820                             }
1821                         | KW_OUT
1822                             {
1823                                 $$ = HLSL_STORAGE_OUT;
1824                             }
1825                         | KW_INOUT
1826                             {
1827                                 $$ = HLSL_STORAGE_IN | HLSL_STORAGE_OUT;
1828                             }
1829
1830 type:
1831
1832       base_type
1833         {
1834             $$ = $1;
1835         }
1836     | KW_VECTOR '<' base_type ',' C_INTEGER '>'
1837         {
1838             if ($3->type != HLSL_CLASS_SCALAR)
1839             {
1840                 hlsl_report_message(get_location(&@3), HLSL_LEVEL_ERROR,
1841                         "vectors of non-scalar types are not allowed\n");
1842                 YYABORT;
1843             }
1844             if ($5 < 1 || $5 > 4)
1845             {
1846                 hlsl_report_message(get_location(&@5), HLSL_LEVEL_ERROR,
1847                         "vector size must be between 1 and 4\n");
1848                 YYABORT;
1849             }
1850
1851             $$ = new_hlsl_type(NULL, HLSL_CLASS_VECTOR, $3->base_type, $5, 1);
1852         }
1853     | KW_MATRIX '<' base_type ',' C_INTEGER ',' C_INTEGER '>'
1854         {
1855             if ($3->type != HLSL_CLASS_SCALAR)
1856             {
1857                 hlsl_report_message(get_location(&@3), HLSL_LEVEL_ERROR,
1858                         "matrices of non-scalar types are not allowed\n");
1859                 YYABORT;
1860             }
1861             if ($5 < 1 || $5 > 4)
1862             {
1863                 hlsl_report_message(get_location(&@5), HLSL_LEVEL_ERROR,
1864                         "matrix row count must be between 1 and 4\n");
1865                 YYABORT;
1866             }
1867             if ($7 < 1 || $7 > 4)
1868             {
1869                 hlsl_report_message(get_location(&@7), HLSL_LEVEL_ERROR,
1870                         "matrix column count must be between 1 and 4\n");
1871                 YYABORT;
1872             }
1873
1874             $$ = new_hlsl_type(NULL, HLSL_CLASS_MATRIX, $3->base_type, $7, $5);
1875         }
1876
1877 base_type:
1878
1879       KW_VOID
1880         {
1881             $$ = hlsl_ctx.builtin_types.Void;
1882         }
1883     | KW_SAMPLER
1884         {
1885             $$ = hlsl_ctx.builtin_types.sampler[HLSL_SAMPLER_DIM_GENERIC];
1886         }
1887     | KW_SAMPLER1D
1888         {
1889             $$ = hlsl_ctx.builtin_types.sampler[HLSL_SAMPLER_DIM_1D];
1890         }
1891     | KW_SAMPLER2D
1892         {
1893             $$ = hlsl_ctx.builtin_types.sampler[HLSL_SAMPLER_DIM_2D];
1894         }
1895     | KW_SAMPLER3D
1896         {
1897             $$ = hlsl_ctx.builtin_types.sampler[HLSL_SAMPLER_DIM_3D];
1898         }
1899     | KW_SAMPLERCUBE
1900         {
1901             $$ = hlsl_ctx.builtin_types.sampler[HLSL_SAMPLER_DIM_3D];
1902         }
1903     | TYPE_IDENTIFIER
1904         {
1905             $$ = get_type(hlsl_ctx.cur_scope, $1, TRUE);
1906             d3dcompiler_free($1);
1907         }
1908     | KW_STRUCT TYPE_IDENTIFIER
1909         {
1910             $$ = get_type(hlsl_ctx.cur_scope, $2, TRUE);
1911             if ($$->type != HLSL_CLASS_STRUCT)
1912                 hlsl_report_message(get_location(&@1), HLSL_LEVEL_ERROR, "'%s' redefined as a structure\n", $2);
1913             d3dcompiler_free($2);
1914         }
1915
1916 declaration_statement:    declaration
1917                         | struct_declaration
1918                         | typedef
1919                             {
1920                                 $$ = d3dcompiler_alloc(sizeof(*$$));
1921                                 if (!$$)
1922                                 {
1923                                     ERR("Out of memory\n");
1924                                     YYABORT;
1925                                 }
1926                                 list_init($$);
1927                             }
1928
1929 typedef_type:             type
1930                         | struct_spec
1931
1932 typedef:                  KW_TYPEDEF var_modifiers typedef_type type_specs ';'
1933                             {
1934                                 if ($2 & ~HLSL_TYPE_MODIFIERS_MASK)
1935                                 {
1936                                     struct parse_variable_def *v, *v_next;
1937                                     hlsl_report_message(get_location(&@1),
1938                                             HLSL_LEVEL_ERROR, "modifier not allowed on typedefs");
1939                                     LIST_FOR_EACH_ENTRY_SAFE(v, v_next, $4, struct parse_variable_def, entry)
1940                                         d3dcompiler_free(v);
1941                                     d3dcompiler_free($4);
1942                                     YYABORT;
1943                                 }
1944                                 if (!add_typedef($2, $3, $4))
1945                                     YYABORT;
1946                             }
1947
1948 type_specs:               type_spec
1949                             {
1950                                 $$ = d3dcompiler_alloc(sizeof(*$$));
1951                                 list_init($$);
1952                                 list_add_head($$, &$1->entry);
1953                             }
1954                         | type_specs ',' type_spec
1955                             {
1956                                 $$ = $1;
1957                                 list_add_tail($$, &$3->entry);
1958                             }
1959
1960 type_spec:                any_identifier array
1961                             {
1962                                 $$ = d3dcompiler_alloc(sizeof(*$$));
1963                                 $$->loc = get_location(&@1);
1964                                 $$->name = $1;
1965                                 $$->array_size = $2;
1966                             }
1967
1968 declaration:              var_modifiers type variables_def ';'
1969                             {
1970                                 struct hlsl_type *type;
1971                                 DWORD modifiers = $1;
1972
1973                                 if (!(type = apply_type_modifiers($2, &modifiers, get_location(&@1))))
1974                                     YYABORT;
1975                                 $$ = declare_vars(type, modifiers, $3);
1976                             }
1977
1978 variables_def_optional:   /* Empty */
1979                             {
1980                                 $$ = NULL;
1981                             }
1982                         | variables_def
1983                             {
1984                                 $$ = $1;
1985                             }
1986
1987 variables_def:            variable_def
1988                             {
1989                                 $$ = d3dcompiler_alloc(sizeof(*$$));
1990                                 list_init($$);
1991                                 list_add_head($$, &$1->entry);
1992                             }
1993                         | variables_def ',' variable_def
1994                             {
1995                                 $$ = $1;
1996                                 list_add_tail($$, &$3->entry);
1997                             }
1998
1999 variable_def:             any_identifier array colon_attribute
2000                             {
2001                                 $$ = d3dcompiler_alloc(sizeof(*$$));
2002                                 $$->loc = get_location(&@1);
2003                                 $$->name = $1;
2004                                 $$->array_size = $2;
2005                                 $$->semantic = $3.semantic;
2006                                 $$->reg_reservation = $3.reg_reservation;
2007                             }
2008                         | any_identifier array colon_attribute '=' complex_initializer
2009                             {
2010                                 TRACE("Declaration with initializer.\n");
2011                                 $$ = d3dcompiler_alloc(sizeof(*$$));
2012                                 $$->loc = get_location(&@1);
2013                                 $$->name = $1;
2014                                 $$->array_size = $2;
2015                                 $$->semantic = $3.semantic;
2016                                 $$->reg_reservation = $3.reg_reservation;
2017                                 $$->initializer = $5;
2018                             }
2019
2020 array:                    /* Empty */
2021                             {
2022                                 $$ = 0;
2023                             }
2024                         | '[' expr ']'
2025                             {
2026                                 unsigned int size = evaluate_array_dimension(node_from_list($2));
2027
2028                                 free_instr_list($2);
2029
2030                                 if (!size)
2031                                 {
2032                                     hlsl_report_message(get_location(&@2), HLSL_LEVEL_ERROR,
2033                                             "array size is not a positive integer constant\n");
2034                                     YYABORT;
2035                                 }
2036                                 TRACE("Array size %u.\n", size);
2037
2038                                 if (size > 65536)
2039                                 {
2040                                     hlsl_report_message(get_location(&@2), HLSL_LEVEL_ERROR,
2041                                             "array size must be between 1 and 65536");
2042                                     YYABORT;
2043                                 }
2044                                 $$ = size;
2045                             }
2046
2047 var_modifiers:            /* Empty */
2048                             {
2049                                 $$ = 0;
2050                             }
2051                         | KW_EXTERN var_modifiers
2052                             {
2053                                 $$ = add_modifiers($2, HLSL_STORAGE_EXTERN, get_location(&@1));
2054                             }
2055                         | KW_NOINTERPOLATION var_modifiers
2056                             {
2057                                 $$ = add_modifiers($2, HLSL_STORAGE_NOINTERPOLATION, get_location(&@1));
2058                             }
2059                         | KW_PRECISE var_modifiers
2060                             {
2061                                 $$ = add_modifiers($2, HLSL_MODIFIER_PRECISE, get_location(&@1));
2062                             }
2063                         | KW_SHARED var_modifiers
2064                             {
2065                                 $$ = add_modifiers($2, HLSL_STORAGE_SHARED, get_location(&@1));
2066                             }
2067                         | KW_GROUPSHARED var_modifiers
2068                             {
2069                                 $$ = add_modifiers($2, HLSL_STORAGE_GROUPSHARED, get_location(&@1));
2070                             }
2071                         | KW_STATIC var_modifiers
2072                             {
2073                                 $$ = add_modifiers($2, HLSL_STORAGE_STATIC, get_location(&@1));
2074                             }
2075                         | KW_UNIFORM var_modifiers
2076                             {
2077                                 $$ = add_modifiers($2, HLSL_STORAGE_UNIFORM, get_location(&@1));
2078                             }
2079                         | KW_VOLATILE var_modifiers
2080                             {
2081                                 $$ = add_modifiers($2, HLSL_STORAGE_VOLATILE, get_location(&@1));
2082                             }
2083                         | KW_CONST var_modifiers
2084                             {
2085                                 $$ = add_modifiers($2, HLSL_MODIFIER_CONST, get_location(&@1));
2086                             }
2087                         | KW_ROW_MAJOR var_modifiers
2088                             {
2089                                 $$ = add_modifiers($2, HLSL_MODIFIER_ROW_MAJOR, get_location(&@1));
2090                             }
2091                         | KW_COLUMN_MAJOR var_modifiers
2092                             {
2093                                 $$ = add_modifiers($2, HLSL_MODIFIER_COLUMN_MAJOR, get_location(&@1));
2094                             }
2095
2096 complex_initializer:      initializer_expr
2097                             {
2098                                 $$.args_count = 1;
2099                                 if (!($$.args = d3dcompiler_alloc(sizeof(*$$.args))))
2100                                     YYABORT;
2101                                 $$.args[0] = node_from_list($1);
2102                                 $$.instrs = $1;
2103                             }
2104                         | '{' initializer_expr_list '}'
2105                             {
2106                                 $$ = $2;
2107                             }
2108                         | '{' initializer_expr_list ',' '}'
2109                             {
2110                                 $$ = $2;
2111                             }
2112
2113 initializer_expr:         assignment_expr
2114                             {
2115                                 $$ = $1;
2116                             }
2117
2118 initializer_expr_list:    initializer_expr
2119                             {
2120                                 $$.args_count = 1;
2121                                 if (!($$.args = d3dcompiler_alloc(sizeof(*$$.args))))
2122                                     YYABORT;
2123                                 $$.args[0] = node_from_list($1);
2124                                 $$.instrs = $1;
2125                             }
2126                         | initializer_expr_list ',' initializer_expr
2127                             {
2128                                 $$ = $1;
2129                                 if (!($$.args = d3dcompiler_realloc($$.args, ($$.args_count + 1) * sizeof(*$$.args))))
2130                                     YYABORT;
2131                                 $$.args[$$.args_count++] = node_from_list($3);
2132                                 list_move_tail($$.instrs, $3);
2133                                 d3dcompiler_free($3);
2134                             }
2135
2136 boolean:                  KW_TRUE
2137                             {
2138                                 $$ = TRUE;
2139                             }
2140                         | KW_FALSE
2141                             {
2142                                 $$ = FALSE;
2143                             }
2144
2145 statement_list:           statement
2146                             {
2147                                 $$ = $1;
2148                             }
2149                         | statement_list statement
2150                             {
2151                                 $$ = $1;
2152                                 list_move_tail($$, $2);
2153                                 d3dcompiler_free($2);
2154                             }
2155
2156 statement:                declaration_statement
2157                         | expr_statement
2158                         | compound_statement
2159                         | jump_statement
2160                         | selection_statement
2161                         | loop_statement
2162
2163 jump_statement:           KW_RETURN expr ';'
2164                             {
2165                                 struct hlsl_ir_jump *jump;
2166                                 if (!(jump = new_return(node_from_list($2), get_location(&@1))))
2167                                     YYABORT;
2168
2169                                 $$ = $2;
2170                                 list_add_tail($$, &jump->node.entry);
2171                             }
2172                         | KW_RETURN ';'
2173                             {
2174                                 struct hlsl_ir_jump *jump;
2175                                 if (!(jump = new_return(NULL, get_location(&@1))))
2176                                     YYABORT;
2177                                 $$ = d3dcompiler_alloc(sizeof(*$$));
2178                                 list_init($$);
2179                                 list_add_tail($$, &jump->node.entry);
2180                             }
2181
2182 selection_statement:      KW_IF '(' expr ')' if_body
2183                             {
2184                                 struct hlsl_ir_if *instr = d3dcompiler_alloc(sizeof(*instr));
2185                                 if (!instr)
2186                                 {
2187                                     ERR("Out of memory\n");
2188                                     YYABORT;
2189                                 }
2190                                 init_node(&instr->node, HLSL_IR_IF, NULL, get_location(&@1));
2191                                 instr->condition = node_from_list($3);
2192                                 instr->then_instrs = $5.then_instrs;
2193                                 instr->else_instrs = $5.else_instrs;
2194                                 if (instr->condition->data_type->dimx > 1 || instr->condition->data_type->dimy > 1)
2195                                 {
2196                                     hlsl_report_message(instr->node.loc, HLSL_LEVEL_ERROR,
2197                                             "if condition requires a scalar");
2198                                 }
2199                                 $$ = $3;
2200                                 list_add_tail($$, &instr->node.entry);
2201                             }
2202
2203 if_body:                  statement
2204                             {
2205                                 $$.then_instrs = $1;
2206                                 $$.else_instrs = NULL;
2207                             }
2208                         | statement KW_ELSE statement
2209                             {
2210                                 $$.then_instrs = $1;
2211                                 $$.else_instrs = $3;
2212                             }
2213
2214 loop_statement:           KW_WHILE '(' expr ')' statement
2215                             {
2216                                 $$ = create_loop(LOOP_WHILE, NULL, $3, NULL, $5, get_location(&@1));
2217                             }
2218                         | KW_DO statement KW_WHILE '(' expr ')' ';'
2219                             {
2220                                 $$ = create_loop(LOOP_DO_WHILE, NULL, $5, NULL, $2, get_location(&@1));
2221                             }
2222                         | KW_FOR '(' scope_start expr_statement expr_statement expr ')' statement
2223                             {
2224                                 $$ = create_loop(LOOP_FOR, $4, $5, $6, $8, get_location(&@1));
2225                                 pop_scope(&hlsl_ctx);
2226                             }
2227                         | KW_FOR '(' scope_start declaration expr_statement expr ')' statement
2228                             {
2229                                 if (!$4)
2230                                     hlsl_report_message(get_location(&@4), HLSL_LEVEL_WARNING,
2231                                             "no expressions in for loop initializer");
2232                                 $$ = create_loop(LOOP_FOR, $4, $5, $6, $8, get_location(&@1));
2233                                 pop_scope(&hlsl_ctx);
2234                             }
2235
2236 expr_statement:           ';'
2237                             {
2238                                 $$ = d3dcompiler_alloc(sizeof(*$$));
2239                                 list_init($$);
2240                             }
2241                         | expr ';'
2242                             {
2243                                 $$ = $1;
2244                             }
2245
2246 primary_expr:             C_FLOAT
2247                             {
2248                                 struct hlsl_ir_constant *c = d3dcompiler_alloc(sizeof(*c));
2249                                 if (!c)
2250                                 {
2251                                     ERR("Out of memory.\n");
2252                                     YYABORT;
2253                                 }
2254                                 init_node(&c->node, HLSL_IR_CONSTANT,
2255                                         hlsl_ctx.builtin_types.scalar[HLSL_TYPE_FLOAT], get_location(&@1));
2256                                 c->v.value.f[0] = $1;
2257                                 if (!($$ = make_list(&c->node)))
2258                                     YYABORT;
2259                             }
2260                         | C_INTEGER
2261                             {
2262                                 struct hlsl_ir_constant *c = d3dcompiler_alloc(sizeof(*c));
2263                                 if (!c)
2264                                 {
2265                                     ERR("Out of memory.\n");
2266                                     YYABORT;
2267                                 }
2268                                 init_node(&c->node, HLSL_IR_CONSTANT,
2269                                         hlsl_ctx.builtin_types.scalar[HLSL_TYPE_INT], get_location(&@1));
2270                                 c->v.value.i[0] = $1;
2271                                 if (!($$ = make_list(&c->node)))
2272                                     YYABORT;
2273                             }
2274                         | boolean
2275                             {
2276                                 struct hlsl_ir_constant *c = d3dcompiler_alloc(sizeof(*c));
2277                                 if (!c)
2278                                 {
2279                                     ERR("Out of memory.\n");
2280                                     YYABORT;
2281                                 }
2282                                 init_node(&c->node, HLSL_IR_CONSTANT,
2283                                         hlsl_ctx.builtin_types.scalar[HLSL_TYPE_BOOL], get_location(&@1));
2284                                 c->v.value.b[0] = $1;
2285                                 if (!($$ = make_list(&c->node)))
2286                                     YYABORT;
2287                             }
2288                         | VAR_IDENTIFIER
2289                             {
2290                                 struct hlsl_ir_load *load;
2291                                 struct hlsl_ir_var *var;
2292
2293                                 if (!(var = get_variable(hlsl_ctx.cur_scope, $1)))
2294                                 {
2295                                     hlsl_report_message(get_location(&@1), HLSL_LEVEL_ERROR,
2296                                             "variable '%s' is not declared\n", $1);
2297                                     YYABORT;
2298                                 }
2299                                 if ((load = new_var_load(var, get_location(&@1))))
2300                                 {
2301                                     if (!($$ = make_list(&load->node)))
2302                                         YYABORT;
2303                                 }
2304                                 else
2305                                     $$ = NULL;
2306                             }
2307                         | '(' expr ')'
2308                             {
2309                                 $$ = $2;
2310                             }
2311
2312 postfix_expr:             primary_expr
2313                             {
2314                                 $$ = $1;
2315                             }
2316                         | postfix_expr OP_INC
2317                             {
2318                                 struct source_location loc;
2319                                 struct hlsl_ir_node *inc;
2320
2321                                 loc = get_location(&@2);
2322                                 if (node_from_list($1)->data_type->modifiers & HLSL_MODIFIER_CONST)
2323                                 {
2324                                     hlsl_report_message(loc, HLSL_LEVEL_ERROR, "modifying a const expression");
2325                                     YYABORT;
2326                                 }
2327                                 inc = new_unary_expr(HLSL_IR_UNOP_POSTINC, node_from_list($1), loc);
2328                                 /* Post increment/decrement expressions are considered const */
2329                                 inc->data_type = clone_hlsl_type(inc->data_type, 0);
2330                                 inc->data_type->modifiers |= HLSL_MODIFIER_CONST;
2331                                 $$ = append_unop($1, inc);
2332                             }
2333                         | postfix_expr OP_DEC
2334                             {
2335                                 struct source_location loc;
2336                                 struct hlsl_ir_node *inc;
2337
2338                                 loc = get_location(&@2);
2339                                 if (node_from_list($1)->data_type->modifiers & HLSL_MODIFIER_CONST)
2340                                 {
2341                                     hlsl_report_message(loc, HLSL_LEVEL_ERROR, "modifying a const expression");
2342                                     YYABORT;
2343                                 }
2344                                 inc = new_unary_expr(HLSL_IR_UNOP_POSTDEC, node_from_list($1), loc);
2345                                 /* Post increment/decrement expressions are considered const */
2346                                 inc->data_type = clone_hlsl_type(inc->data_type, 0);
2347                                 inc->data_type->modifiers |= HLSL_MODIFIER_CONST;
2348                                 $$ = append_unop($1, inc);
2349                             }
2350                         | postfix_expr '.' any_identifier
2351                             {
2352                                 struct hlsl_ir_node *node = node_from_list($1);
2353                                 struct source_location loc;
2354
2355                                 loc = get_location(&@2);
2356                                 if (node->data_type->type == HLSL_CLASS_STRUCT)
2357                                 {
2358                                     struct hlsl_type *type = node->data_type;
2359                                     struct hlsl_struct_field *field;
2360
2361                                     $$ = NULL;
2362                                     LIST_FOR_EACH_ENTRY(field, type->e.elements, struct hlsl_struct_field, entry)
2363                                     {
2364                                         if (!strcmp($3, field->name))
2365                                         {
2366                                             if (!new_record_load(node, field, loc))
2367                                                 YYABORT;
2368                                             $$ = $1;
2369                                             break;
2370                                         }
2371                                     }
2372                                     if (!$$)
2373                                     {
2374                                         hlsl_report_message(loc, HLSL_LEVEL_ERROR,
2375                                                 "invalid subscript %s", debugstr_a($3));
2376                                         YYABORT;
2377                                     }
2378                                 }
2379                                 else if (node->data_type->type <= HLSL_CLASS_LAST_NUMERIC)
2380                                 {
2381                                     struct hlsl_ir_swizzle *swizzle;
2382
2383                                     swizzle = get_swizzle(node, $3, &loc);
2384                                     if (!swizzle)
2385                                     {
2386                                         hlsl_report_message(loc, HLSL_LEVEL_ERROR,
2387                                                 "invalid swizzle %s", debugstr_a($3));
2388                                         YYABORT;
2389                                     }
2390                                     $$ = append_unop($1, &swizzle->node);
2391                                 }
2392                                 else
2393                                 {
2394                                     hlsl_report_message(loc, HLSL_LEVEL_ERROR,
2395                                             "invalid subscript %s", debugstr_a($3));
2396                                     YYABORT;
2397                                 }
2398                             }
2399                         | postfix_expr '[' expr ']'
2400                             {
2401                                 struct hlsl_ir_load *load;
2402
2403                                 if (node_from_list($3)->data_type->type != HLSL_CLASS_SCALAR)
2404                                 {
2405                                     hlsl_report_message(get_location(&@3), HLSL_LEVEL_ERROR, "array index is not scalar");
2406                                     free_instr_list($1);
2407                                     free_instr_list($3);
2408                                     YYABORT;
2409                                 }
2410
2411                                 if (!(load = new_array_load(node_from_list($1), node_from_list($3), get_location(&@2))))
2412                                 {
2413                                     free_instr_list($1);
2414                                     free_instr_list($3);
2415                                     YYABORT;
2416                                 }
2417                                 $$ = append_binop($1, $3, &load->node);
2418                             }
2419                           /* "var_modifiers" doesn't make sense in this case, but it's needed
2420                              in the grammar to avoid shift/reduce conflicts. */
2421                         | var_modifiers type '(' initializer_expr_list ')'
2422                             {
2423                                 struct hlsl_ir_constructor *constructor;
2424
2425                                 TRACE("%s constructor.\n", debug_hlsl_type($2));
2426                                 if ($1)
2427                                 {
2428                                     hlsl_report_message(get_location(&@1), HLSL_LEVEL_ERROR,
2429                                             "unexpected modifier on a constructor\n");
2430                                     YYABORT;
2431                                 }
2432                                 if ($2->type > HLSL_CLASS_LAST_NUMERIC)
2433                                 {
2434                                     hlsl_report_message(get_location(&@2), HLSL_LEVEL_ERROR,
2435                                             "constructors may only be used with numeric data types\n");
2436                                     YYABORT;
2437                                 }
2438                                 if ($2->dimx * $2->dimy != initializer_size(&$4))
2439                                 {
2440                                     hlsl_report_message(get_location(&@4), HLSL_LEVEL_ERROR,
2441                                             "expected %u components in constructor, but got %u\n",
2442                                             $2->dimx * $2->dimy, initializer_size(&$4));
2443                                     YYABORT;
2444                                 }
2445                                 assert($4.args_count <= ARRAY_SIZE(constructor->args));
2446
2447                                 constructor = d3dcompiler_alloc(sizeof(*constructor));
2448                                 init_node(&constructor->node, HLSL_IR_CONSTRUCTOR, $2, get_location(&@3));
2449                                 constructor->args_count = $4.args_count;
2450                                 memcpy(constructor->args, $4.args, $4.args_count * sizeof(*$4.args));
2451                                 d3dcompiler_free($4.args);
2452                                 $$ = append_unop($4.instrs, &constructor->node);
2453                             }
2454
2455 unary_expr:               postfix_expr
2456                             {
2457                                 $$ = $1;
2458                             }
2459                         | OP_INC unary_expr
2460                             {
2461                                 struct source_location loc;
2462
2463                                 loc = get_location(&@1);
2464                                 if (node_from_list($2)->data_type->modifiers & HLSL_MODIFIER_CONST)
2465                                 {
2466                                     hlsl_report_message(loc, HLSL_LEVEL_ERROR, "modifying a const expression");
2467                                     YYABORT;
2468                                 }
2469                                 $$ = append_unop($2, new_unary_expr(HLSL_IR_UNOP_PREINC, node_from_list($2), loc));
2470                             }
2471                         | OP_DEC unary_expr
2472                             {
2473                                 struct source_location loc;
2474
2475                                 loc = get_location(&@1);
2476                                 if (node_from_list($2)->data_type->modifiers & HLSL_MODIFIER_CONST)
2477                                 {
2478                                     hlsl_report_message(loc, HLSL_LEVEL_ERROR, "modifying a const expression");
2479                                     YYABORT;
2480                                 }
2481                                 $$ = append_unop($2, new_unary_expr(HLSL_IR_UNOP_PREDEC, node_from_list($2), loc));
2482                             }
2483                         | unary_op unary_expr
2484                             {
2485                                 enum hlsl_ir_expr_op ops[] = {0, HLSL_IR_UNOP_NEG,
2486                                         HLSL_IR_UNOP_LOGIC_NOT, HLSL_IR_UNOP_BIT_NOT};
2487
2488                                 if ($1 == UNARY_OP_PLUS)
2489                                 {
2490                                     $$ = $2;
2491                                 }
2492                                 else
2493                                 {
2494                                     $$ = append_unop($2, new_unary_expr(ops[$1], node_from_list($2), get_location(&@1)));
2495                                 }
2496                             }
2497                           /* var_modifiers just to avoid shift/reduce conflicts */
2498                         | '(' var_modifiers type array ')' unary_expr
2499                             {
2500                                 struct hlsl_type *src_type = node_from_list($6)->data_type;
2501                                 struct hlsl_type *dst_type;
2502                                 struct source_location loc;
2503
2504                                 loc = get_location(&@3);
2505                                 if ($2)
2506                                 {
2507                                     hlsl_report_message(loc, HLSL_LEVEL_ERROR, "unexpected modifier in a cast");
2508                                     YYABORT;
2509                                 }
2510
2511                                 if ($4)
2512                                     dst_type = new_array_type($3, $4);
2513                                 else
2514                                     dst_type = $3;
2515
2516                                 if (!compatible_data_types(src_type, dst_type))
2517                                 {
2518                                     hlsl_report_message(loc, HLSL_LEVEL_ERROR, "can't cast from %s to %s",
2519                                             debug_hlsl_type(src_type), debug_hlsl_type(dst_type));
2520                                     YYABORT;
2521                                 }
2522
2523                                 $$ = append_unop($6, &new_cast(node_from_list($6), dst_type, &loc)->node);
2524                             }
2525
2526 unary_op:                 '+'
2527                             {
2528                                 $$ = UNARY_OP_PLUS;
2529                             }
2530                         | '-'
2531                             {
2532                                 $$ = UNARY_OP_MINUS;
2533                             }
2534                         | '!'
2535                             {
2536                                 $$ = UNARY_OP_LOGICNOT;
2537                             }
2538                         | '~'
2539                             {
2540                                 $$ = UNARY_OP_BITNOT;
2541                             }
2542
2543 mul_expr:                 unary_expr
2544                             {
2545                                 $$ = $1;
2546                             }
2547                         | mul_expr '*' unary_expr
2548                             {
2549                                 $$ = append_binop($1, $3, new_binary_expr(HLSL_IR_BINOP_MUL,
2550                                         node_from_list($1), node_from_list($3), get_location(&@2)));
2551                             }
2552                         | mul_expr '/' unary_expr
2553                             {
2554                                 $$ = append_binop($1, $3, new_binary_expr(HLSL_IR_BINOP_DIV,
2555                                         node_from_list($1), node_from_list($3), get_location(&@2)));
2556                             }
2557                         | mul_expr '%' unary_expr
2558                             {
2559                                 $$ = append_binop($1, $3, new_binary_expr(HLSL_IR_BINOP_MOD,
2560                                         node_from_list($1), node_from_list($3), get_location(&@2)));
2561                             }
2562
2563 add_expr:                 mul_expr
2564                             {
2565                                 $$ = $1;
2566                             }
2567                         | add_expr '+' mul_expr
2568                             {
2569                                 $$ = append_binop($1, $3, new_binary_expr(HLSL_IR_BINOP_ADD,
2570                                         node_from_list($1), node_from_list($3), get_location(&@2)));
2571                             }
2572                         | add_expr '-' mul_expr
2573                             {
2574                                 $$ = append_binop($1, $3, new_binary_expr(HLSL_IR_BINOP_SUB,
2575                                         node_from_list($1), node_from_list($3), get_location(&@2)));
2576                             }
2577
2578 shift_expr:               add_expr
2579                             {
2580                                 $$ = $1;
2581                             }
2582                         | shift_expr OP_LEFTSHIFT add_expr
2583                             {
2584                                 FIXME("Left shift\n");
2585                             }
2586                         | shift_expr OP_RIGHTSHIFT add_expr
2587                             {
2588                                 FIXME("Right shift\n");
2589                             }
2590
2591 relational_expr:          shift_expr
2592                             {
2593                                 $$ = $1;
2594                             }
2595                         | relational_expr '<' shift_expr
2596                             {
2597                                 $$ = append_binop($1, $3, new_binary_expr(HLSL_IR_BINOP_LESS,
2598                                         node_from_list($1), node_from_list($3), get_location(&@2)));
2599                             }
2600                         | relational_expr '>' shift_expr
2601                             {
2602                                 $$ = append_binop($1, $3, new_binary_expr(HLSL_IR_BINOP_GREATER,
2603                                         node_from_list($1), node_from_list($3), get_location(&@2)));
2604                             }
2605                         | relational_expr OP_LE shift_expr
2606                             {
2607                                 $$ = append_binop($1, $3, new_binary_expr(HLSL_IR_BINOP_LEQUAL,
2608                                         node_from_list($1), node_from_list($3), get_location(&@2)));
2609                             }
2610                         | relational_expr OP_GE shift_expr
2611                             {
2612                                 $$ = append_binop($1, $3, new_binary_expr(HLSL_IR_BINOP_GEQUAL,
2613                                         node_from_list($1), node_from_list($3), get_location(&@2)));
2614                             }
2615
2616 equality_expr:            relational_expr
2617                             {
2618                                 $$ = $1;
2619                             }
2620                         | equality_expr OP_EQ relational_expr
2621                             {
2622                                 $$ = append_binop($1, $3, new_binary_expr(HLSL_IR_BINOP_EQUAL,
2623                                         node_from_list($1), node_from_list($3), get_location(&@2)));
2624                             }
2625                         | equality_expr OP_NE relational_expr
2626                             {
2627                                 $$ = append_binop($1, $3, new_binary_expr(HLSL_IR_BINOP_NEQUAL,
2628                                         node_from_list($1), node_from_list($3), get_location(&@2)));
2629                             }
2630
2631 bitand_expr:              equality_expr
2632                             {
2633                                 $$ = $1;
2634                             }
2635                         | bitand_expr '&' equality_expr
2636                             {
2637                                 FIXME("bitwise AND\n");
2638                             }
2639
2640 bitxor_expr:              bitand_expr
2641                             {
2642                                 $$ = $1;
2643                             }
2644                         | bitxor_expr '^' bitand_expr
2645                             {
2646                                 FIXME("bitwise XOR\n");
2647                             }
2648
2649 bitor_expr:               bitxor_expr
2650                             {
2651                                 $$ = $1;
2652                             }
2653                         | bitor_expr '|' bitxor_expr
2654                             {
2655                                 FIXME("bitwise OR\n");
2656                             }
2657
2658 logicand_expr:            bitor_expr
2659                             {
2660                                 $$ = $1;
2661                             }
2662                         | logicand_expr OP_AND bitor_expr
2663                             {
2664                                 FIXME("logic AND\n");
2665                             }
2666
2667 logicor_expr:             logicand_expr
2668                             {
2669                                 $$ = $1;
2670                             }
2671                         | logicor_expr OP_OR logicand_expr
2672                             {
2673                                 FIXME("logic OR\n");
2674                             }
2675
2676 conditional_expr:         logicor_expr
2677                             {
2678                                 $$ = $1;
2679                             }
2680                         | logicor_expr '?' expr ':' assignment_expr
2681                             {
2682                                 FIXME("ternary operator\n");
2683                             }
2684
2685 assignment_expr:          conditional_expr
2686                             {
2687                                 $$ = $1;
2688                             }
2689                         | unary_expr assign_op assignment_expr
2690                             {
2691                                 struct hlsl_ir_node *instr;
2692
2693                                 if (node_from_list($1)->data_type->modifiers & HLSL_MODIFIER_CONST)
2694                                 {
2695                                     hlsl_report_message(get_location(&@2), HLSL_LEVEL_ERROR, "l-value is const");
2696                                     YYABORT;
2697                                 }
2698                                 if (!(instr = make_assignment(node_from_list($1), $2, node_from_list($3))))
2699                                     YYABORT;
2700                                 instr->loc = get_location(&@2);
2701                                 $$ = append_binop($3, $1, instr);
2702                             }
2703
2704 assign_op:                '='
2705                             {
2706                                 $$ = ASSIGN_OP_ASSIGN;
2707                             }
2708                         | OP_ADDASSIGN
2709                             {
2710                                 $$ = ASSIGN_OP_ADD;
2711                             }
2712                         | OP_SUBASSIGN
2713                             {
2714                                 $$ = ASSIGN_OP_SUB;
2715                             }
2716                         | OP_MULASSIGN
2717                             {
2718                                 $$ = ASSIGN_OP_MUL;
2719                             }
2720                         | OP_DIVASSIGN
2721                             {
2722                                 $$ = ASSIGN_OP_DIV;
2723                             }
2724                         | OP_MODASSIGN
2725                             {
2726                                 $$ = ASSIGN_OP_MOD;
2727                             }
2728                         | OP_LEFTSHIFTASSIGN
2729                             {
2730                                 $$ = ASSIGN_OP_LSHIFT;
2731                             }
2732                         | OP_RIGHTSHIFTASSIGN
2733                             {
2734                                 $$ = ASSIGN_OP_RSHIFT;
2735                             }
2736                         | OP_ANDASSIGN
2737                             {
2738                                 $$ = ASSIGN_OP_AND;
2739                             }
2740                         | OP_ORASSIGN
2741                             {
2742                                 $$ = ASSIGN_OP_OR;
2743                             }
2744                         | OP_XORASSIGN
2745                             {
2746                                 $$ = ASSIGN_OP_XOR;
2747                             }
2748
2749 expr:                     assignment_expr
2750                             {
2751                                 $$ = $1;
2752                             }
2753                         | expr ',' assignment_expr
2754                             {
2755                                 $$ = $1;
2756                                 list_move_tail($$, $3);
2757                                 d3dcompiler_free($3);
2758                             }
2759
2760 %%
2761
2762 static struct source_location get_location(const struct YYLTYPE *l)
2763 {
2764     const struct source_location loc =
2765     {
2766         .file = hlsl_ctx.source_file,
2767         .line = l->first_line,
2768         .col = l->first_column,
2769     };
2770     return loc;
2771 }
2772
2773 static void dump_function_decl(struct wine_rb_entry *entry, void *context)
2774 {
2775     struct hlsl_ir_function_decl *func = WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function_decl, entry);
2776     if (func->body)
2777         debug_dump_ir_function_decl(func);
2778 }
2779
2780 static void dump_function(struct wine_rb_entry *entry, void *context)
2781 {
2782     struct hlsl_ir_function *func = WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry);
2783     wine_rb_for_each_entry(&func->overloads, dump_function_decl, NULL);
2784 }
2785
2786 /* Allocate a unique, ordered index to each instruction, which will be used for
2787  * computing liveness ranges. */
2788 static unsigned int index_instructions(struct list *instrs, unsigned int index)
2789 {
2790     struct hlsl_ir_node *instr;
2791
2792     LIST_FOR_EACH_ENTRY(instr, instrs, struct hlsl_ir_node, entry)
2793     {
2794         instr->index = index++;
2795
2796         if (instr->type == HLSL_IR_IF)
2797         {
2798             struct hlsl_ir_if *iff = if_from_node(instr);
2799             index = index_instructions(iff->then_instrs, index);
2800             if (iff->else_instrs)
2801                 index = index_instructions(iff->else_instrs, index);
2802         }
2803         else if (instr->type == HLSL_IR_LOOP)
2804         {
2805             index = index_instructions(loop_from_node(instr)->body, index);
2806             loop_from_node(instr)->next_index = index;
2807         }
2808     }
2809
2810     return index;
2811 }
2812
2813 /* Compute the earliest and latest liveness for each variable. In the case that
2814  * a variable is accessed inside of a loop, we promote its liveness to extend
2815  * to at least the range of the entire loop. Note that we don't need to do this
2816  * for anonymous nodes, since there's currently no way to use a node which was
2817  * calculated in an earlier iteration of the loop. */
2818 static void compute_liveness_recurse(struct list *instrs, unsigned int loop_first, unsigned int loop_last)
2819 {
2820     struct hlsl_ir_node *instr;
2821     struct hlsl_ir_var *var;
2822
2823     LIST_FOR_EACH_ENTRY(instr, instrs, struct hlsl_ir_node, entry)
2824     {
2825         switch (instr->type)
2826         {
2827         case HLSL_IR_ASSIGNMENT:
2828         {
2829             struct hlsl_ir_assignment *assignment = assignment_from_node(instr);
2830             var = assignment->lhs.var;
2831             if (!var->first_write)
2832                 var->first_write = loop_first ? min(instr->index, loop_first) : instr->index;
2833             assignment->rhs->last_read = instr->index;
2834             if (assignment->lhs.offset)
2835                 assignment->lhs.offset->last_read = instr->index;
2836             break;
2837         }
2838         case HLSL_IR_CONSTRUCTOR:
2839         {
2840             struct hlsl_ir_constructor *constructor = constructor_from_node(instr);
2841             unsigned int i;
2842             for (i = 0; i < constructor->args_count; ++i)
2843                 constructor->args[i]->last_read = instr->index;
2844             break;
2845         }
2846         case HLSL_IR_EXPR:
2847         {
2848             struct hlsl_ir_expr *expr = expr_from_node(instr);
2849             expr->operands[0]->last_read = instr->index;
2850             if (expr->operands[1])
2851                 expr->operands[1]->last_read = instr->index;
2852             if (expr->operands[2])
2853                 expr->operands[2]->last_read = instr->index;
2854             break;
2855         }
2856         case HLSL_IR_IF:
2857         {
2858             struct hlsl_ir_if *iff = if_from_node(instr);
2859             compute_liveness_recurse(iff->then_instrs, loop_first, loop_last);
2860             if (iff->else_instrs)
2861                 compute_liveness_recurse(iff->else_instrs, loop_first, loop_last);
2862             iff->condition->last_read = instr->index;
2863             break;
2864         }
2865         case HLSL_IR_LOAD:
2866         {
2867             struct hlsl_ir_load *load = load_from_node(instr);
2868             var = load->src.var;
2869             var->last_read = loop_last ? max(instr->index, loop_last) : instr->index;
2870             if (load->src.offset)
2871                 load->src.offset->last_read = instr->index;
2872             break;
2873         }
2874         case HLSL_IR_LOOP:
2875         {
2876             struct hlsl_ir_loop *loop = loop_from_node(instr);
2877             compute_liveness_recurse(loop->body, loop_first ? loop_first : instr->index,
2878                     loop_last ? loop_last : loop->next_index);
2879             break;
2880         }
2881         case HLSL_IR_SWIZZLE:
2882         {
2883             struct hlsl_ir_swizzle *swizzle = swizzle_from_node(instr);
2884             swizzle->val->last_read = instr->index;
2885             break;
2886         }
2887         case HLSL_IR_CONSTANT:
2888         case HLSL_IR_JUMP:
2889             break;
2890         }
2891     }
2892 }
2893
2894 static void compute_liveness(struct hlsl_ir_function_decl *entry_func)
2895 {
2896     struct hlsl_ir_var *var;
2897
2898     LIST_FOR_EACH_ENTRY(var, &hlsl_ctx.globals->vars, struct hlsl_ir_var, scope_entry)
2899     {
2900         var->first_write = 1;
2901     }
2902
2903     LIST_FOR_EACH_ENTRY(var, entry_func->parameters, struct hlsl_ir_var, param_entry)
2904     {
2905         if (var->modifiers & HLSL_STORAGE_IN)
2906             var->first_write = 1;
2907         if (var->modifiers & HLSL_STORAGE_OUT)
2908             var->last_read = UINT_MAX;
2909     }
2910
2911     if (entry_func->return_var)
2912         entry_func->return_var->last_read = UINT_MAX;
2913
2914     compute_liveness_recurse(entry_func->body, 0, 0);
2915 }
2916
2917 struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD major, DWORD minor,
2918         const char *entrypoint, char **messages)
2919 {
2920     struct hlsl_ir_function_decl *entry_func;
2921     struct hlsl_scope *scope, *next_scope;
2922     struct hlsl_type *hlsl_type, *next_type;
2923     struct hlsl_ir_var *var, *next_var;
2924     unsigned int i;
2925
2926     hlsl_ctx.status = PARSE_SUCCESS;
2927     hlsl_ctx.messages.size = hlsl_ctx.messages.capacity = 0;
2928     hlsl_ctx.line_no = hlsl_ctx.column = 1;
2929     hlsl_ctx.source_file = d3dcompiler_strdup("");
2930     hlsl_ctx.source_files = d3dcompiler_alloc(sizeof(*hlsl_ctx.source_files));
2931     if (hlsl_ctx.source_files)
2932         hlsl_ctx.source_files[0] = hlsl_ctx.source_file;
2933     hlsl_ctx.source_files_count = 1;
2934     hlsl_ctx.cur_scope = NULL;
2935     hlsl_ctx.matrix_majority = HLSL_COLUMN_MAJOR;
2936     list_init(&hlsl_ctx.scopes);
2937     list_init(&hlsl_ctx.types);
2938     init_functions_tree(&hlsl_ctx.functions);
2939
2940     push_scope(&hlsl_ctx);
2941     hlsl_ctx.globals = hlsl_ctx.cur_scope;
2942     declare_predefined_types(hlsl_ctx.globals);
2943
2944     hlsl_parse();
2945
2946     TRACE("Compilation status = %d\n", hlsl_ctx.status);
2947     if (messages)
2948     {
2949         if (hlsl_ctx.messages.size)
2950             *messages = hlsl_ctx.messages.string;
2951         else
2952             *messages = NULL;
2953     }
2954     else
2955     {
2956         if (hlsl_ctx.messages.capacity)
2957             d3dcompiler_free(hlsl_ctx.messages.string);
2958     }
2959
2960     for (i = 0; i < hlsl_ctx.source_files_count; ++i)
2961         d3dcompiler_free((void *)hlsl_ctx.source_files[i]);
2962     d3dcompiler_free(hlsl_ctx.source_files);
2963
2964     if (hlsl_ctx.status == PARSE_ERR)
2965         goto out;
2966
2967     if (!(entry_func = get_func_entry(entrypoint)))
2968     {
2969         hlsl_message("error: entry point %s is not defined\n", debugstr_a(entrypoint));
2970         goto out;
2971     }
2972
2973     /* Index 0 means unused; index 1 means function entry, so start at 2. */
2974     index_instructions(entry_func->body, 2);
2975
2976     if (TRACE_ON(hlsl_parser))
2977     {
2978         TRACE("IR dump.\n");
2979         wine_rb_for_each_entry(&hlsl_ctx.functions, dump_function, NULL);
2980     }
2981
2982     compute_liveness(entry_func);
2983
2984 out:
2985     TRACE("Freeing functions IR.\n");
2986     wine_rb_destroy(&hlsl_ctx.functions, free_function_rb, NULL);
2987
2988     TRACE("Freeing variables.\n");
2989     LIST_FOR_EACH_ENTRY_SAFE(scope, next_scope, &hlsl_ctx.scopes, struct hlsl_scope, entry)
2990     {
2991         LIST_FOR_EACH_ENTRY_SAFE(var, next_var, &scope->vars, struct hlsl_ir_var, scope_entry)
2992         {
2993             free_declaration(var);
2994         }
2995         wine_rb_destroy(&scope->types, NULL, NULL);
2996         d3dcompiler_free(scope);
2997     }
2998
2999     TRACE("Freeing types.\n");
3000     LIST_FOR_EACH_ENTRY_SAFE(hlsl_type, next_type, &hlsl_ctx.types, struct hlsl_type, entry)
3001     {
3002         free_hlsl_type(hlsl_type);
3003     }
3004
3005     return NULL;
3006 }