src/compiler/glsl/glsl_parser.yy

   1 %{
   2 /*
   3  * Copyright © 2008, 2009 Intel Corporation
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #ifndef _MSC_VER
  28 #include <strings.h>
  29 #endif
  30 #include <assert.h>
  31
  32 #include "ast.h"
  33 #include "glsl_parser_extras.h"
  34 #include "compiler/glsl_types.h"
  35 #include "main/context.h"
  36
  37 #ifdef _MSC_VER
  38 #pragma warning( disable : 4065 ) // switch statement contains 'default' but no 'case' labels
  39 #endif
  40
  41 #undef yyerror
  42
  43 static void yyerror(YYLTYPE *loc, _mesa_glsl_parse_state *st, const char *msg)
  44 {
  45    _mesa_glsl_error(loc, st, "%s", msg);
  46 }
  47
  48 static int
  49 _mesa_glsl_lex(YYSTYPE *val, YYLTYPE *loc, _mesa_glsl_parse_state *state)
  50 {
  51    return _mesa_glsl_lexer_lex(val, loc, state->scanner);
  52 }
  53
  54 static bool match_layout_qualifier(const char *s1, const char *s2,
  55                                    _mesa_glsl_parse_state *state)
  56 {
  57    /* From the GLSL 1.50 spec, section 4.3.8 (Layout Qualifiers):
  58     *
  59     *     "The tokens in any layout-qualifier-id-list ... are not case
  60     *     sensitive, unless explicitly noted otherwise."
  61     *
  62     * The text "unless explicitly noted otherwise" appears to be
  63     * vacuous--no desktop GLSL spec (up through GLSL 4.40) notes
  64     * otherwise.
  65     *
  66     * However, the GLSL ES 3.00 spec says, in section 4.3.8 (Layout
  67     * Qualifiers):
  68     *
  69     *     "As for other identifiers, they are case sensitive."
  70     *
  71     * So we need to do a case-sensitive or a case-insensitive match,
  72     * depending on whether we are compiling for GLSL ES.
  73     */
  74    if (state->es_shader)
  75       return strcmp(s1, s2);
  76    else
  77       return strcasecmp(s1, s2);
  78 }
  79 %}
  80
  81 %expect 0
  82
  83 %pure-parser
  84 %error-verbose
  85
  86 %locations
  87 %initial-action {
  88    @$.first_line = 1;
  89    @$.first_column = 1;
  90    @$.last_line = 1;
  91    @$.last_column = 1;
  92    @$.source = 0;
  93 }
  94
  95 %lex-param   {struct _mesa_glsl_parse_state *state}
  96 %parse-param {struct _mesa_glsl_parse_state *state}
  97
  98 %union {
  99    int n;
 100    int64_t n64;
 101    float real;
 102    double dreal;
 103    const char *identifier;
 104
 105    struct ast_type_qualifier type_qualifier;
 106
 107    ast_node *node;
 108    ast_type_specifier *type_specifier;
 109    ast_array_specifier *array_specifier;
 110    ast_fully_specified_type *fully_specified_type;
 111    ast_function *function;
 112    ast_parameter_declarator *parameter_declarator;
 113    ast_function_definition *function_definition;
 114    ast_compound_statement *compound_statement;
 115    ast_expression *expression;
 116    ast_declarator_list *declarator_list;
 117    ast_struct_specifier *struct_specifier;
 118    ast_declaration *declaration;
 119    ast_switch_body *switch_body;
 120    ast_case_label *case_label;
 121    ast_case_label_list *case_label_list;
 122    ast_case_statement *case_statement;
 123    ast_case_statement_list *case_statement_list;
 124    ast_interface_block *interface_block;
 125    ast_subroutine_list *subroutine_list;
 126    struct {
 127       ast_node *cond;
 128       ast_expression *rest;
 129    } for_rest_statement;
 130
 131    struct {
 132       ast_node *then_statement;
 133       ast_node *else_statement;
 134    } selection_rest_statement;
 135
 136    const glsl_type *type;
 137 }
 138
 139 %token ATTRIBUTE CONST_TOK
 140 %token <type> BASIC_TYPE_TOK
 141 %token BREAK BUFFER CONTINUE DO ELSE FOR IF DISCARD RETURN SWITCH CASE DEFAULT
 142 %token CENTROID IN_TOK OUT_TOK INOUT_TOK UNIFORM VARYING SAMPLE
 143 %token NOPERSPECTIVE FLAT SMOOTH
 144 %token IMAGE1DSHADOW IMAGE2DSHADOW IMAGE1DARRAYSHADOW IMAGE2DARRAYSHADOW
 145 %token COHERENT VOLATILE RESTRICT READONLY WRITEONLY
 146 %token SHARED
 147 %token STRUCT VOID_TOK WHILE
 148 %token <identifier> IDENTIFIER TYPE_IDENTIFIER NEW_IDENTIFIER
 149 %type <identifier> any_identifier
 150 %type <interface_block> instance_name_opt
 151 %token <real> FLOATCONSTANT
 152 %token <dreal> DOUBLECONSTANT
 153 %token <n> INTCONSTANT UINTCONSTANT BOOLCONSTANT
 154 %token <n64> INT64CONSTANT UINT64CONSTANT
 155 %token <identifier> FIELD_SELECTION
 156 %token LEFT_OP RIGHT_OP
 157 %token INC_OP DEC_OP LE_OP GE_OP EQ_OP NE_OP
 158 %token AND_OP OR_OP XOR_OP MUL_ASSIGN DIV_ASSIGN ADD_ASSIGN
 159 %token MOD_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN XOR_ASSIGN OR_ASSIGN
 160 %token SUB_ASSIGN
 161 %token INVARIANT PRECISE
 162 %token LOWP MEDIUMP HIGHP SUPERP PRECISION
 163
 164 %token VERSION_TOK EXTENSION LINE COLON EOL INTERFACE OUTPUT
 165 %token PRAGMA_DEBUG_ON PRAGMA_DEBUG_OFF
 166 %token PRAGMA_OPTIMIZE_ON PRAGMA_OPTIMIZE_OFF
 167 %token PRAGMA_INVARIANT_ALL
 168 %token LAYOUT_TOK
 169 %token DOT_TOK
 170    /* Reserved words that are not actually used in the grammar.
 171     */
 172 %token ASM CLASS UNION ENUM TYPEDEF TEMPLATE THIS PACKED_TOK GOTO
 173 %token INLINE_TOK NOINLINE PUBLIC_TOK STATIC EXTERN EXTERNAL
 174 %token LONG_TOK SHORT_TOK HALF FIXED_TOK UNSIGNED INPUT_TOK
 175 %token HVEC2 HVEC3 HVEC4 FVEC2 FVEC3 FVEC4
 176 %token SAMPLER3DRECT
 177 %token SIZEOF CAST NAMESPACE USING
 178 %token RESOURCE PATCH
 179 %token SUBROUTINE
 180
 181 %token ERROR_TOK
 182
 183 %token COMMON PARTITION ACTIVE FILTER ROW_MAJOR
 184
 185 %type <identifier> variable_identifier
 186 %type <node> statement
 187 %type <node> statement_list
 188 %type <node> simple_statement
 189 %type <n> precision_qualifier
 190 %type <type_qualifier> type_qualifier
 191 %type <type_qualifier> auxiliary_storage_qualifier
 192 %type <type_qualifier> storage_qualifier
 193 %type <type_qualifier> interpolation_qualifier
 194 %type <type_qualifier> layout_qualifier
 195 %type <type_qualifier> layout_qualifier_id_list layout_qualifier_id
 196 %type <type_qualifier> interface_block_layout_qualifier
 197 %type <type_qualifier> memory_qualifier
 198 %type <type_qualifier> subroutine_qualifier
 199 %type <subroutine_list> subroutine_type_list
 200 %type <type_qualifier> interface_qualifier
 201 %type <type_specifier> type_specifier
 202 %type <type_specifier> type_specifier_nonarray
 203 %type <array_specifier> array_specifier
 204 %type <type> basic_type_specifier_nonarray
 205 %type <fully_specified_type> fully_specified_type
 206 %type <function> function_prototype
 207 %type <function> function_header
 208 %type <function> function_header_with_parameters
 209 %type <function> function_declarator
 210 %type <parameter_declarator> parameter_declarator
 211 %type <parameter_declarator> parameter_declaration
 212 %type <type_qualifier> parameter_qualifier
 213 %type <type_qualifier> parameter_direction_qualifier
 214 %type <type_specifier> parameter_type_specifier
 215 %type <function_definition> function_definition
 216 %type <compound_statement> compound_statement_no_new_scope
 217 %type <compound_statement> compound_statement
 218 %type <node> statement_no_new_scope
 219 %type <node> expression_statement
 220 %type <expression> expression
 221 %type <expression> primary_expression
 222 %type <expression> assignment_expression
 223 %type <expression> conditional_expression
 224 %type <expression> logical_or_expression
 225 %type <expression> logical_xor_expression
 226 %type <expression> logical_and_expression
 227 %type <expression> inclusive_or_expression
 228 %type <expression> exclusive_or_expression
 229 %type <expression> and_expression
 230 %type <expression> equality_expression
 231 %type <expression> relational_expression
 232 %type <expression> shift_expression
 233 %type <expression> additive_expression
 234 %type <expression> multiplicative_expression
 235 %type <expression> unary_expression
 236 %type <expression> constant_expression
 237 %type <expression> integer_expression
 238 %type <expression> postfix_expression
 239 %type <expression> function_call_header_with_parameters
 240 %type <expression> function_call_header_no_parameters
 241 %type <expression> function_call_header
 242 %type <expression> function_call_generic
 243 %type <expression> function_call_or_method
 244 %type <expression> function_call
 245 %type <n> assignment_operator
 246 %type <n> unary_operator
 247 %type <expression> function_identifier
 248 %type <node> external_declaration
 249 %type <declarator_list> init_declarator_list
 250 %type <declarator_list> single_declaration
 251 %type <expression> initializer
 252 %type <expression> initializer_list
 253 %type <node> declaration
 254 %type <node> declaration_statement
 255 %type <node> jump_statement
 256 %type <node> interface_block
 257 %type <interface_block> basic_interface_block
 258 %type <struct_specifier> struct_specifier
 259 %type <declarator_list> struct_declaration_list
 260 %type <declarator_list> struct_declaration
 261 %type <declaration> struct_declarator
 262 %type <declaration> struct_declarator_list
 263 %type <declarator_list> member_list
 264 %type <declarator_list> member_declaration
 265 %type <node> selection_statement
 266 %type <selection_rest_statement> selection_rest_statement
 267 %type <node> switch_statement
 268 %type <switch_body> switch_body
 269 %type <case_label_list> case_label_list
 270 %type <case_label> case_label
 271 %type <case_statement> case_statement
 272 %type <case_statement_list> case_statement_list
 273 %type <node> iteration_statement
 274 %type <node> condition
 275 %type <node> conditionopt
 276 %type <node> for_init_statement
 277 %type <for_rest_statement> for_rest_statement
 278 %type <node> layout_defaults
 279 %type <type_qualifier> layout_uniform_defaults
 280 %type <type_qualifier> layout_buffer_defaults
 281 %type <type_qualifier> layout_in_defaults
 282 %type <type_qualifier> layout_out_defaults
 283
 284 %right THEN ELSE
 285 %%
 286
 287 translation_unit:
 288    version_statement extension_statement_list
 289    {
 290       _mesa_glsl_initialize_types(state);
 291    }
 292    external_declaration_list
 293    {
 294       delete state->symbols;
 295       state->symbols = new(ralloc_parent(state)) glsl_symbol_table;
 296       if (state->es_shader) {
 297          if (state->stage == MESA_SHADER_FRAGMENT) {
 298             state->symbols->add_default_precision_qualifier("int", ast_precision_medium);
 299          } else {
 300             state->symbols->add_default_precision_qualifier("float", ast_precision_high);
 301             state->symbols->add_default_precision_qualifier("int", ast_precision_high);
 302          }
 303          state->symbols->add_default_precision_qualifier("sampler2D", ast_precision_low);
 304          state->symbols->add_default_precision_qualifier("samplerExternalOES", ast_precision_low);
 305          state->symbols->add_default_precision_qualifier("samplerCube", ast_precision_low);
 306          state->symbols->add_default_precision_qualifier("atomic_uint", ast_precision_high);
 307       }
 308       _mesa_glsl_initialize_types(state);
 309    }
 310    ;
 311
 312 version_statement:
 313    /* blank - no #version specified: defaults are already set */
 314    | VERSION_TOK INTCONSTANT EOL
 315    {
 316       state->process_version_directive(&@2, $2, NULL);
 317       if (state->error) {
 318          YYERROR;
 319       }
 320    }
 321    | VERSION_TOK INTCONSTANT any_identifier EOL
 322    {
 323       state->process_version_directive(&@2, $2, $3);
 324       if (state->error) {
 325          YYERROR;
 326       }
 327    }
 328    ;
 329
 330 pragma_statement:
 331    PRAGMA_DEBUG_ON EOL
 332    | PRAGMA_DEBUG_OFF EOL
 333    | PRAGMA_OPTIMIZE_ON EOL
 334    | PRAGMA_OPTIMIZE_OFF EOL
 335    | PRAGMA_INVARIANT_ALL EOL
 336    {
 337       /* Pragma invariant(all) cannot be used in a fragment shader.
 338        *
 339        * Page 27 of the GLSL 1.20 spec, Page 53 of the GLSL ES 3.00 spec:
 340        *
 341        *     "It is an error to use this pragma in a fragment shader."
 342        */
 343       if (state->is_version(120, 300) &&
 344           state->stage == MESA_SHADER_FRAGMENT) {
 345          _mesa_glsl_error(& @1, state,
 346                           "pragma `invariant(all)' cannot be used "
 347                           "in a fragment shader.");
 348       } else if (!state->is_version(120, 100)) {
 349          _mesa_glsl_warning(& @1, state,
 350                             "pragma `invariant(all)' not supported in %s "
 351                             "(GLSL ES 1.00 or GLSL 1.20 required)",
 352                             state->get_version_string());
 353       } else {
 354          state->all_invariant = true;
 355       }
 356    }
 357    ;
 358
 359 extension_statement_list:
 360
 361    | extension_statement_list extension_statement
 362    ;
 363
 364 any_identifier:
 365    IDENTIFIER
 366    | TYPE_IDENTIFIER
 367    | NEW_IDENTIFIER
 368    ;
 369
 370 extension_statement:
 371    EXTENSION any_identifier COLON any_identifier EOL
 372    {
 373       if (!_mesa_glsl_process_extension($2, & @2, $4, & @4, state)) {
 374          YYERROR;
 375       }
 376    }
 377    ;
 378
 379 external_declaration_list:
 380    external_declaration
 381    {
 382       /* FINISHME: The NULL test is required because pragmas are set to
 383        * FINISHME: NULL. (See production rule for external_declaration.)
 384        */
 385       if ($1 != NULL)
 386          state->translation_unit.push_tail(& $1->link);
 387    }
 388    | external_declaration_list external_declaration
 389    {
 390       /* FINISHME: The NULL test is required because pragmas are set to
 391        * FINISHME: NULL. (See production rule for external_declaration.)
 392        */
 393       if ($2 != NULL)
 394          state->translation_unit.push_tail(& $2->link);
 395    }
 396    | external_declaration_list extension_statement {
 397       if (!state->allow_extension_directive_midshader) {
 398          _mesa_glsl_error(& @2, state,
 399                           "#extension directive is not allowed "
 400                           "in the middle of a shader");
 401          YYERROR;
 402       }
 403    }
 404    ;
 405
 406 variable_identifier:
 407    IDENTIFIER
 408    | NEW_IDENTIFIER
 409    ;
 410
 411 primary_expression:
 412    variable_identifier
 413    {
 414       void *ctx = state->linalloc;
 415       $$ = new(ctx) ast_expression(ast_identifier, NULL, NULL, NULL);
 416       $$->set_location(@1);
 417       $$->primary_expression.identifier = $1;
 418    }
 419    | INTCONSTANT
 420    {
 421       void *ctx = state->linalloc;
 422       $$ = new(ctx) ast_expression(ast_int_constant, NULL, NULL, NULL);
 423       $$->set_location(@1);
 424       $$->primary_expression.int_constant = $1;
 425    }
 426    | UINTCONSTANT
 427    {
 428       void *ctx = state->linalloc;
 429       $$ = new(ctx) ast_expression(ast_uint_constant, NULL, NULL, NULL);
 430       $$->set_location(@1);
 431       $$->primary_expression.uint_constant = $1;
 432    }
 433    | INT64CONSTANT
 434    {
 435       void *ctx = state->linalloc;
 436       $$ = new(ctx) ast_expression(ast_int64_constant, NULL, NULL, NULL);
 437       $$->set_location(@1);
 438       $$->primary_expression.int64_constant = $1;
 439    }
 440    | UINT64CONSTANT
 441    {
 442       void *ctx = state->linalloc;
 443       $$ = new(ctx) ast_expression(ast_uint64_constant, NULL, NULL, NULL);
 444       $$->set_location(@1);
 445       $$->primary_expression.uint64_constant = $1;
 446    }
 447    | FLOATCONSTANT
 448    {
 449       void *ctx = state->linalloc;
 450       $$ = new(ctx) ast_expression(ast_float_constant, NULL, NULL, NULL);
 451       $$->set_location(@1);
 452       $$->primary_expression.float_constant = $1;
 453    }
 454    | DOUBLECONSTANT
 455    {
 456       void *ctx = state->linalloc;
 457       $$ = new(ctx) ast_expression(ast_double_constant, NULL, NULL, NULL);
 458       $$->set_location(@1);
 459       $$->primary_expression.double_constant = $1;
 460    }
 461    | BOOLCONSTANT
 462    {
 463       void *ctx = state->linalloc;
 464       $$ = new(ctx) ast_expression(ast_bool_constant, NULL, NULL, NULL);
 465       $$->set_location(@1);
 466       $$->primary_expression.bool_constant = $1;
 467    }
 468    | '(' expression ')'
 469    {
 470       $$ = $2;
 471    }
 472    ;
 473
 474 postfix_expression:
 475    primary_expression
 476    | postfix_expression '[' integer_expression ']'
 477    {
 478       void *ctx = state->linalloc;
 479       $$ = new(ctx) ast_expression(ast_array_index, $1, $3, NULL);
 480       $$->set_location_range(@1, @4);
 481    }
 482    | function_call
 483    {
 484       $$ = $1;
 485    }
 486    | postfix_expression DOT_TOK FIELD_SELECTION
 487    {
 488       void *ctx = state->linalloc;
 489       $$ = new(ctx) ast_expression(ast_field_selection, $1, NULL, NULL);
 490       $$->set_location_range(@1, @3);
 491       $$->primary_expression.identifier = $3;
 492    }
 493    | postfix_expression INC_OP
 494    {
 495       void *ctx = state->linalloc;
 496       $$ = new(ctx) ast_expression(ast_post_inc, $1, NULL, NULL);
 497       $$->set_location_range(@1, @2);
 498    }
 499    | postfix_expression DEC_OP
 500    {
 501       void *ctx = state->linalloc;
 502       $$ = new(ctx) ast_expression(ast_post_dec, $1, NULL, NULL);
 503       $$->set_location_range(@1, @2);
 504    }
 505    ;
 506
 507 integer_expression:
 508    expression
 509    ;
 510
 511 function_call:
 512    function_call_or_method
 513    ;
 514
 515 function_call_or_method:
 516    function_call_generic
 517    ;
 518
 519 function_call_generic:
 520    function_call_header_with_parameters ')'
 521    | function_call_header_no_parameters ')'
 522    ;
 523
 524 function_call_header_no_parameters:
 525    function_call_header VOID_TOK
 526    | function_call_header
 527    ;
 528
 529 function_call_header_with_parameters:
 530    function_call_header assignment_expression
 531    {
 532       $$ = $1;
 533       $$->set_location(@1);
 534       $$->expressions.push_tail(& $2->link);
 535    }
 536    | function_call_header_with_parameters ',' assignment_expression
 537    {
 538       $$ = $1;
 539       $$->set_location(@1);
 540       $$->expressions.push_tail(& $3->link);
 541    }
 542    ;
 543
 544    // Grammar Note: Constructors look like functions, but lexical
 545    // analysis recognized most of them as keywords. They are now
 546    // recognized through "type_specifier".
 547 function_call_header:
 548    function_identifier '('
 549    ;
 550
 551 function_identifier:
 552    type_specifier
 553    {
 554       void *ctx = state->linalloc;
 555       $$ = new(ctx) ast_function_expression($1);
 556       $$->set_location(@1);
 557       }
 558    | postfix_expression
 559    {
 560       void *ctx = state->linalloc;
 561       $$ = new(ctx) ast_function_expression($1);
 562       $$->set_location(@1);
 563       }
 564    ;
 565
 566    // Grammar Note: Constructors look like methods, but lexical
 567    // analysis recognized most of them as keywords. They are now
 568    // recognized through "type_specifier".
 569
 570    // Grammar Note: No traditional style type casts.
 571 unary_expression:
 572    postfix_expression
 573    | INC_OP unary_expression
 574    {
 575       void *ctx = state->linalloc;
 576       $$ = new(ctx) ast_expression(ast_pre_inc, $2, NULL, NULL);
 577       $$->set_location(@1);
 578    }
 579    | DEC_OP unary_expression
 580    {
 581       void *ctx = state->linalloc;
 582       $$ = new(ctx) ast_expression(ast_pre_dec, $2, NULL, NULL);
 583       $$->set_location(@1);
 584    }
 585    | unary_operator unary_expression
 586    {
 587       void *ctx = state->linalloc;
 588       $$ = new(ctx) ast_expression($1, $2, NULL, NULL);
 589       $$->set_location_range(@1, @2);
 590    }
 591    ;
 592
 593    // Grammar Note: No '*' or '&' unary ops. Pointers are not supported.
 594 unary_operator:
 595    '+'   { $$ = ast_plus; }
 596    | '-' { $$ = ast_neg; }
 597    | '!' { $$ = ast_logic_not; }
 598    | '~' { $$ = ast_bit_not; }
 599    ;
 600
 601 multiplicative_expression:
 602    unary_expression
 603    | multiplicative_expression '*' unary_expression
 604    {
 605       void *ctx = state->linalloc;
 606       $$ = new(ctx) ast_expression_bin(ast_mul, $1, $3);
 607       $$->set_location_range(@1, @3);
 608    }
 609    | multiplicative_expression '/' unary_expression
 610    {
 611       void *ctx = state->linalloc;
 612       $$ = new(ctx) ast_expression_bin(ast_div, $1, $3);
 613       $$->set_location_range(@1, @3);
 614    }
 615    | multiplicative_expression '%' unary_expression
 616    {
 617       void *ctx = state->linalloc;
 618       $$ = new(ctx) ast_expression_bin(ast_mod, $1, $3);
 619       $$->set_location_range(@1, @3);
 620    }
 621    ;
 622
 623 additive_expression:
 624    multiplicative_expression
 625    | additive_expression '+' multiplicative_expression
 626    {
 627       void *ctx = state->linalloc;
 628       $$ = new(ctx) ast_expression_bin(ast_add, $1, $3);
 629       $$->set_location_range(@1, @3);
 630    }
 631    | additive_expression '-' multiplicative_expression
 632    {
 633       void *ctx = state->linalloc;
 634       $$ = new(ctx) ast_expression_bin(ast_sub, $1, $3);
 635       $$->set_location_range(@1, @3);
 636    }
 637    ;
 638
 639 shift_expression:
 640    additive_expression
 641    | shift_expression LEFT_OP additive_expression
 642    {
 643       void *ctx = state->linalloc;
 644       $$ = new(ctx) ast_expression_bin(ast_lshift, $1, $3);
 645       $$->set_location_range(@1, @3);
 646    }
 647    | shift_expression RIGHT_OP additive_expression
 648    {
 649       void *ctx = state->linalloc;
 650       $$ = new(ctx) ast_expression_bin(ast_rshift, $1, $3);
 651       $$->set_location_range(@1, @3);
 652    }
 653    ;
 654
 655 relational_expression:
 656    shift_expression
 657    | relational_expression '<' shift_expression
 658    {
 659       void *ctx = state->linalloc;
 660       $$ = new(ctx) ast_expression_bin(ast_less, $1, $3);
 661       $$->set_location_range(@1, @3);
 662    }
 663    | relational_expression '>' shift_expression
 664    {
 665       void *ctx = state->linalloc;
 666       $$ = new(ctx) ast_expression_bin(ast_greater, $1, $3);
 667       $$->set_location_range(@1, @3);
 668    }
 669    | relational_expression LE_OP shift_expression
 670    {
 671       void *ctx = state->linalloc;
 672       $$ = new(ctx) ast_expression_bin(ast_lequal, $1, $3);
 673       $$->set_location_range(@1, @3);
 674    }
 675    | relational_expression GE_OP shift_expression
 676    {
 677       void *ctx = state->linalloc;
 678       $$ = new(ctx) ast_expression_bin(ast_gequal, $1, $3);
 679       $$->set_location_range(@1, @3);
 680    }
 681    ;
 682
 683 equality_expression:
 684    relational_expression
 685    | equality_expression EQ_OP relational_expression
 686    {
 687       void *ctx = state->linalloc;
 688       $$ = new(ctx) ast_expression_bin(ast_equal, $1, $3);
 689       $$->set_location_range(@1, @3);
 690    }
 691    | equality_expression NE_OP relational_expression
 692    {
 693       void *ctx = state->linalloc;
 694       $$ = new(ctx) ast_expression_bin(ast_nequal, $1, $3);
 695       $$->set_location_range(@1, @3);
 696    }
 697    ;
 698
 699 and_expression:
 700    equality_expression
 701    | and_expression '&' equality_expression
 702    {
 703       void *ctx = state->linalloc;
 704       $$ = new(ctx) ast_expression_bin(ast_bit_and, $1, $3);
 705       $$->set_location_range(@1, @3);
 706    }
 707    ;
 708
 709 exclusive_or_expression:
 710    and_expression
 711    | exclusive_or_expression '^' and_expression
 712    {
 713       void *ctx = state->linalloc;
 714       $$ = new(ctx) ast_expression_bin(ast_bit_xor, $1, $3);
 715       $$->set_location_range(@1, @3);
 716    }
 717    ;
 718
 719 inclusive_or_expression:
 720    exclusive_or_expression
 721    | inclusive_or_expression '|' exclusive_or_expression
 722    {
 723       void *ctx = state->linalloc;
 724       $$ = new(ctx) ast_expression_bin(ast_bit_or, $1, $3);
 725       $$->set_location_range(@1, @3);
 726    }
 727    ;
 728
 729 logical_and_expression:
 730    inclusive_or_expression
 731    | logical_and_expression AND_OP inclusive_or_expression
 732    {
 733       void *ctx = state->linalloc;
 734       $$ = new(ctx) ast_expression_bin(ast_logic_and, $1, $3);
 735       $$->set_location_range(@1, @3);
 736    }
 737    ;
 738
 739 logical_xor_expression:
 740    logical_and_expression
 741    | logical_xor_expression XOR_OP logical_and_expression
 742    {
 743       void *ctx = state->linalloc;
 744       $$ = new(ctx) ast_expression_bin(ast_logic_xor, $1, $3);
 745       $$->set_location_range(@1, @3);
 746    }
 747    ;
 748
 749 logical_or_expression:
 750    logical_xor_expression
 751    | logical_or_expression OR_OP logical_xor_expression
 752    {
 753       void *ctx = state->linalloc;
 754       $$ = new(ctx) ast_expression_bin(ast_logic_or, $1, $3);
 755       $$->set_location_range(@1, @3);
 756    }
 757    ;
 758
 759 conditional_expression:
 760    logical_or_expression
 761    | logical_or_expression '?' expression ':' assignment_expression
 762    {
 763       void *ctx = state->linalloc;
 764       $$ = new(ctx) ast_expression(ast_conditional, $1, $3, $5);
 765       $$->set_location_range(@1, @5);
 766    }
 767    ;
 768
 769 assignment_expression:
 770    conditional_expression
 771    | unary_expression assignment_operator assignment_expression
 772    {
 773       void *ctx = state->linalloc;
 774       $$ = new(ctx) ast_expression($2, $1, $3, NULL);
 775       $$->set_location_range(@1, @3);
 776    }
 777    ;
 778
 779 assignment_operator:
 780    '='                { $$ = ast_assign; }
 781    | MUL_ASSIGN       { $$ = ast_mul_assign; }
 782    | DIV_ASSIGN       { $$ = ast_div_assign; }
 783    | MOD_ASSIGN       { $$ = ast_mod_assign; }
 784    | ADD_ASSIGN       { $$ = ast_add_assign; }
 785    | SUB_ASSIGN       { $$ = ast_sub_assign; }
 786    | LEFT_ASSIGN      { $$ = ast_ls_assign; }
 787    | RIGHT_ASSIGN     { $$ = ast_rs_assign; }
 788    | AND_ASSIGN       { $$ = ast_and_assign; }
 789    | XOR_ASSIGN       { $$ = ast_xor_assign; }
 790    | OR_ASSIGN        { $$ = ast_or_assign; }
 791    ;
 792
 793 expression:
 794    assignment_expression
 795    {
 796       $$ = $1;
 797    }
 798    | expression ',' assignment_expression
 799    {
 800       void *ctx = state->linalloc;
 801       if ($1->oper != ast_sequence) {
 802          $$ = new(ctx) ast_expression(ast_sequence, NULL, NULL, NULL);
 803          $$->set_location_range(@1, @3);
 804          $$->expressions.push_tail(& $1->link);
 805       } else {
 806          $$ = $1;
 807       }
 808
 809       $$->expressions.push_tail(& $3->link);
 810    }
 811    ;
 812
 813 constant_expression:
 814    conditional_expression
 815    ;
 816
 817 declaration:
 818    function_prototype ';'
 819    {
 820       state->symbols->pop_scope();
 821       $$ = $1;
 822    }
 823    | init_declarator_list ';'
 824    {
 825       $$ = $1;
 826    }
 827    | PRECISION precision_qualifier type_specifier ';'
 828    {
 829       $3->default_precision = $2;
 830       $$ = $3;
 831    }
 832    | interface_block
 833    {
 834       ast_interface_block *block = (ast_interface_block *) $1;
 835       if (block->layout.has_layout() || block->layout.has_memory()) {
 836          if (!block->default_layout.merge_qualifier(& @1, state, block->layout, false)) {
 837             YYERROR;
 838          }
 839       }
 840       block->layout = block->default_layout;
 841       if (!block->layout.push_to_global(& @1, state)) {
 842          YYERROR;
 843       }
 844       $$ = $1;
 845    }
 846    ;
 847
 848 function_prototype:
 849    function_declarator ')'
 850    ;
 851
 852 function_declarator:
 853    function_header
 854    | function_header_with_parameters
 855    ;
 856
 857 function_header_with_parameters:
 858    function_header parameter_declaration
 859    {
 860       $$ = $1;
 861       $$->parameters.push_tail(& $2->link);
 862    }
 863    | function_header_with_parameters ',' parameter_declaration
 864    {
 865       $$ = $1;
 866       $$->parameters.push_tail(& $3->link);
 867    }
 868    ;
 869
 870 function_header:
 871    fully_specified_type variable_identifier '('
 872    {
 873       void *ctx = state->linalloc;
 874       $$ = new(ctx) ast_function();
 875       $$->set_location(@2);
 876       $$->return_type = $1;
 877       $$->identifier = $2;
 878
 879       if ($1->qualifier.is_subroutine_decl()) {
 880          /* add type for IDENTIFIER search */
 881          state->symbols->add_type($2, glsl_type::get_subroutine_instance($2));
 882       } else
 883          state->symbols->add_function(new(state) ir_function($2));
 884       state->symbols->push_scope();
 885    }
 886    ;
 887
 888 parameter_declarator:
 889    type_specifier any_identifier
 890    {
 891       void *ctx = state->linalloc;
 892       $$ = new(ctx) ast_parameter_declarator();
 893       $$->set_location_range(@1, @2);
 894       $$->type = new(ctx) ast_fully_specified_type();
 895       $$->type->set_location(@1);
 896       $$->type->specifier = $1;
 897       $$->identifier = $2;
 898       state->symbols->add_variable(new(state) ir_variable(NULL, $2, ir_var_auto));
 899    }
 900    | type_specifier any_identifier array_specifier
 901    {
 902       void *ctx = state->linalloc;
 903       $$ = new(ctx) ast_parameter_declarator();
 904       $$->set_location_range(@1, @3);
 905       $$->type = new(ctx) ast_fully_specified_type();
 906       $$->type->set_location(@1);
 907       $$->type->specifier = $1;
 908       $$->identifier = $2;
 909       $$->array_specifier = $3;
 910       state->symbols->add_variable(new(state) ir_variable(NULL, $2, ir_var_auto));
 911    }
 912    ;
 913
 914 parameter_declaration:
 915    parameter_qualifier parameter_declarator
 916    {
 917       $$ = $2;
 918       $$->type->qualifier = $1;
 919       if (!$$->type->qualifier.push_to_global(& @1, state)) {
 920          YYERROR;
 921       }
 922    }
 923    | parameter_qualifier parameter_type_specifier
 924    {
 925       void *ctx = state->linalloc;
 926       $$ = new(ctx) ast_parameter_declarator();
 927       $$->set_location(@2);
 928       $$->type = new(ctx) ast_fully_specified_type();
 929       $$->type->set_location_range(@1, @2);
 930       $$->type->qualifier = $1;
 931       if (!$$->type->qualifier.push_to_global(& @1, state)) {
 932          YYERROR;
 933       }
 934       $$->type->specifier = $2;
 935    }
 936    ;
 937
 938 parameter_qualifier:
 939    /* empty */
 940    {
 941       memset(& $$, 0, sizeof($$));
 942    }
 943    | CONST_TOK parameter_qualifier
 944    {
 945       if ($2.flags.q.constant)
 946          _mesa_glsl_error(&@1, state, "duplicate const qualifier");
 947
 948       $$ = $2;
 949       $$.flags.q.constant = 1;
 950    }
 951    | PRECISE parameter_qualifier
 952    {
 953       if ($2.flags.q.precise)
 954          _mesa_glsl_error(&@1, state, "duplicate precise qualifier");
 955
 956       $$ = $2;
 957       $$.flags.q.precise = 1;
 958    }
 959    | parameter_direction_qualifier parameter_qualifier
 960    {
 961       if (($1.flags.q.in || $1.flags.q.out) && ($2.flags.q.in || $2.flags.q.out))
 962          _mesa_glsl_error(&@1, state, "duplicate in/out/inout qualifier");
 963
 964       if (!state->has_420pack_or_es31() && $2.flags.q.constant)
 965          _mesa_glsl_error(&@1, state, "in/out/inout must come after const "
 966                                       "or precise");
 967
 968       $$ = $1;
 969       $$.merge_qualifier(&@1, state, $2, false);
 970    }
 971    | precision_qualifier parameter_qualifier
 972    {
 973       if ($2.precision != ast_precision_none)
 974          _mesa_glsl_error(&@1, state, "duplicate precision qualifier");
 975
 976       if (!state->has_420pack_or_es31() &&
 977           $2.flags.i != 0)
 978          _mesa_glsl_error(&@1, state, "precision qualifiers must come last");
 979
 980       $$ = $2;
 981       $$.precision = $1;
 982    }
 983    | memory_qualifier parameter_qualifier
 984    {
 985       $$ = $1;
 986       $$.merge_qualifier(&@1, state, $2, false);
 987    }
 988
 989 parameter_direction_qualifier:
 990    IN_TOK
 991    {
 992       memset(& $$, 0, sizeof($$));
 993       $$.flags.q.in = 1;
 994    }
 995    | OUT_TOK
 996    {
 997       memset(& $$, 0, sizeof($$));
 998       $$.flags.q.out = 1;
 999    }
1000    | INOUT_TOK
1001    {
1002       memset(& $$, 0, sizeof($$));
1003       $$.flags.q.in = 1;
1004       $$.flags.q.out = 1;
1005    }
1006    ;
1007
1008 parameter_type_specifier:
1009    type_specifier
1010    ;
1011
1012 init_declarator_list:
1013    single_declaration
1014    | init_declarator_list ',' any_identifier
1015    {
1016       void *ctx = state->linalloc;
1017       ast_declaration *decl = new(ctx) ast_declaration($3, NULL, NULL);
1018       decl->set_location(@3);
1019
1020       $$ = $1;
1021       $$->declarations.push_tail(&decl->link);
1022       state->symbols->add_variable(new(state) ir_variable(NULL, $3, ir_var_auto));
1023    }
1024    | init_declarator_list ',' any_identifier array_specifier
1025    {
1026       void *ctx = state->linalloc;
1027       ast_declaration *decl = new(ctx) ast_declaration($3, $4, NULL);
1028       decl->set_location_range(@3, @4);
1029
1030       $$ = $1;
1031       $$->declarations.push_tail(&decl->link);
1032       state->symbols->add_variable(new(state) ir_variable(NULL, $3, ir_var_auto));
1033    }
1034    | init_declarator_list ',' any_identifier array_specifier '=' initializer
1035    {
1036       void *ctx = state->linalloc;
1037       ast_declaration *decl = new(ctx) ast_declaration($3, $4, $6);
1038       decl->set_location_range(@3, @4);
1039
1040       $$ = $1;
1041       $$->declarations.push_tail(&decl->link);
1042       state->symbols->add_variable(new(state) ir_variable(NULL, $3, ir_var_auto));
1043    }
1044    | init_declarator_list ',' any_identifier '=' initializer
1045    {
1046       void *ctx = state->linalloc;
1047       ast_declaration *decl = new(ctx) ast_declaration($3, NULL, $5);
1048       decl->set_location(@3);
1049
1050       $$ = $1;
1051       $$->declarations.push_tail(&decl->link);
1052       state->symbols->add_variable(new(state) ir_variable(NULL, $3, ir_var_auto));
1053    }
1054    ;
1055
1056    // Grammar Note: No 'enum', or 'typedef'.
1057 single_declaration:
1058    fully_specified_type
1059    {
1060       void *ctx = state->linalloc;
1061       /* Empty declaration list is valid. */
1062       $$ = new(ctx) ast_declarator_list($1);
1063       $$->set_location(@1);
1064    }
1065    | fully_specified_type any_identifier
1066    {
1067       void *ctx = state->linalloc;
1068       ast_declaration *decl = new(ctx) ast_declaration($2, NULL, NULL);
1069       decl->set_location(@2);
1070
1071       $$ = new(ctx) ast_declarator_list($1);
1072       $$->set_location_range(@1, @2);
1073       $$->declarations.push_tail(&decl->link);
1074       state->symbols->add_variable(new(state) ir_variable(NULL, $2, ir_var_auto));
1075    }
1076    | fully_specified_type any_identifier array_specifier
1077    {
1078       void *ctx = state->linalloc;
1079       ast_declaration *decl = new(ctx) ast_declaration($2, $3, NULL);
1080       decl->set_location_range(@2, @3);
1081
1082       $$ = new(ctx) ast_declarator_list($1);
1083       $$->set_location_range(@1, @3);
1084       $$->declarations.push_tail(&decl->link);
1085       state->symbols->add_variable(new(state) ir_variable(NULL, $2, ir_var_auto));
1086    }
1087    | fully_specified_type any_identifier array_specifier '=' initializer
1088    {
1089       void *ctx = state->linalloc;
1090       ast_declaration *decl = new(ctx) ast_declaration($2, $3, $5);
1091       decl->set_location_range(@2, @3);
1092
1093       $$ = new(ctx) ast_declarator_list($1);
1094       $$->set_location_range(@1, @3);
1095       $$->declarations.push_tail(&decl->link);
1096       state->symbols->add_variable(new(state) ir_variable(NULL, $2, ir_var_auto));
1097    }
1098    | fully_specified_type any_identifier '=' initializer
1099    {
1100       void *ctx = state->linalloc;
1101       ast_declaration *decl = new(ctx) ast_declaration($2, NULL, $4);
1102       decl->set_location(@2);
1103
1104       $$ = new(ctx) ast_declarator_list($1);
1105       $$->set_location_range(@1, @2);
1106       $$->declarations.push_tail(&decl->link);
1107       state->symbols->add_variable(new(state) ir_variable(NULL, $2, ir_var_auto));
1108    }
1109    | INVARIANT variable_identifier
1110    {
1111       void *ctx = state->linalloc;
1112       ast_declaration *decl = new(ctx) ast_declaration($2, NULL, NULL);
1113       decl->set_location(@2);
1114
1115       $$ = new(ctx) ast_declarator_list(NULL);
1116       $$->set_location_range(@1, @2);
1117       $$->invariant = true;
1118
1119       $$->declarations.push_tail(&decl->link);
1120    }
1121    | PRECISE variable_identifier
1122    {
1123       void *ctx = state->linalloc;
1124       ast_declaration *decl = new(ctx) ast_declaration($2, NULL, NULL);
1125       decl->set_location(@2);
1126
1127       $$ = new(ctx) ast_declarator_list(NULL);
1128       $$->set_location_range(@1, @2);
1129       $$->precise = true;
1130
1131       $$->declarations.push_tail(&decl->link);
1132    }
1133    ;
1134
1135 fully_specified_type:
1136    type_specifier
1137    {
1138       void *ctx = state->linalloc;
1139       $$ = new(ctx) ast_fully_specified_type();
1140       $$->set_location(@1);
1141       $$->specifier = $1;
1142    }
1143    | type_qualifier type_specifier
1144    {
1145       void *ctx = state->linalloc;
1146       $$ = new(ctx) ast_fully_specified_type();
1147       $$->set_location_range(@1, @2);
1148       $$->qualifier = $1;
1149       if (!$$->qualifier.push_to_global(& @1, state)) {
1150          YYERROR;
1151       }
1152       $$->specifier = $2;
1153       if ($$->specifier->structure != NULL &&
1154           $$->specifier->structure->is_declaration) {
1155             $$->specifier->structure->layout = &$$->qualifier;
1156       }
1157    }
1158    ;
1159
1160 layout_qualifier:
1161    LAYOUT_TOK '(' layout_qualifier_id_list ')'
1162    {
1163       $$ = $3;
1164    }
1165    ;
1166
1167 layout_qualifier_id_list:
1168    layout_qualifier_id
1169    | layout_qualifier_id_list ',' layout_qualifier_id
1170    {
1171       $$ = $1;
1172       if (!$$.merge_qualifier(& @3, state, $3, true)) {
1173          YYERROR;
1174       }
1175    }
1176    ;
1177
1178 layout_qualifier_id:
1179    any_identifier
1180    {
1181       memset(& $$, 0, sizeof($$));
1182
1183       /* Layout qualifiers for ARB_fragment_coord_conventions. */
1184       if (!$$.flags.i && (state->ARB_fragment_coord_conventions_enable ||
1185                           state->is_version(150, 0))) {
1186          if (match_layout_qualifier($1, "origin_upper_left", state) == 0) {
1187             $$.flags.q.origin_upper_left = 1;
1188          } else if (match_layout_qualifier($1, "pixel_center_integer",
1189                                            state) == 0) {
1190             $$.flags.q.pixel_center_integer = 1;
1191          }
1192
1193          if ($$.flags.i && state->ARB_fragment_coord_conventions_warn) {
1194             _mesa_glsl_warning(& @1, state,
1195                                "GL_ARB_fragment_coord_conventions layout "
1196                                "identifier `%s' used", $1);
1197          }
1198       }
1199
1200       /* Layout qualifiers for AMD/ARB_conservative_depth. */
1201       if (!$$.flags.i &&
1202           (state->AMD_conservative_depth_enable ||
1203            state->ARB_conservative_depth_enable ||
1204            state->is_version(420, 0))) {
1205          if (match_layout_qualifier($1, "depth_any", state) == 0) {
1206             $$.flags.q.depth_type = 1;
1207             $$.depth_type = ast_depth_any;
1208          } else if (match_layout_qualifier($1, "depth_greater", state) == 0) {
1209             $$.flags.q.depth_type = 1;
1210             $$.depth_type = ast_depth_greater;
1211          } else if (match_layout_qualifier($1, "depth_less", state) == 0) {
1212             $$.flags.q.depth_type = 1;
1213             $$.depth_type = ast_depth_less;
1214          } else if (match_layout_qualifier($1, "depth_unchanged",
1215                                            state) == 0) {
1216             $$.flags.q.depth_type = 1;
1217             $$.depth_type = ast_depth_unchanged;
1218          }
1219
1220          if ($$.flags.i && state->AMD_conservative_depth_warn) {
1221             _mesa_glsl_warning(& @1, state,
1222                                "GL_AMD_conservative_depth "
1223                                "layout qualifier `%s' is used", $1);
1224          }
1225          if ($$.flags.i && state->ARB_conservative_depth_warn) {
1226             _mesa_glsl_warning(& @1, state,
1227                                "GL_ARB_conservative_depth "
1228                                "layout qualifier `%s' is used", $1);
1229          }
1230       }
1231
1232       /* See also interface_block_layout_qualifier. */
1233       if (!$$.flags.i && state->has_uniform_buffer_objects()) {
1234          if (match_layout_qualifier($1, "std140", state) == 0) {
1235             $$.flags.q.std140 = 1;
1236          } else if (match_layout_qualifier($1, "shared", state) == 0) {
1237             $$.flags.q.shared = 1;
1238          } else if (match_layout_qualifier($1, "std430", state) == 0) {
1239             $$.flags.q.std430 = 1;
1240          } else if (match_layout_qualifier($1, "column_major", state) == 0) {
1241             $$.flags.q.column_major = 1;
1242          /* "row_major" is a reserved word in GLSL 1.30+. Its token is parsed
1243           * below in the interface_block_layout_qualifier rule.
1244           *
1245           * It is not a reserved word in GLSL ES 3.00, so it's handled here as
1246           * an identifier.
1247           *
1248           * Also, this takes care of alternate capitalizations of
1249           * "row_major" (which is necessary because layout qualifiers
1250           * are case-insensitive in desktop GLSL).
1251           */
1252          } else if (match_layout_qualifier($1, "row_major", state) == 0) {
1253             $$.flags.q.row_major = 1;
1254          /* "packed" is a reserved word in GLSL, and its token is
1255           * parsed below in the interface_block_layout_qualifier rule.
1256           * However, we must take care of alternate capitalizations of
1257           * "packed", because layout qualifiers are case-insensitive
1258           * in desktop GLSL.
1259           */
1260          } else if (match_layout_qualifier($1, "packed", state) == 0) {
1261            $$.flags.q.packed = 1;
1262          }
1263
1264          if ($$.flags.i && state->ARB_uniform_buffer_object_warn) {
1265             _mesa_glsl_warning(& @1, state,
1266                                "#version 140 / GL_ARB_uniform_buffer_object "
1267                                "layout qualifier `%s' is used", $1);
1268          }
1269       }
1270
1271       /* Layout qualifiers for GLSL 1.50 geometry shaders. */
1272       if (!$$.flags.i) {
1273          static const struct {
1274             const char *s;
1275             GLenum e;
1276          } map[] = {
1277                  { "points", GL_POINTS },
1278                  { "lines", GL_LINES },
1279                  { "lines_adjacency", GL_LINES_ADJACENCY },
1280                  { "line_strip", GL_LINE_STRIP },
1281                  { "triangles", GL_TRIANGLES },
1282                  { "triangles_adjacency", GL_TRIANGLES_ADJACENCY },
1283                  { "triangle_strip", GL_TRIANGLE_STRIP },
1284          };
1285          for (unsigned i = 0; i < ARRAY_SIZE(map); i++) {
1286             if (match_layout_qualifier($1, map[i].s, state) == 0) {
1287                $$.flags.q.prim_type = 1;
1288                $$.prim_type = map[i].e;
1289                break;
1290             }
1291          }
1292
1293          if ($$.flags.i && !state->has_geometry_shader() &&
1294              !state->has_tessellation_shader()) {
1295             _mesa_glsl_error(& @1, state, "#version 150 layout "
1296                              "qualifier `%s' used", $1);
1297          }
1298       }
1299
1300       /* Layout qualifiers for ARB_shader_image_load_store. */
1301       if (state->has_shader_image_load_store()) {
1302          if (!$$.flags.i) {
1303             static const struct {
1304                const char *name;
1305                GLenum format;
1306                glsl_base_type base_type;
1307                /** Minimum desktop GLSL version required for the image
1308                 * format.  Use 130 if already present in the original
1309                 * ARB extension.
1310                 */
1311                unsigned required_glsl;
1312                /** Minimum GLSL ES version required for the image format. */
1313                unsigned required_essl;
1314                /* NV_image_formats */
1315                bool nv_image_formats;
1316             } map[] = {
1317                { "rgba32f", GL_RGBA32F, GLSL_TYPE_FLOAT, 130, 310, false },
1318                { "rgba16f", GL_RGBA16F, GLSL_TYPE_FLOAT, 130, 310, false },
1319                { "rg32f", GL_RG32F, GLSL_TYPE_FLOAT, 130, 0, true },
1320                { "rg16f", GL_RG16F, GLSL_TYPE_FLOAT, 130, 0, true },
1321                { "r11f_g11f_b10f", GL_R11F_G11F_B10F, GLSL_TYPE_FLOAT, 130, 0, true },
1322                { "r32f", GL_R32F, GLSL_TYPE_FLOAT, 130, 310, false },
1323                { "r16f", GL_R16F, GLSL_TYPE_FLOAT, 130, 0, true },
1324                { "rgba32ui", GL_RGBA32UI, GLSL_TYPE_UINT, 130, 310, false },
1325                { "rgba16ui", GL_RGBA16UI, GLSL_TYPE_UINT, 130, 310, false },
1326                { "rgb10_a2ui", GL_RGB10_A2UI, GLSL_TYPE_UINT, 130, 0, true },
1327                { "rgba8ui", GL_RGBA8UI, GLSL_TYPE_UINT, 130, 310, false },
1328                { "rg32ui", GL_RG32UI, GLSL_TYPE_UINT, 130, 0, true },
1329                { "rg16ui", GL_RG16UI, GLSL_TYPE_UINT, 130, 0, true },
1330                { "rg8ui", GL_RG8UI, GLSL_TYPE_UINT, 130, 0, true },
1331                { "r32ui", GL_R32UI, GLSL_TYPE_UINT, 130, 310, false },
1332                { "r16ui", GL_R16UI, GLSL_TYPE_UINT, 130, 0, true },
1333                { "r8ui", GL_R8UI, GLSL_TYPE_UINT, 130, 0, true },
1334                { "rgba32i", GL_RGBA32I, GLSL_TYPE_INT, 130, 310, false },
1335                { "rgba16i", GL_RGBA16I, GLSL_TYPE_INT, 130, 310, false },
1336                { "rgba8i", GL_RGBA8I, GLSL_TYPE_INT, 130, 310, false },
1337                { "rg32i", GL_RG32I, GLSL_TYPE_INT, 130, 0, true },
1338                { "rg16i", GL_RG16I, GLSL_TYPE_INT, 130, 0, true },
1339                { "rg8i", GL_RG8I, GLSL_TYPE_INT, 130, 0, true },
1340                { "r32i", GL_R32I, GLSL_TYPE_INT, 130, 310, false },
1341                { "r16i", GL_R16I, GLSL_TYPE_INT, 130, 0, true },
1342                { "r8i", GL_R8I, GLSL_TYPE_INT, 130, 0, true },
1343                { "rgba16", GL_RGBA16, GLSL_TYPE_FLOAT, 130, 0, true },
1344                { "rgb10_a2", GL_RGB10_A2, GLSL_TYPE_FLOAT, 130, 0, true },
1345                { "rgba8", GL_RGBA8, GLSL_TYPE_FLOAT, 130, 310, false },
1346                { "rg16", GL_RG16, GLSL_TYPE_FLOAT, 130, 0, true },
1347                { "rg8", GL_RG8, GLSL_TYPE_FLOAT, 130, 0, true },
1348                { "r16", GL_R16, GLSL_TYPE_FLOAT, 130, 0, true },
1349                { "r8", GL_R8, GLSL_TYPE_FLOAT, 130, 0, true },
1350                { "rgba16_snorm", GL_RGBA16_SNORM, GLSL_TYPE_FLOAT, 130, 0, true },
1351                { "rgba8_snorm", GL_RGBA8_SNORM, GLSL_TYPE_FLOAT, 130, 310, false },
1352                { "rg16_snorm", GL_RG16_SNORM, GLSL_TYPE_FLOAT, 130, 0, true },
1353                { "rg8_snorm", GL_RG8_SNORM, GLSL_TYPE_FLOAT, 130, 0, true },
1354                { "r16_snorm", GL_R16_SNORM, GLSL_TYPE_FLOAT, 130, 0, true },
1355                { "r8_snorm", GL_R8_SNORM, GLSL_TYPE_FLOAT, 130, 0, true }
1356             };
1357
1358             for (unsigned i = 0; i < ARRAY_SIZE(map); i++) {
1359                if ((state->is_version(map[i].required_glsl,
1360                                       map[i].required_essl) ||
1361                     (state->NV_image_formats_enable &&
1362                      map[i].nv_image_formats)) &&
1363                    match_layout_qualifier($1, map[i].name, state) == 0) {
1364                   $$.flags.q.explicit_image_format = 1;
1365                   $$.image_format = map[i].format;
1366                   $$.image_base_type = map[i].base_type;
1367                   break;
1368                }
1369             }
1370          }
1371       }
1372
1373       if (!$$.flags.i) {
1374          if (match_layout_qualifier($1, "early_fragment_tests", state) == 0) {
1375             /* From section 4.4.1.3 of the GLSL 4.50 specification
1376              * (Fragment Shader Inputs):
1377              *
1378              *  "Fragment shaders also allow the following layout
1379              *   qualifier on in only (not with variable declarations)
1380              *     layout-qualifier-id
1381              *        early_fragment_tests
1382              *   [...]"
1383              */
1384             if (state->stage != MESA_SHADER_FRAGMENT) {
1385                _mesa_glsl_error(& @1, state,
1386                                 "early_fragment_tests layout qualifier only "
1387                                 "valid in fragment shaders");
1388             }
1389
1390             $$.flags.q.early_fragment_tests = 1;
1391          }
1392
1393          if (match_layout_qualifier($1, "inner_coverage", state) == 0) {
1394             if (state->stage != MESA_SHADER_FRAGMENT) {
1395                _mesa_glsl_error(& @1, state,
1396                                 "inner_coverage layout qualifier only "
1397                                 "valid in fragment shaders");
1398             }
1399
1400             if (state->INTEL_conservative_rasterization_enable) {
1401                $$.flags.q.inner_coverage = 1;
1402             } else {
1403                _mesa_glsl_error(& @1, state,
1404                                 "inner_coverage layout qualifier present, "
1405                                 "but the INTEL_conservative_rasterization extension "
1406                                 "is not enabled.");
1407             }
1408          }
1409
1410          if (match_layout_qualifier($1, "post_depth_coverage", state) == 0) {
1411             if (state->stage != MESA_SHADER_FRAGMENT) {
1412                _mesa_glsl_error(& @1, state,
1413                                 "post_depth_coverage layout qualifier only "
1414                                 "valid in fragment shaders");
1415             }
1416
1417             if (state->ARB_post_depth_coverage_enable ||
1418                 state->INTEL_conservative_rasterization_enable) {
1419                $$.flags.q.post_depth_coverage = 1;
1420             } else {
1421                _mesa_glsl_error(& @1, state,
1422                                 "post_depth_coverage layout qualifier present, "
1423                                 "but the GL_ARB_post_depth_coverage extension "
1424                                 "is not enabled.");
1425             }
1426          }
1427
1428          if ($$.flags.q.post_depth_coverage && $$.flags.q.inner_coverage) {
1429             _mesa_glsl_error(& @1, state,
1430                              "post_depth_coverage & inner_coverage layout qualifiers "
1431                              "are mutually exclusive");
1432          }
1433       }
1434
1435       const bool pixel_interlock_ordered = match_layout_qualifier($1,
1436          "pixel_interlock_ordered", state) == 0;
1437       const bool pixel_interlock_unordered = match_layout_qualifier($1,
1438          "pixel_interlock_unordered", state) == 0;
1439       const bool sample_interlock_ordered = match_layout_qualifier($1,
1440          "sample_interlock_ordered", state) == 0;
1441       const bool sample_interlock_unordered = match_layout_qualifier($1,
1442          "sample_interlock_unordered", state) == 0;
1443
1444       if (pixel_interlock_ordered + pixel_interlock_unordered +
1445           sample_interlock_ordered + sample_interlock_unordered > 0 &&
1446           state->stage != MESA_SHADER_FRAGMENT) {
1447          _mesa_glsl_error(& @1, state, "interlock layout qualifiers: "
1448                           "pixel_interlock_ordered, pixel_interlock_unordered, "
1449                           "sample_interlock_ordered and sample_interlock_unordered, "
1450                           "only valid in fragment shader input layout declaration.");
1451       } else if (pixel_interlock_ordered + pixel_interlock_unordered +
1452                  sample_interlock_ordered + sample_interlock_unordered > 0 &&
1453                  !state->ARB_fragment_shader_interlock_enable &&
1454                  !state->NV_fragment_shader_interlock_enable) {
1455          _mesa_glsl_error(& @1, state,
1456                           "interlock layout qualifier present, but the "
1457                           "GL_ARB_fragment_shader_interlock or "
1458                           "GL_NV_fragment_shader_interlock extension is not "
1459                           "enabled.");
1460       } else {
1461          $$.flags.q.pixel_interlock_ordered = pixel_interlock_ordered;
1462          $$.flags.q.pixel_interlock_unordered = pixel_interlock_unordered;
1463          $$.flags.q.sample_interlock_ordered = sample_interlock_ordered;
1464          $$.flags.q.sample_interlock_unordered = sample_interlock_unordered;
1465       }
1466
1467       /* Layout qualifiers for tessellation evaluation shaders. */
1468       if (!$$.flags.i) {
1469          static const struct {
1470             const char *s;
1471             GLenum e;
1472          } map[] = {
1473                  /* triangles already parsed by gs-specific code */
1474                  { "quads", GL_QUADS },
1475                  { "isolines", GL_ISOLINES },
1476          };
1477          for (unsigned i = 0; i < ARRAY_SIZE(map); i++) {
1478             if (match_layout_qualifier($1, map[i].s, state) == 0) {
1479                $$.flags.q.prim_type = 1;
1480                $$.prim_type = map[i].e;
1481                break;
1482             }
1483          }
1484
1485          if ($$.flags.i && !state->has_tessellation_shader()) {
1486             _mesa_glsl_error(& @1, state,
1487                              "primitive mode qualifier `%s' requires "
1488                              "GLSL 4.00 or ARB_tessellation_shader", $1);
1489          }
1490       }
1491       if (!$$.flags.i) {
1492          static const struct {
1493             const char *s;
1494             enum gl_tess_spacing e;
1495          } map[] = {
1496                  { "equal_spacing", TESS_SPACING_EQUAL },
1497                  { "fractional_odd_spacing", TESS_SPACING_FRACTIONAL_ODD },
1498                  { "fractional_even_spacing", TESS_SPACING_FRACTIONAL_EVEN },
1499          };
1500          for (unsigned i = 0; i < ARRAY_SIZE(map); i++) {
1501             if (match_layout_qualifier($1, map[i].s, state) == 0) {
1502                $$.flags.q.vertex_spacing = 1;
1503                $$.vertex_spacing = map[i].e;
1504                break;
1505             }
1506          }
1507
1508          if ($$.flags.i && !state->has_tessellation_shader()) {
1509             _mesa_glsl_error(& @1, state,
1510                              "vertex spacing qualifier `%s' requires "
1511                              "GLSL 4.00 or ARB_tessellation_shader", $1);
1512          }
1513       }
1514       if (!$$.flags.i) {
1515          if (match_layout_qualifier($1, "cw", state) == 0) {
1516             $$.flags.q.ordering = 1;
1517             $$.ordering = GL_CW;
1518          } else if (match_layout_qualifier($1, "ccw", state) == 0) {
1519             $$.flags.q.ordering = 1;
1520             $$.ordering = GL_CCW;
1521          }
1522
1523          if ($$.flags.i && !state->has_tessellation_shader()) {
1524             _mesa_glsl_error(& @1, state,
1525                              "ordering qualifier `%s' requires "
1526                              "GLSL 4.00 or ARB_tessellation_shader", $1);
1527          }
1528       }
1529       if (!$$.flags.i) {
1530          if (match_layout_qualifier($1, "point_mode", state) == 0) {
1531             $$.flags.q.point_mode = 1;
1532             $$.point_mode = true;
1533          }
1534
1535          if ($$.flags.i && !state->has_tessellation_shader()) {
1536             _mesa_glsl_error(& @1, state,
1537                              "qualifier `point_mode' requires "
1538                              "GLSL 4.00 or ARB_tessellation_shader");
1539          }
1540       }
1541
1542       if (!$$.flags.i) {
1543          static const struct {
1544             const char *s;
1545             uint32_t mask;
1546          } map[] = {
1547                  { "blend_support_multiply",       BLEND_MULTIPLY },
1548                  { "blend_support_screen",         BLEND_SCREEN },
1549                  { "blend_support_overlay",        BLEND_OVERLAY },
1550                  { "blend_support_darken",         BLEND_DARKEN },
1551                  { "blend_support_lighten",        BLEND_LIGHTEN },
1552                  { "blend_support_colordodge",     BLEND_COLORDODGE },
1553                  { "blend_support_colorburn",      BLEND_COLORBURN },
1554                  { "blend_support_hardlight",      BLEND_HARDLIGHT },
1555                  { "blend_support_softlight",      BLEND_SOFTLIGHT },
1556                  { "blend_support_difference",     BLEND_DIFFERENCE },
1557                  { "blend_support_exclusion",      BLEND_EXCLUSION },
1558                  { "blend_support_hsl_hue",        BLEND_HSL_HUE },
1559                  { "blend_support_hsl_saturation", BLEND_HSL_SATURATION },
1560                  { "blend_support_hsl_color",      BLEND_HSL_COLOR },
1561                  { "blend_support_hsl_luminosity", BLEND_HSL_LUMINOSITY },
1562                  { "blend_support_all_equations",  BLEND_ALL },
1563          };
1564          for (unsigned i = 0; i < ARRAY_SIZE(map); i++) {
1565             if (match_layout_qualifier($1, map[i].s, state) == 0) {
1566                $$.flags.q.blend_support = 1;
1567                state->fs_blend_support |= map[i].mask;
1568                break;
1569             }
1570          }
1571
1572          if ($$.flags.i &&
1573              !state->KHR_blend_equation_advanced_enable &&
1574              !state->is_version(0, 320)) {
1575             _mesa_glsl_error(& @1, state,
1576                              "advanced blending layout qualifiers require "
1577                              "ESSL 3.20 or KHR_blend_equation_advanced");
1578          }
1579
1580          if ($$.flags.i && state->stage != MESA_SHADER_FRAGMENT) {
1581             _mesa_glsl_error(& @1, state,
1582                              "advanced blending layout qualifiers only "
1583                              "valid in fragment shaders");
1584          }
1585       }
1586
1587       /* Layout qualifiers for ARB_compute_variable_group_size. */
1588       if (!$$.flags.i) {
1589          if (match_layout_qualifier($1, "local_size_variable", state) == 0) {
1590             $$.flags.q.local_size_variable = 1;
1591          }
1592
1593          if ($$.flags.i && !state->ARB_compute_variable_group_size_enable) {
1594             _mesa_glsl_error(& @1, state,
1595                              "qualifier `local_size_variable` requires "
1596                              "ARB_compute_variable_group_size");
1597          }
1598       }
1599
1600       /* Layout qualifiers for ARB_bindless_texture. */
1601       if (!$$.flags.i) {
1602          if (match_layout_qualifier($1, "bindless_sampler", state) == 0)
1603             $$.flags.q.bindless_sampler = 1;
1604          if (match_layout_qualifier($1, "bound_sampler", state) == 0)
1605             $$.flags.q.bound_sampler = 1;
1606
1607          if (state->has_shader_image_load_store()) {
1608             if (match_layout_qualifier($1, "bindless_image", state) == 0)
1609                $$.flags.q.bindless_image = 1;
1610             if (match_layout_qualifier($1, "bound_image", state) == 0)
1611                $$.flags.q.bound_image = 1;
1612          }
1613
1614          if ($$.flags.i && !state->has_bindless()) {
1615             _mesa_glsl_error(& @1, state,
1616                              "qualifier `%s` requires "
1617                              "ARB_bindless_texture", $1);
1618          }
1619       }
1620
1621       if (!$$.flags.i &&
1622           state->EXT_shader_framebuffer_fetch_non_coherent_enable) {
1623          if (match_layout_qualifier($1, "noncoherent", state) == 0)
1624             $$.flags.q.non_coherent = 1;
1625       }
1626
1627       if (!$$.flags.i) {
1628          _mesa_glsl_error(& @1, state, "unrecognized layout identifier "
1629                           "`%s'", $1);
1630          YYERROR;
1631       }
1632    }
1633    | any_identifier '=' constant_expression
1634    {
1635       memset(& $$, 0, sizeof($$));
1636       void *ctx = state->linalloc;
1637
1638       if ($3->oper != ast_int_constant &&
1639           $3->oper != ast_uint_constant &&
1640           !state->has_enhanced_layouts()) {
1641          _mesa_glsl_error(& @1, state,
1642                           "compile-time constant expressions require "
1643                           "GLSL 4.40 or ARB_enhanced_layouts");
1644       }
1645
1646       if (match_layout_qualifier("align", $1, state) == 0) {
1647          if (!state->has_enhanced_layouts()) {
1648             _mesa_glsl_error(& @1, state,
1649                              "align qualifier requires "
1650                              "GLSL 4.40 or ARB_enhanced_layouts");
1651          } else {
1652             $$.flags.q.explicit_align = 1;
1653             $$.align = $3;
1654          }
1655       }
1656
1657       if (match_layout_qualifier("location", $1, state) == 0) {
1658          $$.flags.q.explicit_location = 1;
1659
1660          if ($$.flags.q.attribute == 1 &&
1661              state->ARB_explicit_attrib_location_warn) {
1662             _mesa_glsl_warning(& @1, state,
1663                                "GL_ARB_explicit_attrib_location layout "
1664                                "identifier `%s' used", $1);
1665          }
1666          $$.location = $3;
1667       }
1668
1669       if (match_layout_qualifier("component", $1, state) == 0) {
1670          if (!state->has_enhanced_layouts()) {
1671             _mesa_glsl_error(& @1, state,
1672                              "component qualifier requires "
1673                              "GLSL 4.40 or ARB_enhanced_layouts");
1674          } else {
1675             $$.flags.q.explicit_component = 1;
1676             $$.component = $3;
1677          }
1678       }
1679
1680       if (match_layout_qualifier("index", $1, state) == 0) {
1681          if (state->es_shader && !state->EXT_blend_func_extended_enable) {
1682             _mesa_glsl_error(& @3, state, "index layout qualifier requires EXT_blend_func_extended");
1683             YYERROR;
1684          }
1685
1686          $$.flags.q.explicit_index = 1;
1687          $$.index = $3;
1688       }
1689
1690       if ((state->has_420pack_or_es31() ||
1691            state->has_atomic_counters() ||
1692            state->has_shader_storage_buffer_objects()) &&
1693           match_layout_qualifier("binding", $1, state) == 0) {
1694          $$.flags.q.explicit_binding = 1;
1695          $$.binding = $3;
1696       }
1697
1698       if ((state->has_atomic_counters() ||
1699            state->has_enhanced_layouts()) &&
1700           match_layout_qualifier("offset", $1, state) == 0) {
1701          $$.flags.q.explicit_offset = 1;
1702          $$.offset = $3;
1703       }
1704
1705       if (match_layout_qualifier("max_vertices", $1, state) == 0) {
1706          $$.flags.q.max_vertices = 1;
1707          $$.max_vertices = new(ctx) ast_layout_expression(@1, $3);
1708          if (!state->has_geometry_shader()) {
1709             _mesa_glsl_error(& @3, state,
1710                              "#version 150 max_vertices qualifier "
1711                              "specified", $3);
1712          }
1713       }
1714
1715       if (state->stage == MESA_SHADER_GEOMETRY) {
1716          if (match_layout_qualifier("stream", $1, state) == 0 &&
1717              state->check_explicit_attrib_stream_allowed(& @3)) {
1718             $$.flags.q.stream = 1;
1719             $$.flags.q.explicit_stream = 1;
1720             $$.stream = $3;
1721          }
1722       }
1723
1724       if (state->has_enhanced_layouts()) {
1725          if (match_layout_qualifier("xfb_buffer", $1, state) == 0) {
1726             $$.flags.q.xfb_buffer = 1;
1727             $$.flags.q.explicit_xfb_buffer = 1;
1728             $$.xfb_buffer = $3;
1729          }
1730
1731          if (match_layout_qualifier("xfb_offset", $1, state) == 0) {
1732             $$.flags.q.explicit_xfb_offset = 1;
1733             $$.offset = $3;
1734          }
1735
1736          if (match_layout_qualifier("xfb_stride", $1, state) == 0) {
1737             $$.flags.q.xfb_stride = 1;
1738             $$.flags.q.explicit_xfb_stride = 1;
1739             $$.xfb_stride = $3;
1740          }
1741       }
1742
1743       static const char * const local_size_qualifiers[3] = {
1744          "local_size_x",
1745          "local_size_y",
1746          "local_size_z",
1747       };
1748       for (int i = 0; i < 3; i++) {
1749          if (match_layout_qualifier(local_size_qualifiers[i], $1,
1750                                     state) == 0) {
1751             if (!state->has_compute_shader()) {
1752                _mesa_glsl_error(& @3, state,
1753                                 "%s qualifier requires GLSL 4.30 or "
1754                                 "GLSL ES 3.10 or ARB_compute_shader",
1755                                 local_size_qualifiers[i]);
1756                YYERROR;
1757             } else {
1758                $$.flags.q.local_size |= (1 << i);
1759                $$.local_size[i] = new(ctx) ast_layout_expression(@1, $3);
1760             }
1761             break;
1762          }
1763       }
1764
1765       if (match_layout_qualifier("invocations", $1, state) == 0) {
1766          $$.flags.q.invocations = 1;
1767          $$.invocations = new(ctx) ast_layout_expression(@1, $3);
1768          if (!state->is_version(400, 320) &&
1769              !state->ARB_gpu_shader5_enable &&
1770              !state->OES_geometry_shader_enable &&
1771              !state->EXT_geometry_shader_enable) {
1772             _mesa_glsl_error(& @3, state,
1773                              "GL_ARB_gpu_shader5 invocations "
1774                              "qualifier specified", $3);
1775          }
1776       }
1777
1778       /* Layout qualifiers for tessellation control shaders. */
1779       if (match_layout_qualifier("vertices", $1, state) == 0) {
1780          $$.flags.q.vertices = 1;
1781          $$.vertices = new(ctx) ast_layout_expression(@1, $3);
1782          if (!state->has_tessellation_shader()) {
1783             _mesa_glsl_error(& @1, state,
1784                              "vertices qualifier requires GLSL 4.00 or "
1785                              "ARB_tessellation_shader");
1786          }
1787       }
1788
1789       /* If the identifier didn't match any known layout identifiers,
1790        * emit an error.
1791        */
1792       if (!$$.flags.i) {
1793          _mesa_glsl_error(& @1, state, "unrecognized layout identifier "
1794                           "`%s'", $1);
1795          YYERROR;
1796       }
1797    }
1798    | interface_block_layout_qualifier
1799    {
1800       $$ = $1;
1801       /* Layout qualifiers for ARB_uniform_buffer_object. */
1802       if ($$.flags.q.uniform && !state->has_uniform_buffer_objects()) {
1803          _mesa_glsl_error(& @1, state,
1804                           "#version 140 / GL_ARB_uniform_buffer_object "
1805                           "layout qualifier `%s' is used", $1);
1806       } else if ($$.flags.q.uniform && state->ARB_uniform_buffer_object_warn) {
1807          _mesa_glsl_warning(& @1, state,
1808                             "#version 140 / GL_ARB_uniform_buffer_object "
1809                             "layout qualifier `%s' is used", $1);
1810       }
1811    }
1812    ;
1813
1814 /* This is a separate language rule because we parse these as tokens
1815  * (due to them being reserved keywords) instead of identifiers like
1816  * most qualifiers.  See the any_identifier path of
1817  * layout_qualifier_id for the others.
1818  *
1819  * Note that since layout qualifiers are case-insensitive in desktop
1820  * GLSL, all of these qualifiers need to be handled as identifiers as
1821  * well (by the any_identifier path of layout_qualifier_id).
1822  */
1823 interface_block_layout_qualifier:
1824    ROW_MAJOR
1825    {
1826       memset(& $$, 0, sizeof($$));
1827       $$.flags.q.row_major = 1;
1828    }
1829    | PACKED_TOK
1830    {
1831       memset(& $$, 0, sizeof($$));
1832       $$.flags.q.packed = 1;
1833    }
1834    | SHARED
1835    {
1836       memset(& $$, 0, sizeof($$));
1837       $$.flags.q.shared = 1;
1838    }
1839    ;
1840
1841 subroutine_qualifier:
1842    SUBROUTINE
1843    {
1844       memset(& $$, 0, sizeof($$));
1845       $$.flags.q.subroutine = 1;
1846    }
1847    | SUBROUTINE '(' subroutine_type_list ')'
1848    {
1849       memset(& $$, 0, sizeof($$));
1850       $$.flags.q.subroutine = 1;
1851       $$.subroutine_list = $3;
1852    }
1853    ;
1854
1855 subroutine_type_list:
1856    any_identifier
1857    {
1858         void *ctx = state->linalloc;
1859         ast_declaration *decl = new(ctx)  ast_declaration($1, NULL, NULL);
1860         decl->set_location(@1);
1861
1862         $$ = new(ctx) ast_subroutine_list();
1863         $$->declarations.push_tail(&decl->link);
1864    }
1865    | subroutine_type_list ',' any_identifier
1866    {
1867         void *ctx = state->linalloc;
1868         ast_declaration *decl = new(ctx)  ast_declaration($3, NULL, NULL);
1869         decl->set_location(@3);
1870
1871         $$ = $1;
1872         $$->declarations.push_tail(&decl->link);
1873    }
1874    ;
1875
1876 interpolation_qualifier:
1877    SMOOTH
1878    {
1879       memset(& $$, 0, sizeof($$));
1880       $$.flags.q.smooth = 1;
1881    }
1882    | FLAT
1883    {
1884       memset(& $$, 0, sizeof($$));
1885       $$.flags.q.flat = 1;
1886    }
1887    | NOPERSPECTIVE
1888    {
1889       memset(& $$, 0, sizeof($$));
1890       $$.flags.q.noperspective = 1;
1891    }
1892    ;
1893
1894 type_qualifier:
1895    /* Single qualifiers */
1896    INVARIANT
1897    {
1898       memset(& $$, 0, sizeof($$));
1899       $$.flags.q.invariant = 1;
1900    }
1901    | PRECISE
1902    {
1903       memset(& $$, 0, sizeof($$));
1904       $$.flags.q.precise = 1;
1905    }
1906    | auxiliary_storage_qualifier
1907    | storage_qualifier
1908    | interpolation_qualifier
1909    | layout_qualifier
1910    | memory_qualifier
1911    | subroutine_qualifier
1912    | precision_qualifier
1913    {
1914       memset(&$$, 0, sizeof($$));
1915       $$.precision = $1;
1916    }
1917
1918    /* Multiple qualifiers:
1919     * In GLSL 4.20, these can be specified in any order.  In earlier versions,
1920     * they appear in this order (see GLSL 1.50 section 4.7 & comments below):
1921     *
1922     *    invariant interpolation auxiliary storage precision  ...or...
1923     *    layout storage precision
1924     *
1925     * Each qualifier's rule ensures that the accumulated qualifiers on the right
1926     * side don't contain any that must appear on the left hand side.
1927     * For example, when processing a storage qualifier, we check that there are
1928     * no auxiliary, interpolation, layout, invariant, or precise qualifiers to the right.
1929     */
1930    | PRECISE type_qualifier
1931    {
1932       if ($2.flags.q.precise)
1933          _mesa_glsl_error(&@1, state, "duplicate \"precise\" qualifier");
1934
1935       $$ = $2;
1936       $$.flags.q.precise = 1;
1937    }
1938    | INVARIANT type_qualifier
1939    {
1940       if ($2.flags.q.invariant)
1941          _mesa_glsl_error(&@1, state, "duplicate \"invariant\" qualifier");
1942
1943       if (!state->has_420pack_or_es31() && $2.flags.q.precise)
1944          _mesa_glsl_error(&@1, state,
1945                           "\"invariant\" must come after \"precise\"");
1946
1947       $$ = $2;
1948       $$.flags.q.invariant = 1;
1949
1950       /* GLSL ES 3.00 spec, section 4.6.1 "The Invariant Qualifier":
1951        *
1952        * "Only variables output from a shader can be candidates for invariance.
1953        * This includes user-defined output variables and the built-in output
1954        * variables. As only outputs can be declared as invariant, an invariant
1955        * output from one shader stage will still match an input of a subsequent
1956        * stage without the input being declared as invariant."
1957        *
1958        * On the desktop side, this text first appears in GLSL 4.30.
1959        */
1960       if (state->is_version(430, 300) && $$.flags.q.in)
1961          _mesa_glsl_error(&@1, state, "invariant qualifiers cannot be used with shader inputs");
1962    }
1963    | interpolation_qualifier type_qualifier
1964    {
1965       /* Section 4.3 of the GLSL 1.40 specification states:
1966        * "...qualified with one of these interpolation qualifiers"
1967        *
1968        * GLSL 1.30 claims to allow "one or more", but insists that:
1969        * "These interpolation qualifiers may only precede the qualifiers in,
1970        *  centroid in, out, or centroid out in a declaration."
1971        *
1972        * ...which means that e.g. smooth can't precede smooth, so there can be
1973        * only one after all, and the 1.40 text is a clarification, not a change.
1974        */
1975       if ($2.has_interpolation())
1976          _mesa_glsl_error(&@1, state, "duplicate interpolation qualifier");
1977
1978       if (!state->has_420pack_or_es31() &&
1979           ($2.flags.q.precise || $2.flags.q.invariant)) {
1980          _mesa_glsl_error(&@1, state, "interpolation qualifiers must come "
1981                           "after \"precise\" or \"invariant\"");
1982       }
1983
1984       $$ = $1;
1985       $$.merge_qualifier(&@1, state, $2, false);
1986    }
1987    | layout_qualifier type_qualifier
1988    {
1989       /* In the absence of ARB_shading_language_420pack, layout qualifiers may
1990        * appear no later than auxiliary storage qualifiers. There is no
1991        * particularly clear spec language mandating this, but in all examples
1992        * the layout qualifier precedes the storage qualifier.
1993        *
1994        * We allow combinations of layout with interpolation, invariant or
1995        * precise qualifiers since these are useful in ARB_separate_shader_objects.
1996        * There is no clear spec guidance on this either.
1997        */
1998       $$ = $1;
1999       $$.merge_qualifier(& @1, state, $2, false, $2.has_layout());
2000    }
2001    | subroutine_qualifier type_qualifier
2002    {
2003       $$ = $1;
2004       $$.merge_qualifier(&@1, state, $2, false);
2005    }
2006    | auxiliary_storage_qualifier type_qualifier
2007    {
2008       if ($2.has_auxiliary_storage()) {
2009          _mesa_glsl_error(&@1, state,
2010                           "duplicate auxiliary storage qualifier (centroid or sample)");
2011       }
2012
2013       if (!state->has_420pack_or_es31() &&
2014           ($2.flags.q.precise || $2.flags.q.invariant ||
2015            $2.has_interpolation() || $2.has_layout())) {
2016          _mesa_glsl_error(&@1, state, "auxiliary storage qualifiers must come "
2017                           "just before storage qualifiers");
2018       }
2019       $$ = $1;
2020       $$.merge_qualifier(&@1, state, $2, false);
2021    }
2022    | storage_qualifier type_qualifier
2023    {
2024       /* Section 4.3 of the GLSL 1.20 specification states:
2025        * "Variable declarations may have a storage qualifier specified..."
2026        *  1.30 clarifies this to "may have one storage qualifier".
2027        */
2028       if ($2.has_storage())
2029          _mesa_glsl_error(&@1, state, "duplicate storage qualifier");
2030
2031       if (!state->has_420pack_or_es31() &&
2032           ($2.flags.q.precise || $2.flags.q.invariant || $2.has_interpolation() ||
2033            $2.has_layout() || $2.has_auxiliary_storage())) {
2034          _mesa_glsl_error(&@1, state, "storage qualifiers must come after "
2035                           "precise, invariant, interpolation, layout and auxiliary "
2036                           "storage qualifiers");
2037       }
2038
2039       $$ = $1;
2040       $$.merge_qualifier(&@1, state, $2, false);
2041    }
2042    | precision_qualifier type_qualifier
2043    {
2044       if ($2.precision != ast_precision_none)
2045          _mesa_glsl_error(&@1, state, "duplicate precision qualifier");
2046
2047       if (!(state->has_420pack_or_es31()) &&
2048           $2.flags.i != 0)
2049          _mesa_glsl_error(&@1, state, "precision qualifiers must come last");
2050
2051       $$ = $2;
2052       $$.precision = $1;
2053    }
2054    | memory_qualifier type_qualifier
2055    {
2056       $$ = $1;
2057       $$.merge_qualifier(&@1, state, $2, false);
2058    }
2059    ;
2060
2061 auxiliary_storage_qualifier:
2062    CENTROID
2063    {
2064       memset(& $$, 0, sizeof($$));
2065       $$.flags.q.centroid = 1;
2066    }
2067    | SAMPLE
2068    {
2069       memset(& $$, 0, sizeof($$));
2070       $$.flags.q.sample = 1;
2071    }
2072    | PATCH
2073    {
2074       memset(& $$, 0, sizeof($$));
2075       $$.flags.q.patch = 1;
2076    }
2077
2078 storage_qualifier:
2079    CONST_TOK
2080    {
2081       memset(& $$, 0, sizeof($$));
2082       $$.flags.q.constant = 1;
2083    }
2084    | ATTRIBUTE
2085    {
2086       memset(& $$, 0, sizeof($$));
2087       $$.flags.q.attribute = 1;
2088    }
2089    | VARYING
2090    {
2091       memset(& $$, 0, sizeof($$));
2092       $$.flags.q.varying = 1;
2093    }
2094    | IN_TOK
2095    {
2096       memset(& $$, 0, sizeof($$));
2097       $$.flags.q.in = 1;
2098    }
2099    | OUT_TOK
2100    {
2101       memset(& $$, 0, sizeof($$));
2102       $$.flags.q.out = 1;
2103
2104       if (state->stage == MESA_SHADER_GEOMETRY &&
2105           state->has_explicit_attrib_stream()) {
2106          /* Section 4.3.8.2 (Output Layout Qualifiers) of the GLSL 4.00
2107           * spec says:
2108           *
2109           *     "If the block or variable is declared with the stream
2110           *     identifier, it is associated with the specified stream;
2111           *     otherwise, it is associated with the current default stream."
2112           */
2113           $$.flags.q.stream = 1;
2114           $$.flags.q.explicit_stream = 0;
2115           $$.stream = state->out_qualifier->stream;
2116       }
2117
2118       if (state->has_enhanced_layouts()) {
2119           $$.flags.q.xfb_buffer = 1;
2120           $$.flags.q.explicit_xfb_buffer = 0;
2121           $$.xfb_buffer = state->out_qualifier->xfb_buffer;
2122       }
2123    }
2124    | INOUT_TOK
2125    {
2126       memset(& $$, 0, sizeof($$));
2127       $$.flags.q.in = 1;
2128       $$.flags.q.out = 1;
2129
2130       if (!state->has_framebuffer_fetch() ||
2131           !state->is_version(130, 300) ||
2132           state->stage != MESA_SHADER_FRAGMENT)
2133          _mesa_glsl_error(&@1, state, "A single interface variable cannot be "
2134                           "declared as both input and output");
2135    }
2136    | UNIFORM
2137    {
2138       memset(& $$, 0, sizeof($$));
2139       $$.flags.q.uniform = 1;
2140    }
2141    | BUFFER
2142    {
2143       memset(& $$, 0, sizeof($$));
2144       $$.flags.q.buffer = 1;
2145    }
2146    | SHARED
2147    {
2148       memset(& $$, 0, sizeof($$));
2149       $$.flags.q.shared_storage = 1;
2150    }
2151    ;
2152
2153 memory_qualifier:
2154    COHERENT
2155    {
2156       memset(& $$, 0, sizeof($$));
2157       $$.flags.q.coherent = 1;
2158    }
2159    | VOLATILE
2160    {
2161       memset(& $$, 0, sizeof($$));
2162       $$.flags.q._volatile = 1;
2163    }
2164    | RESTRICT
2165    {
2166       STATIC_ASSERT(sizeof($$.flags.q) <= sizeof($$.flags.i));
2167       memset(& $$, 0, sizeof($$));
2168       $$.flags.q.restrict_flag = 1;
2169    }
2170    | READONLY
2171    {
2172       memset(& $$, 0, sizeof($$));
2173       $$.flags.q.read_only = 1;
2174    }
2175    | WRITEONLY
2176    {
2177       memset(& $$, 0, sizeof($$));
2178       $$.flags.q.write_only = 1;
2179    }
2180    ;
2181
2182 array_specifier:
2183    '[' ']'
2184    {
2185       void *ctx = state->linalloc;
2186       $$ = new(ctx) ast_array_specifier(@1, new(ctx) ast_expression(
2187                                                   ast_unsized_array_dim, NULL,
2188                                                   NULL, NULL));
2189       $$->set_location_range(@1, @2);
2190    }
2191    | '[' constant_expression ']'
2192    {
2193       void *ctx = state->linalloc;
2194       $$ = new(ctx) ast_array_specifier(@1, $2);
2195       $$->set_location_range(@1, @3);
2196    }
2197    | array_specifier '[' ']'
2198    {
2199       void *ctx = state->linalloc;
2200       $$ = $1;
2201
2202       if (state->check_arrays_of_arrays_allowed(& @1)) {
2203          $$->add_dimension(new(ctx) ast_expression(ast_unsized_array_dim, NULL,
2204                                                    NULL, NULL));
2205       }
2206    }
2207    | array_specifier '[' constant_expression ']'
2208    {
2209       $$ = $1;
2210
2211       if (state->check_arrays_of_arrays_allowed(& @1)) {
2212          $$->add_dimension($3);
2213       }
2214    }
2215    ;
2216
2217 type_specifier:
2218    type_specifier_nonarray
2219    | type_specifier_nonarray array_specifier
2220    {
2221       $$ = $1;
2222       $$->array_specifier = $2;
2223    }
2224    ;
2225
2226 type_specifier_nonarray:
2227    basic_type_specifier_nonarray
2228    {
2229       void *ctx = state->linalloc;
2230       $$ = new(ctx) ast_type_specifier($1);
2231       $$->set_location(@1);
2232    }
2233    | struct_specifier
2234    {
2235       void *ctx = state->linalloc;
2236       $$ = new(ctx) ast_type_specifier($1);
2237       $$->set_location(@1);
2238    }
2239    | TYPE_IDENTIFIER
2240    {
2241       void *ctx = state->linalloc;
2242       $$ = new(ctx) ast_type_specifier($1);
2243       $$->set_location(@1);
2244    }
2245    ;
2246
2247 basic_type_specifier_nonarray:
2248    VOID_TOK                 { $$ = glsl_type::void_type; }
2249    | BASIC_TYPE_TOK         { $$ = $1; };
2250    ;
2251
2252 precision_qualifier:
2253    HIGHP
2254    {
2255       state->check_precision_qualifiers_allowed(&@1);
2256       $$ = ast_precision_high;
2257    }
2258    | MEDIUMP
2259    {
2260       state->check_precision_qualifiers_allowed(&@1);
2261       $$ = ast_precision_medium;
2262    }
2263    | LOWP
2264    {
2265       state->check_precision_qualifiers_allowed(&@1);
2266       $$ = ast_precision_low;
2267    }
2268    ;
2269
2270 struct_specifier:
2271    STRUCT any_identifier '{' struct_declaration_list '}'
2272    {
2273       void *ctx = state->linalloc;
2274       $$ = new(ctx) ast_struct_specifier($2, $4);
2275       $$->set_location_range(@2, @5);
2276       state->symbols->add_type($2, glsl_type::void_type);
2277    }
2278    | STRUCT '{' struct_declaration_list '}'
2279    {
2280       void *ctx = state->linalloc;
2281
2282       /* All anonymous structs have the same name. This simplifies matching of
2283        * globals whose type is an unnamed struct.
2284        *
2285        * It also avoids a memory leak when the same shader is compiled over and
2286        * over again.
2287        */
2288       $$ = new(ctx) ast_struct_specifier("#anon_struct", $3);
2289
2290       $$->set_location_range(@2, @4);
2291    }
2292    ;
2293
2294 struct_declaration_list:
2295    struct_declaration
2296    {
2297       $$ = $1;
2298       $1->link.self_link();
2299    }
2300    | struct_declaration_list struct_declaration
2301    {
2302       $$ = $1;
2303       $$->link.insert_before(& $2->link);
2304    }
2305    ;
2306
2307 struct_declaration:
2308    fully_specified_type struct_declarator_list ';'
2309    {
2310       void *ctx = state->linalloc;
2311       ast_fully_specified_type *const type = $1;
2312       type->set_location(@1);
2313
2314       if (state->has_bindless()) {
2315          ast_type_qualifier input_layout_mask;
2316
2317          /* Allow to declare qualifiers for images. */
2318          input_layout_mask.flags.i = 0;
2319          input_layout_mask.flags.q.coherent = 1;
2320          input_layout_mask.flags.q._volatile = 1;
2321          input_layout_mask.flags.q.restrict_flag = 1;
2322          input_layout_mask.flags.q.read_only = 1;
2323          input_layout_mask.flags.q.write_only = 1;
2324          input_layout_mask.flags.q.explicit_image_format = 1;
2325
2326          if ((type->qualifier.flags.i & ~input_layout_mask.flags.i) != 0) {
2327             _mesa_glsl_error(&@1, state,
2328                              "only precision and image qualifiers may be "
2329                              "applied to structure members");
2330          }
2331       } else {
2332          if (type->qualifier.flags.i != 0)
2333             _mesa_glsl_error(&@1, state,
2334                              "only precision qualifiers may be applied to "
2335                              "structure members");
2336       }
2337
2338       $$ = new(ctx) ast_declarator_list(type);
2339       $$->set_location(@2);
2340
2341       $$->declarations.push_degenerate_list_at_head(& $2->link);
2342    }
2343    ;
2344
2345 struct_declarator_list:
2346    struct_declarator
2347    {
2348       $$ = $1;
2349       $1->link.self_link();
2350    }
2351    | struct_declarator_list ',' struct_declarator
2352    {
2353       $$ = $1;
2354       $$->link.insert_before(& $3->link);
2355    }
2356    ;
2357
2358 struct_declarator:
2359    any_identifier
2360    {
2361       void *ctx = state->linalloc;
2362       $$ = new(ctx) ast_declaration($1, NULL, NULL);
2363       $$->set_location(@1);
2364    }
2365    | any_identifier array_specifier
2366    {
2367       void *ctx = state->linalloc;
2368       $$ = new(ctx) ast_declaration($1, $2, NULL);
2369       $$->set_location_range(@1, @2);
2370    }
2371    ;
2372
2373 initializer:
2374    assignment_expression
2375    | '{' initializer_list '}'
2376    {
2377       $$ = $2;
2378    }
2379    | '{' initializer_list ',' '}'
2380    {
2381       $$ = $2;
2382    }
2383    ;
2384
2385 initializer_list:
2386    initializer
2387    {
2388       void *ctx = state->linalloc;
2389       $$ = new(ctx) ast_aggregate_initializer();
2390       $$->set_location(@1);
2391       $$->expressions.push_tail(& $1->link);
2392    }
2393    | initializer_list ',' initializer
2394    {
2395       $1->expressions.push_tail(& $3->link);
2396    }
2397    ;
2398
2399 declaration_statement:
2400    declaration
2401    ;
2402
2403    // Grammar Note: labeled statements for SWITCH only; 'goto' is not
2404    // supported.
2405 statement:
2406    compound_statement        { $$ = (ast_node *) $1; }
2407    | simple_statement
2408    ;
2409
2410 simple_statement:
2411    declaration_statement
2412    | expression_statement
2413    | selection_statement
2414    | switch_statement
2415    | iteration_statement
2416    | jump_statement
2417    ;
2418
2419 compound_statement:
2420    '{' '}'
2421    {
2422       void *ctx = state->linalloc;
2423       $$ = new(ctx) ast_compound_statement(true, NULL);
2424       $$->set_location_range(@1, @2);
2425    }
2426    | '{'
2427    {
2428       state->symbols->push_scope();
2429    }
2430    statement_list '}'
2431    {
2432       void *ctx = state->linalloc;
2433       $$ = new(ctx) ast_compound_statement(true, $3);
2434       $$->set_location_range(@1, @4);
2435       state->symbols->pop_scope();
2436    }
2437    ;
2438
2439 statement_no_new_scope:
2440    compound_statement_no_new_scope { $$ = (ast_node *) $1; }
2441    | simple_statement
2442    ;
2443
2444 compound_statement_no_new_scope:
2445    '{' '}'
2446    {
2447       void *ctx = state->linalloc;
2448       $$ = new(ctx) ast_compound_statement(false, NULL);
2449       $$->set_location_range(@1, @2);
2450    }
2451    | '{' statement_list '}'
2452    {
2453       void *ctx = state->linalloc;
2454       $$ = new(ctx) ast_compound_statement(false, $2);
2455       $$->set_location_range(@1, @3);
2456    }
2457    ;
2458
2459 statement_list:
2460    statement
2461    {
2462       if ($1 == NULL) {
2463          _mesa_glsl_error(& @1, state, "<nil> statement");
2464          assert($1 != NULL);
2465       }
2466
2467       $$ = $1;
2468       $$->link.self_link();
2469    }
2470    | statement_list statement
2471    {
2472       if ($2 == NULL) {
2473          _mesa_glsl_error(& @2, state, "<nil> statement");
2474          assert($2 != NULL);
2475       }
2476       $$ = $1;
2477       $$->link.insert_before(& $2->link);
2478    }
2479    ;
2480
2481 expression_statement:
2482    ';'
2483    {
2484       void *ctx = state->linalloc;
2485       $$ = new(ctx) ast_expression_statement(NULL);
2486       $$->set_location(@1);
2487    }
2488    | expression ';'
2489    {
2490       void *ctx = state->linalloc;
2491       $$ = new(ctx) ast_expression_statement($1);
2492       $$->set_location(@1);
2493    }
2494    ;
2495
2496 selection_statement:
2497    IF '(' expression ')' selection_rest_statement
2498    {
2499       $$ = new(state->linalloc) ast_selection_statement($3, $5.then_statement,
2500                                                         $5.else_statement);
2501       $$->set_location_range(@1, @5);
2502    }
2503    ;
2504
2505 selection_rest_statement:
2506    statement ELSE statement
2507    {
2508       $$.then_statement = $1;
2509       $$.else_statement = $3;
2510    }
2511    | statement %prec THEN
2512    {
2513       $$.then_statement = $1;
2514       $$.else_statement = NULL;
2515    }
2516    ;
2517
2518 condition:
2519    expression
2520    {
2521       $$ = (ast_node *) $1;
2522    }
2523    | fully_specified_type any_identifier '=' initializer
2524    {
2525       void *ctx = state->linalloc;
2526       ast_declaration *decl = new(ctx) ast_declaration($2, NULL, $4);
2527       ast_declarator_list *declarator = new(ctx) ast_declarator_list($1);
2528       decl->set_location_range(@2, @4);
2529       declarator->set_location(@1);
2530
2531       declarator->declarations.push_tail(&decl->link);
2532       $$ = declarator;
2533    }
2534    ;
2535
2536 /*
2537  * switch_statement grammar is based on the syntax described in the body
2538  * of the GLSL spec, not in it's appendix!!!
2539  */
2540 switch_statement:
2541    SWITCH '(' expression ')' switch_body
2542    {
2543       $$ = new(state->linalloc) ast_switch_statement($3, $5);
2544       $$->set_location_range(@1, @5);
2545    }
2546    ;
2547
2548 switch_body:
2549    '{' '}'
2550    {
2551       $$ = new(state->linalloc) ast_switch_body(NULL);
2552       $$->set_location_range(@1, @2);
2553    }
2554    | '{' case_statement_list '}'
2555    {
2556       $$ = new(state->linalloc) ast_switch_body($2);
2557       $$->set_location_range(@1, @3);
2558    }
2559    ;
2560
2561 case_label:
2562    CASE expression ':'
2563    {
2564       $$ = new(state->linalloc) ast_case_label($2);
2565       $$->set_location(@2);
2566    }
2567    | DEFAULT ':'
2568    {
2569       $$ = new(state->linalloc) ast_case_label(NULL);
2570       $$->set_location(@2);
2571    }
2572    ;
2573
2574 case_label_list:
2575    case_label
2576    {
2577       ast_case_label_list *labels = new(state->linalloc) ast_case_label_list();
2578
2579       labels->labels.push_tail(& $1->link);
2580       $$ = labels;
2581       $$->set_location(@1);
2582    }
2583    | case_label_list case_label
2584    {
2585       $$ = $1;
2586       $$->labels.push_tail(& $2->link);
2587    }
2588    ;
2589
2590 case_statement:
2591    case_label_list statement
2592    {
2593       ast_case_statement *stmts = new(state->linalloc) ast_case_statement($1);
2594       stmts->set_location(@2);
2595
2596       stmts->stmts.push_tail(& $2->link);
2597       $$ = stmts;
2598    }
2599    | case_statement statement
2600    {
2601       $$ = $1;
2602       $$->stmts.push_tail(& $2->link);
2603    }
2604    ;
2605
2606 case_statement_list:
2607    case_statement
2608    {
2609       ast_case_statement_list *cases= new(state->linalloc) ast_case_statement_list();
2610       cases->set_location(@1);
2611
2612       cases->cases.push_tail(& $1->link);
2613       $$ = cases;
2614    }
2615    | case_statement_list case_statement
2616    {
2617       $$ = $1;
2618       $$->cases.push_tail(& $2->link);
2619    }
2620    ;
2621
2622 iteration_statement:
2623    WHILE '(' condition ')' statement_no_new_scope
2624    {
2625       void *ctx = state->linalloc;
2626       $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_while,
2627                                             NULL, $3, NULL, $5);
2628       $$->set_location_range(@1, @4);
2629    }
2630    | DO statement WHILE '(' expression ')' ';'
2631    {
2632       void *ctx = state->linalloc;
2633       $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_do_while,
2634                                             NULL, $5, NULL, $2);
2635       $$->set_location_range(@1, @6);
2636    }
2637    | FOR '(' for_init_statement for_rest_statement ')' statement_no_new_scope
2638    {
2639       void *ctx = state->linalloc;
2640       $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_for,
2641                                             $3, $4.cond, $4.rest, $6);
2642       $$->set_location_range(@1, @6);
2643    }
2644    ;
2645
2646 for_init_statement:
2647    expression_statement
2648    | declaration_statement
2649    ;
2650
2651 conditionopt:
2652    condition
2653    | /* empty */
2654    {
2655       $$ = NULL;
2656    }
2657    ;
2658
2659 for_rest_statement:
2660    conditionopt ';'
2661    {
2662       $$.cond = $1;
2663       $$.rest = NULL;
2664    }
2665    | conditionopt ';' expression
2666    {
2667       $$.cond = $1;
2668       $$.rest = $3;
2669    }
2670    ;
2671
2672    // Grammar Note: No 'goto'. Gotos are not supported.
2673 jump_statement:
2674    CONTINUE ';'
2675    {
2676       void *ctx = state->linalloc;
2677       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_continue, NULL);
2678       $$->set_location(@1);
2679    }
2680    | BREAK ';'
2681    {
2682       void *ctx = state->linalloc;
2683       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_break, NULL);
2684       $$->set_location(@1);
2685    }
2686    | RETURN ';'
2687    {
2688       void *ctx = state->linalloc;
2689       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, NULL);
2690       $$->set_location(@1);
2691    }
2692    | RETURN expression ';'
2693    {
2694       void *ctx = state->linalloc;
2695       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, $2);
2696       $$->set_location_range(@1, @2);
2697    }
2698    | DISCARD ';' // Fragment shader only.
2699    {
2700       void *ctx = state->linalloc;
2701       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_discard, NULL);
2702       $$->set_location(@1);
2703    }
2704    ;
2705
2706 external_declaration:
2707    function_definition      { $$ = $1; }
2708    | declaration            { $$ = $1; }
2709    | pragma_statement       { $$ = NULL; }
2710    | layout_defaults        { $$ = $1; }
2711    | ';'                    { $$ = NULL; }
2712    ;
2713
2714 function_definition:
2715    function_prototype compound_statement_no_new_scope
2716    {
2717       void *ctx = state->linalloc;
2718       $$ = new(ctx) ast_function_definition();
2719       $$->set_location_range(@1, @2);
2720       $$->prototype = $1;
2721       $$->body = $2;
2722
2723       state->symbols->pop_scope();
2724    }
2725    ;
2726
2727 /* layout_qualifieropt is packed into this rule */
2728 interface_block:
2729    basic_interface_block
2730    {
2731       $$ = $1;
2732    }
2733    | layout_qualifier interface_block
2734    {
2735       ast_interface_block *block = (ast_interface_block *) $2;
2736
2737       if (!$1.merge_qualifier(& @1, state, block->layout, false,
2738                               block->layout.has_layout())) {
2739          YYERROR;
2740       }
2741
2742       block->layout = $1;
2743
2744       $$ = block;
2745    }
2746    | memory_qualifier interface_block
2747    {
2748       ast_interface_block *block = (ast_interface_block *)$2;
2749
2750       if (!block->default_layout.flags.q.buffer) {
2751             _mesa_glsl_error(& @1, state,
2752                              "memory qualifiers can only be used in the "
2753                              "declaration of shader storage blocks");
2754       }
2755       if (!$1.merge_qualifier(& @1, state, block->layout, false)) {
2756          YYERROR;
2757       }
2758       block->layout = $1;
2759       $$ = block;
2760    }
2761    ;
2762
2763 basic_interface_block:
2764    interface_qualifier NEW_IDENTIFIER '{' member_list '}' instance_name_opt ';'
2765    {
2766       ast_interface_block *const block = $6;
2767
2768       if ($1.flags.q.uniform) {
2769          block->default_layout = *state->default_uniform_qualifier;
2770       } else if ($1.flags.q.buffer) {
2771          block->default_layout = *state->default_shader_storage_qualifier;
2772       }
2773       block->block_name = $2;
2774       block->declarations.push_degenerate_list_at_head(& $4->link);
2775
2776       _mesa_ast_process_interface_block(& @1, state, block, $1);
2777
2778       $$ = block;
2779    }
2780    ;
2781
2782 interface_qualifier:
2783    IN_TOK
2784    {
2785       memset(& $$, 0, sizeof($$));
2786       $$.flags.q.in = 1;
2787    }
2788    | OUT_TOK
2789    {
2790       memset(& $$, 0, sizeof($$));
2791       $$.flags.q.out = 1;
2792    }
2793    | UNIFORM
2794    {
2795       memset(& $$, 0, sizeof($$));
2796       $$.flags.q.uniform = 1;
2797    }
2798    | BUFFER
2799    {
2800       memset(& $$, 0, sizeof($$));
2801       $$.flags.q.buffer = 1;
2802    }
2803    | auxiliary_storage_qualifier interface_qualifier
2804    {
2805       if (!$1.flags.q.patch) {
2806          _mesa_glsl_error(&@1, state, "invalid interface qualifier");
2807       }
2808       if ($2.has_auxiliary_storage()) {
2809          _mesa_glsl_error(&@1, state, "duplicate patch qualifier");
2810       }
2811       $$ = $2;
2812       $$.flags.q.patch = 1;
2813    }
2814    ;
2815
2816 instance_name_opt:
2817    /* empty */
2818    {
2819       $$ = new(state->linalloc) ast_interface_block(NULL, NULL);
2820    }
2821    | NEW_IDENTIFIER
2822    {
2823       $$ = new(state->linalloc) ast_interface_block($1, NULL);
2824       $$->set_location(@1);
2825    }
2826    | NEW_IDENTIFIER array_specifier
2827    {
2828       $$ = new(state->linalloc) ast_interface_block($1, $2);
2829       $$->set_location_range(@1, @2);
2830    }
2831    ;
2832
2833 member_list:
2834    member_declaration
2835    {
2836       $$ = $1;
2837       $1->link.self_link();
2838    }
2839    | member_declaration member_list
2840    {
2841       $$ = $1;
2842       $2->link.insert_before(& $$->link);
2843    }
2844    ;
2845
2846 member_declaration:
2847    fully_specified_type struct_declarator_list ';'
2848    {
2849       void *ctx = state->linalloc;
2850       ast_fully_specified_type *type = $1;
2851       type->set_location(@1);
2852
2853       if (type->qualifier.flags.q.attribute) {
2854          _mesa_glsl_error(& @1, state,
2855                           "keyword 'attribute' cannot be used with "
2856                           "interface block member");
2857       } else if (type->qualifier.flags.q.varying) {
2858          _mesa_glsl_error(& @1, state,
2859                           "keyword 'varying' cannot be used with "
2860                           "interface block member");
2861       }
2862
2863       $$ = new(ctx) ast_declarator_list(type);
2864       $$->set_location(@2);
2865
2866       $$->declarations.push_degenerate_list_at_head(& $2->link);
2867    }
2868    ;
2869
2870 layout_uniform_defaults:
2871    layout_qualifier layout_uniform_defaults
2872    {
2873       $$ = $1;
2874       if (!$$.merge_qualifier(& @1, state, $2, false, true)) {
2875          YYERROR;
2876       }
2877    }
2878    | layout_qualifier UNIFORM ';'
2879    ;
2880
2881 layout_buffer_defaults:
2882    layout_qualifier layout_buffer_defaults
2883    {
2884       $$ = $1;
2885       if (!$$.merge_qualifier(& @1, state, $2, false, true)) {
2886          YYERROR;
2887       }
2888    }
2889    | layout_qualifier BUFFER ';'
2890    ;
2891
2892 layout_in_defaults:
2893    layout_qualifier layout_in_defaults
2894    {
2895       $$ = $1;
2896       if (!$$.merge_qualifier(& @1, state, $2, false, true)) {
2897          YYERROR;
2898       }
2899       if (!$$.validate_in_qualifier(& @1, state)) {
2900          YYERROR;
2901       }
2902    }
2903    | layout_qualifier IN_TOK ';'
2904    {
2905       if (!$1.validate_in_qualifier(& @1, state)) {
2906          YYERROR;
2907       }
2908    }
2909    ;
2910
2911 layout_out_defaults:
2912    layout_qualifier layout_out_defaults
2913    {
2914       $$ = $1;
2915       if (!$$.merge_qualifier(& @1, state, $2, false, true)) {
2916          YYERROR;
2917       }
2918       if (!$$.validate_out_qualifier(& @1, state)) {
2919          YYERROR;
2920       }
2921    }
2922    | layout_qualifier OUT_TOK ';'
2923    {
2924       if (!$1.validate_out_qualifier(& @1, state)) {
2925          YYERROR;
2926       }
2927    }
2928    ;
2929
2930 layout_defaults:
2931    layout_uniform_defaults
2932    {
2933       $$ = NULL;
2934       if (!state->default_uniform_qualifier->
2935              merge_qualifier(& @1, state, $1, false)) {
2936          YYERROR;
2937       }
2938       if (!state->default_uniform_qualifier->
2939              push_to_global(& @1, state)) {
2940          YYERROR;
2941       }
2942    }
2943    | layout_buffer_defaults
2944    {
2945       $$ = NULL;
2946       if (!state->default_shader_storage_qualifier->
2947              merge_qualifier(& @1, state, $1, false)) {
2948          YYERROR;
2949       }
2950       if (!state->default_shader_storage_qualifier->
2951              push_to_global(& @1, state)) {
2952          YYERROR;
2953       }
2954
2955       /* From the GLSL 4.50 spec, section 4.4.5:
2956        *
2957        *     "It is a compile-time error to specify the binding identifier for
2958        *     the global scope or for block member declarations."
2959        */
2960       if (state->default_shader_storage_qualifier->flags.q.explicit_binding) {
2961          _mesa_glsl_error(& @1, state,
2962                           "binding qualifier cannot be set for default layout");
2963       }
2964    }
2965    | layout_in_defaults
2966    {
2967       $$ = NULL;
2968       if (!$1.merge_into_in_qualifier(& @1, state, $$)) {
2969          YYERROR;
2970       }
2971       if (!state->in_qualifier->push_to_global(& @1, state)) {
2972          YYERROR;
2973       }
2974    }
2975    | layout_out_defaults
2976    {
2977       $$ = NULL;
2978       if (!$1.merge_into_out_qualifier(& @1, state, $$)) {
2979          YYERROR;
2980       }
2981       if (!state->out_qualifier->push_to_global(& @1, state)) {
2982          YYERROR;
2983       }
2984    }
2985    ;