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, false },
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, false },
1347                { "rg8", GL_RG8, GLSL_TYPE_FLOAT, 130, 0, true },
1348                { "r16", GL_R16, GLSL_TYPE_FLOAT, 130, 0, false },
1349                { "r8", GL_R8, GLSL_TYPE_FLOAT, 130, 0, true },
1350                { "rgba16_snorm", GL_RGBA16_SNORM, GLSL_TYPE_FLOAT, 130, 0, false },
1351                { "rgba8_snorm", GL_RGBA8_SNORM, GLSL_TYPE_FLOAT, 130, 310, false },
1352                { "rg16_snorm", GL_RG16_SNORM, GLSL_TYPE_FLOAT, 130, 0, false },
1353                { "rg8_snorm", GL_RG8_SNORM, GLSL_TYPE_FLOAT, 130, 0, true },
1354                { "r16_snorm", GL_R16_SNORM, GLSL_TYPE_FLOAT, 130, 0, false },
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       /* Layout qualifiers for tessellation evaluation shaders. */
1436       if (!$$.flags.i) {
1437          static const struct {
1438             const char *s;
1439             GLenum e;
1440          } map[] = {
1441                  /* triangles already parsed by gs-specific code */
1442                  { "quads", GL_QUADS },
1443                  { "isolines", GL_ISOLINES },
1444          };
1445          for (unsigned i = 0; i < ARRAY_SIZE(map); i++) {
1446             if (match_layout_qualifier($1, map[i].s, state) == 0) {
1447                $$.flags.q.prim_type = 1;
1448                $$.prim_type = map[i].e;
1449                break;
1450             }
1451          }
1452
1453          if ($$.flags.i && !state->has_tessellation_shader()) {
1454             _mesa_glsl_error(& @1, state,
1455                              "primitive mode qualifier `%s' requires "
1456                              "GLSL 4.00 or ARB_tessellation_shader", $1);
1457          }
1458       }
1459       if (!$$.flags.i) {
1460          static const struct {
1461             const char *s;
1462             enum gl_tess_spacing e;
1463          } map[] = {
1464                  { "equal_spacing", TESS_SPACING_EQUAL },
1465                  { "fractional_odd_spacing", TESS_SPACING_FRACTIONAL_ODD },
1466                  { "fractional_even_spacing", TESS_SPACING_FRACTIONAL_EVEN },
1467          };
1468          for (unsigned i = 0; i < ARRAY_SIZE(map); i++) {
1469             if (match_layout_qualifier($1, map[i].s, state) == 0) {
1470                $$.flags.q.vertex_spacing = 1;
1471                $$.vertex_spacing = map[i].e;
1472                break;
1473             }
1474          }
1475
1476          if ($$.flags.i && !state->has_tessellation_shader()) {
1477             _mesa_glsl_error(& @1, state,
1478                              "vertex spacing qualifier `%s' requires "
1479                              "GLSL 4.00 or ARB_tessellation_shader", $1);
1480          }
1481       }
1482       if (!$$.flags.i) {
1483          if (match_layout_qualifier($1, "cw", state) == 0) {
1484             $$.flags.q.ordering = 1;
1485             $$.ordering = GL_CW;
1486          } else if (match_layout_qualifier($1, "ccw", state) == 0) {
1487             $$.flags.q.ordering = 1;
1488             $$.ordering = GL_CCW;
1489          }
1490
1491          if ($$.flags.i && !state->has_tessellation_shader()) {
1492             _mesa_glsl_error(& @1, state,
1493                              "ordering qualifier `%s' requires "
1494                              "GLSL 4.00 or ARB_tessellation_shader", $1);
1495          }
1496       }
1497       if (!$$.flags.i) {
1498          if (match_layout_qualifier($1, "point_mode", state) == 0) {
1499             $$.flags.q.point_mode = 1;
1500             $$.point_mode = true;
1501          }
1502
1503          if ($$.flags.i && !state->has_tessellation_shader()) {
1504             _mesa_glsl_error(& @1, state,
1505                              "qualifier `point_mode' requires "
1506                              "GLSL 4.00 or ARB_tessellation_shader");
1507          }
1508       }
1509
1510       if (!$$.flags.i) {
1511          static const struct {
1512             const char *s;
1513             uint32_t mask;
1514          } map[] = {
1515                  { "blend_support_multiply",       BLEND_MULTIPLY },
1516                  { "blend_support_screen",         BLEND_SCREEN },
1517                  { "blend_support_overlay",        BLEND_OVERLAY },
1518                  { "blend_support_darken",         BLEND_DARKEN },
1519                  { "blend_support_lighten",        BLEND_LIGHTEN },
1520                  { "blend_support_colordodge",     BLEND_COLORDODGE },
1521                  { "blend_support_colorburn",      BLEND_COLORBURN },
1522                  { "blend_support_hardlight",      BLEND_HARDLIGHT },
1523                  { "blend_support_softlight",      BLEND_SOFTLIGHT },
1524                  { "blend_support_difference",     BLEND_DIFFERENCE },
1525                  { "blend_support_exclusion",      BLEND_EXCLUSION },
1526                  { "blend_support_hsl_hue",        BLEND_HSL_HUE },
1527                  { "blend_support_hsl_saturation", BLEND_HSL_SATURATION },
1528                  { "blend_support_hsl_color",      BLEND_HSL_COLOR },
1529                  { "blend_support_hsl_luminosity", BLEND_HSL_LUMINOSITY },
1530                  { "blend_support_all_equations",  BLEND_ALL },
1531          };
1532          for (unsigned i = 0; i < ARRAY_SIZE(map); i++) {
1533             if (match_layout_qualifier($1, map[i].s, state) == 0) {
1534                $$.flags.q.blend_support = 1;
1535                state->fs_blend_support |= map[i].mask;
1536                break;
1537             }
1538          }
1539
1540          if ($$.flags.i &&
1541              !state->KHR_blend_equation_advanced_enable &&
1542              !state->is_version(0, 320)) {
1543             _mesa_glsl_error(& @1, state,
1544                              "advanced blending layout qualifiers require "
1545                              "ESSL 3.20 or KHR_blend_equation_advanced");
1546          }
1547
1548          if ($$.flags.i && state->stage != MESA_SHADER_FRAGMENT) {
1549             _mesa_glsl_error(& @1, state,
1550                              "advanced blending layout qualifiers only "
1551                              "valid in fragment shaders");
1552          }
1553       }
1554
1555       /* Layout qualifiers for ARB_compute_variable_group_size. */
1556       if (!$$.flags.i) {
1557          if (match_layout_qualifier($1, "local_size_variable", state) == 0) {
1558             $$.flags.q.local_size_variable = 1;
1559          }
1560
1561          if ($$.flags.i && !state->ARB_compute_variable_group_size_enable) {
1562             _mesa_glsl_error(& @1, state,
1563                              "qualifier `local_size_variable` requires "
1564                              "ARB_compute_variable_group_size");
1565          }
1566       }
1567
1568       /* Layout qualifiers for ARB_bindless_texture. */
1569       if (!$$.flags.i) {
1570          if (match_layout_qualifier($1, "bindless_sampler", state) == 0)
1571             $$.flags.q.bindless_sampler = 1;
1572          if (match_layout_qualifier($1, "bound_sampler", state) == 0)
1573             $$.flags.q.bound_sampler = 1;
1574
1575          if (state->has_shader_image_load_store()) {
1576             if (match_layout_qualifier($1, "bindless_image", state) == 0)
1577                $$.flags.q.bindless_image = 1;
1578             if (match_layout_qualifier($1, "bound_image", state) == 0)
1579                $$.flags.q.bound_image = 1;
1580          }
1581
1582          if ($$.flags.i && !state->has_bindless()) {
1583             _mesa_glsl_error(& @1, state,
1584                              "qualifier `%s` requires "
1585                              "ARB_bindless_texture", $1);
1586          }
1587       }
1588
1589       if (!$$.flags.i) {
1590          _mesa_glsl_error(& @1, state, "unrecognized layout identifier "
1591                           "`%s'", $1);
1592          YYERROR;
1593       }
1594    }
1595    | any_identifier '=' constant_expression
1596    {
1597       memset(& $$, 0, sizeof($$));
1598       void *ctx = state->linalloc;
1599
1600       if ($3->oper != ast_int_constant &&
1601           $3->oper != ast_uint_constant &&
1602           !state->has_enhanced_layouts()) {
1603          _mesa_glsl_error(& @1, state,
1604                           "compile-time constant expressions require "
1605                           "GLSL 4.40 or ARB_enhanced_layouts");
1606       }
1607
1608       if (match_layout_qualifier("align", $1, state) == 0) {
1609          if (!state->has_enhanced_layouts()) {
1610             _mesa_glsl_error(& @1, state,
1611                              "align qualifier requires "
1612                              "GLSL 4.40 or ARB_enhanced_layouts");
1613          } else {
1614             $$.flags.q.explicit_align = 1;
1615             $$.align = $3;
1616          }
1617       }
1618
1619       if (match_layout_qualifier("location", $1, state) == 0) {
1620          $$.flags.q.explicit_location = 1;
1621
1622          if ($$.flags.q.attribute == 1 &&
1623              state->ARB_explicit_attrib_location_warn) {
1624             _mesa_glsl_warning(& @1, state,
1625                                "GL_ARB_explicit_attrib_location layout "
1626                                "identifier `%s' used", $1);
1627          }
1628          $$.location = $3;
1629       }
1630
1631       if (match_layout_qualifier("component", $1, state) == 0) {
1632          if (!state->has_enhanced_layouts()) {
1633             _mesa_glsl_error(& @1, state,
1634                              "component qualifier requires "
1635                              "GLSL 4.40 or ARB_enhanced_layouts");
1636          } else {
1637             $$.flags.q.explicit_component = 1;
1638             $$.component = $3;
1639          }
1640       }
1641
1642       if (match_layout_qualifier("index", $1, state) == 0) {
1643          if (state->es_shader && !state->EXT_blend_func_extended_enable) {
1644             _mesa_glsl_error(& @3, state, "index layout qualifier requires EXT_blend_func_extended");
1645             YYERROR;
1646          }
1647
1648          $$.flags.q.explicit_index = 1;
1649          $$.index = $3;
1650       }
1651
1652       if ((state->has_420pack_or_es31() ||
1653            state->has_atomic_counters() ||
1654            state->has_shader_storage_buffer_objects()) &&
1655           match_layout_qualifier("binding", $1, state) == 0) {
1656          $$.flags.q.explicit_binding = 1;
1657          $$.binding = $3;
1658       }
1659
1660       if ((state->has_atomic_counters() ||
1661            state->has_enhanced_layouts()) &&
1662           match_layout_qualifier("offset", $1, state) == 0) {
1663          $$.flags.q.explicit_offset = 1;
1664          $$.offset = $3;
1665       }
1666
1667       if (match_layout_qualifier("max_vertices", $1, state) == 0) {
1668          $$.flags.q.max_vertices = 1;
1669          $$.max_vertices = new(ctx) ast_layout_expression(@1, $3);
1670          if (!state->has_geometry_shader()) {
1671             _mesa_glsl_error(& @3, state,
1672                              "#version 150 max_vertices qualifier "
1673                              "specified", $3);
1674          }
1675       }
1676
1677       if (state->stage == MESA_SHADER_GEOMETRY) {
1678          if (match_layout_qualifier("stream", $1, state) == 0 &&
1679              state->check_explicit_attrib_stream_allowed(& @3)) {
1680             $$.flags.q.stream = 1;
1681             $$.flags.q.explicit_stream = 1;
1682             $$.stream = $3;
1683          }
1684       }
1685
1686       if (state->has_enhanced_layouts()) {
1687          if (match_layout_qualifier("xfb_buffer", $1, state) == 0) {
1688             $$.flags.q.xfb_buffer = 1;
1689             $$.flags.q.explicit_xfb_buffer = 1;
1690             $$.xfb_buffer = $3;
1691          }
1692
1693          if (match_layout_qualifier("xfb_offset", $1, state) == 0) {
1694             $$.flags.q.explicit_xfb_offset = 1;
1695             $$.offset = $3;
1696          }
1697
1698          if (match_layout_qualifier("xfb_stride", $1, state) == 0) {
1699             $$.flags.q.xfb_stride = 1;
1700             $$.flags.q.explicit_xfb_stride = 1;
1701             $$.xfb_stride = $3;
1702          }
1703       }
1704
1705       static const char * const local_size_qualifiers[3] = {
1706          "local_size_x",
1707          "local_size_y",
1708          "local_size_z",
1709       };
1710       for (int i = 0; i < 3; i++) {
1711          if (match_layout_qualifier(local_size_qualifiers[i], $1,
1712                                     state) == 0) {
1713             if (!state->has_compute_shader()) {
1714                _mesa_glsl_error(& @3, state,
1715                                 "%s qualifier requires GLSL 4.30 or "
1716                                 "GLSL ES 3.10 or ARB_compute_shader",
1717                                 local_size_qualifiers[i]);
1718                YYERROR;
1719             } else {
1720                $$.flags.q.local_size |= (1 << i);
1721                $$.local_size[i] = new(ctx) ast_layout_expression(@1, $3);
1722             }
1723             break;
1724          }
1725       }
1726
1727       if (match_layout_qualifier("invocations", $1, state) == 0) {
1728          $$.flags.q.invocations = 1;
1729          $$.invocations = new(ctx) ast_layout_expression(@1, $3);
1730          if (!state->is_version(400, 320) &&
1731              !state->ARB_gpu_shader5_enable &&
1732              !state->OES_geometry_shader_enable &&
1733              !state->EXT_geometry_shader_enable) {
1734             _mesa_glsl_error(& @3, state,
1735                              "GL_ARB_gpu_shader5 invocations "
1736                              "qualifier specified", $3);
1737          }
1738       }
1739
1740       /* Layout qualifiers for tessellation control shaders. */
1741       if (match_layout_qualifier("vertices", $1, state) == 0) {
1742          $$.flags.q.vertices = 1;
1743          $$.vertices = new(ctx) ast_layout_expression(@1, $3);
1744          if (!state->has_tessellation_shader()) {
1745             _mesa_glsl_error(& @1, state,
1746                              "vertices qualifier requires GLSL 4.00 or "
1747                              "ARB_tessellation_shader");
1748          }
1749       }
1750
1751       /* If the identifier didn't match any known layout identifiers,
1752        * emit an error.
1753        */
1754       if (!$$.flags.i) {
1755          _mesa_glsl_error(& @1, state, "unrecognized layout identifier "
1756                           "`%s'", $1);
1757          YYERROR;
1758       }
1759    }
1760    | interface_block_layout_qualifier
1761    {
1762       $$ = $1;
1763       /* Layout qualifiers for ARB_uniform_buffer_object. */
1764       if ($$.flags.q.uniform && !state->has_uniform_buffer_objects()) {
1765          _mesa_glsl_error(& @1, state,
1766                           "#version 140 / GL_ARB_uniform_buffer_object "
1767                           "layout qualifier `%s' is used", $1);
1768       } else if ($$.flags.q.uniform && state->ARB_uniform_buffer_object_warn) {
1769          _mesa_glsl_warning(& @1, state,
1770                             "#version 140 / GL_ARB_uniform_buffer_object "
1771                             "layout qualifier `%s' is used", $1);
1772       }
1773    }
1774    ;
1775
1776 /* This is a separate language rule because we parse these as tokens
1777  * (due to them being reserved keywords) instead of identifiers like
1778  * most qualifiers.  See the any_identifier path of
1779  * layout_qualifier_id for the others.
1780  *
1781  * Note that since layout qualifiers are case-insensitive in desktop
1782  * GLSL, all of these qualifiers need to be handled as identifiers as
1783  * well (by the any_identifier path of layout_qualifier_id).
1784  */
1785 interface_block_layout_qualifier:
1786    ROW_MAJOR
1787    {
1788       memset(& $$, 0, sizeof($$));
1789       $$.flags.q.row_major = 1;
1790    }
1791    | PACKED_TOK
1792    {
1793       memset(& $$, 0, sizeof($$));
1794       $$.flags.q.packed = 1;
1795    }
1796    | SHARED
1797    {
1798       memset(& $$, 0, sizeof($$));
1799       $$.flags.q.shared = 1;
1800    }
1801    ;
1802
1803 subroutine_qualifier:
1804    SUBROUTINE
1805    {
1806       memset(& $$, 0, sizeof($$));
1807       $$.flags.q.subroutine = 1;
1808    }
1809    | SUBROUTINE '(' subroutine_type_list ')'
1810    {
1811       memset(& $$, 0, sizeof($$));
1812       $$.flags.q.subroutine = 1;
1813       $$.subroutine_list = $3;
1814    }
1815    ;
1816
1817 subroutine_type_list:
1818    any_identifier
1819    {
1820         void *ctx = state->linalloc;
1821         ast_declaration *decl = new(ctx)  ast_declaration($1, NULL, NULL);
1822         decl->set_location(@1);
1823
1824         $$ = new(ctx) ast_subroutine_list();
1825         $$->declarations.push_tail(&decl->link);
1826    }
1827    | subroutine_type_list ',' any_identifier
1828    {
1829         void *ctx = state->linalloc;
1830         ast_declaration *decl = new(ctx)  ast_declaration($3, NULL, NULL);
1831         decl->set_location(@3);
1832
1833         $$ = $1;
1834         $$->declarations.push_tail(&decl->link);
1835    }
1836    ;
1837
1838 interpolation_qualifier:
1839    SMOOTH
1840    {
1841       memset(& $$, 0, sizeof($$));
1842       $$.flags.q.smooth = 1;
1843    }
1844    | FLAT
1845    {
1846       memset(& $$, 0, sizeof($$));
1847       $$.flags.q.flat = 1;
1848    }
1849    | NOPERSPECTIVE
1850    {
1851       memset(& $$, 0, sizeof($$));
1852       $$.flags.q.noperspective = 1;
1853    }
1854    ;
1855
1856 type_qualifier:
1857    /* Single qualifiers */
1858    INVARIANT
1859    {
1860       memset(& $$, 0, sizeof($$));
1861       $$.flags.q.invariant = 1;
1862    }
1863    | PRECISE
1864    {
1865       memset(& $$, 0, sizeof($$));
1866       $$.flags.q.precise = 1;
1867    }
1868    | auxiliary_storage_qualifier
1869    | storage_qualifier
1870    | interpolation_qualifier
1871    | layout_qualifier
1872    | memory_qualifier
1873    | subroutine_qualifier
1874    | precision_qualifier
1875    {
1876       memset(&$$, 0, sizeof($$));
1877       $$.precision = $1;
1878    }
1879
1880    /* Multiple qualifiers:
1881     * In GLSL 4.20, these can be specified in any order.  In earlier versions,
1882     * they appear in this order (see GLSL 1.50 section 4.7 & comments below):
1883     *
1884     *    invariant interpolation auxiliary storage precision  ...or...
1885     *    layout storage precision
1886     *
1887     * Each qualifier's rule ensures that the accumulated qualifiers on the right
1888     * side don't contain any that must appear on the left hand side.
1889     * For example, when processing a storage qualifier, we check that there are
1890     * no auxiliary, interpolation, layout, invariant, or precise qualifiers to the right.
1891     */
1892    | PRECISE type_qualifier
1893    {
1894       if ($2.flags.q.precise)
1895          _mesa_glsl_error(&@1, state, "duplicate \"precise\" qualifier");
1896
1897       $$ = $2;
1898       $$.flags.q.precise = 1;
1899    }
1900    | INVARIANT type_qualifier
1901    {
1902       if ($2.flags.q.invariant)
1903          _mesa_glsl_error(&@1, state, "duplicate \"invariant\" qualifier");
1904
1905       if (!state->has_420pack_or_es31() && $2.flags.q.precise)
1906          _mesa_glsl_error(&@1, state,
1907                           "\"invariant\" must come after \"precise\"");
1908
1909       $$ = $2;
1910       $$.flags.q.invariant = 1;
1911
1912       /* GLSL ES 3.00 spec, section 4.6.1 "The Invariant Qualifier":
1913        *
1914        * "Only variables output from a shader can be candidates for invariance.
1915        * This includes user-defined output variables and the built-in output
1916        * variables. As only outputs can be declared as invariant, an invariant
1917        * output from one shader stage will still match an input of a subsequent
1918        * stage without the input being declared as invariant."
1919        *
1920        * On the desktop side, this text first appears in GLSL 4.30.
1921        */
1922       if (state->is_version(430, 300) && $$.flags.q.in)
1923          _mesa_glsl_error(&@1, state, "invariant qualifiers cannot be used with shader inputs");
1924    }
1925    | interpolation_qualifier type_qualifier
1926    {
1927       /* Section 4.3 of the GLSL 1.40 specification states:
1928        * "...qualified with one of these interpolation qualifiers"
1929        *
1930        * GLSL 1.30 claims to allow "one or more", but insists that:
1931        * "These interpolation qualifiers may only precede the qualifiers in,
1932        *  centroid in, out, or centroid out in a declaration."
1933        *
1934        * ...which means that e.g. smooth can't precede smooth, so there can be
1935        * only one after all, and the 1.40 text is a clarification, not a change.
1936        */
1937       if ($2.has_interpolation())
1938          _mesa_glsl_error(&@1, state, "duplicate interpolation qualifier");
1939
1940       if (!state->has_420pack_or_es31() &&
1941           ($2.flags.q.precise || $2.flags.q.invariant)) {
1942          _mesa_glsl_error(&@1, state, "interpolation qualifiers must come "
1943                           "after \"precise\" or \"invariant\"");
1944       }
1945
1946       $$ = $1;
1947       $$.merge_qualifier(&@1, state, $2, false);
1948    }
1949    | layout_qualifier type_qualifier
1950    {
1951       /* In the absence of ARB_shading_language_420pack, layout qualifiers may
1952        * appear no later than auxiliary storage qualifiers. There is no
1953        * particularly clear spec language mandating this, but in all examples
1954        * the layout qualifier precedes the storage qualifier.
1955        *
1956        * We allow combinations of layout with interpolation, invariant or
1957        * precise qualifiers since these are useful in ARB_separate_shader_objects.
1958        * There is no clear spec guidance on this either.
1959        */
1960       $$ = $1;
1961       $$.merge_qualifier(& @1, state, $2, false, $2.has_layout());
1962    }
1963    | subroutine_qualifier type_qualifier
1964    {
1965       $$ = $1;
1966       $$.merge_qualifier(&@1, state, $2, false);
1967    }
1968    | auxiliary_storage_qualifier type_qualifier
1969    {
1970       if ($2.has_auxiliary_storage()) {
1971          _mesa_glsl_error(&@1, state,
1972                           "duplicate auxiliary storage qualifier (centroid or sample)");
1973       }
1974
1975       if (!state->has_420pack_or_es31() &&
1976           ($2.flags.q.precise || $2.flags.q.invariant ||
1977            $2.has_interpolation() || $2.has_layout())) {
1978          _mesa_glsl_error(&@1, state, "auxiliary storage qualifiers must come "
1979                           "just before storage qualifiers");
1980       }
1981       $$ = $1;
1982       $$.merge_qualifier(&@1, state, $2, false);
1983    }
1984    | storage_qualifier type_qualifier
1985    {
1986       /* Section 4.3 of the GLSL 1.20 specification states:
1987        * "Variable declarations may have a storage qualifier specified..."
1988        *  1.30 clarifies this to "may have one storage qualifier".
1989        */
1990       if ($2.has_storage())
1991          _mesa_glsl_error(&@1, state, "duplicate storage qualifier");
1992
1993       if (!state->has_420pack_or_es31() &&
1994           ($2.flags.q.precise || $2.flags.q.invariant || $2.has_interpolation() ||
1995            $2.has_layout() || $2.has_auxiliary_storage())) {
1996          _mesa_glsl_error(&@1, state, "storage qualifiers must come after "
1997                           "precise, invariant, interpolation, layout and auxiliary "
1998                           "storage qualifiers");
1999       }
2000
2001       $$ = $1;
2002       $$.merge_qualifier(&@1, state, $2, false);
2003    }
2004    | precision_qualifier type_qualifier
2005    {
2006       if ($2.precision != ast_precision_none)
2007          _mesa_glsl_error(&@1, state, "duplicate precision qualifier");
2008
2009       if (!(state->has_420pack_or_es31()) &&
2010           $2.flags.i != 0)
2011          _mesa_glsl_error(&@1, state, "precision qualifiers must come last");
2012
2013       $$ = $2;
2014       $$.precision = $1;
2015    }
2016    | memory_qualifier type_qualifier
2017    {
2018       $$ = $1;
2019       $$.merge_qualifier(&@1, state, $2, false);
2020    }
2021    ;
2022
2023 auxiliary_storage_qualifier:
2024    CENTROID
2025    {
2026       memset(& $$, 0, sizeof($$));
2027       $$.flags.q.centroid = 1;
2028    }
2029    | SAMPLE
2030    {
2031       memset(& $$, 0, sizeof($$));
2032       $$.flags.q.sample = 1;
2033    }
2034    | PATCH
2035    {
2036       memset(& $$, 0, sizeof($$));
2037       $$.flags.q.patch = 1;
2038    }
2039
2040 storage_qualifier:
2041    CONST_TOK
2042    {
2043       memset(& $$, 0, sizeof($$));
2044       $$.flags.q.constant = 1;
2045    }
2046    | ATTRIBUTE
2047    {
2048       memset(& $$, 0, sizeof($$));
2049       $$.flags.q.attribute = 1;
2050    }
2051    | VARYING
2052    {
2053       memset(& $$, 0, sizeof($$));
2054       $$.flags.q.varying = 1;
2055    }
2056    | IN_TOK
2057    {
2058       memset(& $$, 0, sizeof($$));
2059       $$.flags.q.in = 1;
2060    }
2061    | OUT_TOK
2062    {
2063       memset(& $$, 0, sizeof($$));
2064       $$.flags.q.out = 1;
2065
2066       if (state->stage == MESA_SHADER_GEOMETRY &&
2067           state->has_explicit_attrib_stream()) {
2068          /* Section 4.3.8.2 (Output Layout Qualifiers) of the GLSL 4.00
2069           * spec says:
2070           *
2071           *     "If the block or variable is declared with the stream
2072           *     identifier, it is associated with the specified stream;
2073           *     otherwise, it is associated with the current default stream."
2074           */
2075           $$.flags.q.stream = 1;
2076           $$.flags.q.explicit_stream = 0;
2077           $$.stream = state->out_qualifier->stream;
2078       }
2079
2080       if (state->has_enhanced_layouts()) {
2081           $$.flags.q.xfb_buffer = 1;
2082           $$.flags.q.explicit_xfb_buffer = 0;
2083           $$.xfb_buffer = state->out_qualifier->xfb_buffer;
2084       }
2085    }
2086    | INOUT_TOK
2087    {
2088       memset(& $$, 0, sizeof($$));
2089       $$.flags.q.in = 1;
2090       $$.flags.q.out = 1;
2091
2092       if (!state->has_framebuffer_fetch() ||
2093           !state->is_version(130, 300) ||
2094           state->stage != MESA_SHADER_FRAGMENT)
2095          _mesa_glsl_error(&@1, state, "A single interface variable cannot be "
2096                           "declared as both input and output");
2097    }
2098    | UNIFORM
2099    {
2100       memset(& $$, 0, sizeof($$));
2101       $$.flags.q.uniform = 1;
2102    }
2103    | BUFFER
2104    {
2105       memset(& $$, 0, sizeof($$));
2106       $$.flags.q.buffer = 1;
2107    }
2108    | SHARED
2109    {
2110       memset(& $$, 0, sizeof($$));
2111       $$.flags.q.shared_storage = 1;
2112    }
2113    ;
2114
2115 memory_qualifier:
2116    COHERENT
2117    {
2118       memset(& $$, 0, sizeof($$));
2119       $$.flags.q.coherent = 1;
2120    }
2121    | VOLATILE
2122    {
2123       memset(& $$, 0, sizeof($$));
2124       $$.flags.q._volatile = 1;
2125    }
2126    | RESTRICT
2127    {
2128       STATIC_ASSERT(sizeof($$.flags.q) <= sizeof($$.flags.i));
2129       memset(& $$, 0, sizeof($$));
2130       $$.flags.q.restrict_flag = 1;
2131    }
2132    | READONLY
2133    {
2134       memset(& $$, 0, sizeof($$));
2135       $$.flags.q.read_only = 1;
2136    }
2137    | WRITEONLY
2138    {
2139       memset(& $$, 0, sizeof($$));
2140       $$.flags.q.write_only = 1;
2141    }
2142    ;
2143
2144 array_specifier:
2145    '[' ']'
2146    {
2147       void *ctx = state->linalloc;
2148       $$ = new(ctx) ast_array_specifier(@1, new(ctx) ast_expression(
2149                                                   ast_unsized_array_dim, NULL,
2150                                                   NULL, NULL));
2151       $$->set_location_range(@1, @2);
2152    }
2153    | '[' constant_expression ']'
2154    {
2155       void *ctx = state->linalloc;
2156       $$ = new(ctx) ast_array_specifier(@1, $2);
2157       $$->set_location_range(@1, @3);
2158    }
2159    | array_specifier '[' ']'
2160    {
2161       void *ctx = state->linalloc;
2162       $$ = $1;
2163
2164       if (state->check_arrays_of_arrays_allowed(& @1)) {
2165          $$->add_dimension(new(ctx) ast_expression(ast_unsized_array_dim, NULL,
2166                                                    NULL, NULL));
2167       }
2168    }
2169    | array_specifier '[' constant_expression ']'
2170    {
2171       $$ = $1;
2172
2173       if (state->check_arrays_of_arrays_allowed(& @1)) {
2174          $$->add_dimension($3);
2175       }
2176    }
2177    ;
2178
2179 type_specifier:
2180    type_specifier_nonarray
2181    | type_specifier_nonarray array_specifier
2182    {
2183       $$ = $1;
2184       $$->array_specifier = $2;
2185    }
2186    ;
2187
2188 type_specifier_nonarray:
2189    basic_type_specifier_nonarray
2190    {
2191       void *ctx = state->linalloc;
2192       $$ = new(ctx) ast_type_specifier($1);
2193       $$->set_location(@1);
2194    }
2195    | struct_specifier
2196    {
2197       void *ctx = state->linalloc;
2198       $$ = new(ctx) ast_type_specifier($1);
2199       $$->set_location(@1);
2200    }
2201    | TYPE_IDENTIFIER
2202    {
2203       void *ctx = state->linalloc;
2204       $$ = new(ctx) ast_type_specifier($1);
2205       $$->set_location(@1);
2206    }
2207    ;
2208
2209 basic_type_specifier_nonarray:
2210    VOID_TOK                 { $$ = glsl_type::void_type; }
2211    | BASIC_TYPE_TOK         { $$ = $1; };
2212    ;
2213
2214 precision_qualifier:
2215    HIGHP
2216    {
2217       state->check_precision_qualifiers_allowed(&@1);
2218       $$ = ast_precision_high;
2219    }
2220    | MEDIUMP
2221    {
2222       state->check_precision_qualifiers_allowed(&@1);
2223       $$ = ast_precision_medium;
2224    }
2225    | LOWP
2226    {
2227       state->check_precision_qualifiers_allowed(&@1);
2228       $$ = ast_precision_low;
2229    }
2230    ;
2231
2232 struct_specifier:
2233    STRUCT any_identifier '{' struct_declaration_list '}'
2234    {
2235       void *ctx = state->linalloc;
2236       $$ = new(ctx) ast_struct_specifier($2, $4);
2237       $$->set_location_range(@2, @5);
2238       state->symbols->add_type($2, glsl_type::void_type);
2239    }
2240    | STRUCT '{' struct_declaration_list '}'
2241    {
2242       void *ctx = state->linalloc;
2243
2244       /* All anonymous structs have the same name. This simplifies matching of
2245        * globals whose type is an unnamed struct.
2246        *
2247        * It also avoids a memory leak when the same shader is compiled over and
2248        * over again.
2249        */
2250       $$ = new(ctx) ast_struct_specifier("#anon_struct", $3);
2251
2252       $$->set_location_range(@2, @4);
2253    }
2254    ;
2255
2256 struct_declaration_list:
2257    struct_declaration
2258    {
2259       $$ = $1;
2260       $1->link.self_link();
2261    }
2262    | struct_declaration_list struct_declaration
2263    {
2264       $$ = $1;
2265       $$->link.insert_before(& $2->link);
2266    }
2267    ;
2268
2269 struct_declaration:
2270    fully_specified_type struct_declarator_list ';'
2271    {
2272       void *ctx = state->linalloc;
2273       ast_fully_specified_type *const type = $1;
2274       type->set_location(@1);
2275
2276       if (state->has_bindless()) {
2277          ast_type_qualifier input_layout_mask;
2278
2279          /* Allow to declare qualifiers for images. */
2280          input_layout_mask.flags.i = 0;
2281          input_layout_mask.flags.q.coherent = 1;
2282          input_layout_mask.flags.q._volatile = 1;
2283          input_layout_mask.flags.q.restrict_flag = 1;
2284          input_layout_mask.flags.q.read_only = 1;
2285          input_layout_mask.flags.q.write_only = 1;
2286          input_layout_mask.flags.q.explicit_image_format = 1;
2287
2288          if ((type->qualifier.flags.i & ~input_layout_mask.flags.i) != 0) {
2289             _mesa_glsl_error(&@1, state,
2290                              "only precision and image qualifiers may be "
2291                              "applied to structure members");
2292          }
2293       } else {
2294          if (type->qualifier.flags.i != 0)
2295             _mesa_glsl_error(&@1, state,
2296                              "only precision qualifiers may be applied to "
2297                              "structure members");
2298       }
2299
2300       $$ = new(ctx) ast_declarator_list(type);
2301       $$->set_location(@2);
2302
2303       $$->declarations.push_degenerate_list_at_head(& $2->link);
2304    }
2305    ;
2306
2307 struct_declarator_list:
2308    struct_declarator
2309    {
2310       $$ = $1;
2311       $1->link.self_link();
2312    }
2313    | struct_declarator_list ',' struct_declarator
2314    {
2315       $$ = $1;
2316       $$->link.insert_before(& $3->link);
2317    }
2318    ;
2319
2320 struct_declarator:
2321    any_identifier
2322    {
2323       void *ctx = state->linalloc;
2324       $$ = new(ctx) ast_declaration($1, NULL, NULL);
2325       $$->set_location(@1);
2326    }
2327    | any_identifier array_specifier
2328    {
2329       void *ctx = state->linalloc;
2330       $$ = new(ctx) ast_declaration($1, $2, NULL);
2331       $$->set_location_range(@1, @2);
2332    }
2333    ;
2334
2335 initializer:
2336    assignment_expression
2337    | '{' initializer_list '}'
2338    {
2339       $$ = $2;
2340    }
2341    | '{' initializer_list ',' '}'
2342    {
2343       $$ = $2;
2344    }
2345    ;
2346
2347 initializer_list:
2348    initializer
2349    {
2350       void *ctx = state->linalloc;
2351       $$ = new(ctx) ast_aggregate_initializer();
2352       $$->set_location(@1);
2353       $$->expressions.push_tail(& $1->link);
2354    }
2355    | initializer_list ',' initializer
2356    {
2357       $1->expressions.push_tail(& $3->link);
2358    }
2359    ;
2360
2361 declaration_statement:
2362    declaration
2363    ;
2364
2365    // Grammar Note: labeled statements for SWITCH only; 'goto' is not
2366    // supported.
2367 statement:
2368    compound_statement        { $$ = (ast_node *) $1; }
2369    | simple_statement
2370    ;
2371
2372 simple_statement:
2373    declaration_statement
2374    | expression_statement
2375    | selection_statement
2376    | switch_statement
2377    | iteration_statement
2378    | jump_statement
2379    ;
2380
2381 compound_statement:
2382    '{' '}'
2383    {
2384       void *ctx = state->linalloc;
2385       $$ = new(ctx) ast_compound_statement(true, NULL);
2386       $$->set_location_range(@1, @2);
2387    }
2388    | '{'
2389    {
2390       state->symbols->push_scope();
2391    }
2392    statement_list '}'
2393    {
2394       void *ctx = state->linalloc;
2395       $$ = new(ctx) ast_compound_statement(true, $3);
2396       $$->set_location_range(@1, @4);
2397       state->symbols->pop_scope();
2398    }
2399    ;
2400
2401 statement_no_new_scope:
2402    compound_statement_no_new_scope { $$ = (ast_node *) $1; }
2403    | simple_statement
2404    ;
2405
2406 compound_statement_no_new_scope:
2407    '{' '}'
2408    {
2409       void *ctx = state->linalloc;
2410       $$ = new(ctx) ast_compound_statement(false, NULL);
2411       $$->set_location_range(@1, @2);
2412    }
2413    | '{' statement_list '}'
2414    {
2415       void *ctx = state->linalloc;
2416       $$ = new(ctx) ast_compound_statement(false, $2);
2417       $$->set_location_range(@1, @3);
2418    }
2419    ;
2420
2421 statement_list:
2422    statement
2423    {
2424       if ($1 == NULL) {
2425          _mesa_glsl_error(& @1, state, "<nil> statement");
2426          assert($1 != NULL);
2427       }
2428
2429       $$ = $1;
2430       $$->link.self_link();
2431    }
2432    | statement_list statement
2433    {
2434       if ($2 == NULL) {
2435          _mesa_glsl_error(& @2, state, "<nil> statement");
2436          assert($2 != NULL);
2437       }
2438       $$ = $1;
2439       $$->link.insert_before(& $2->link);
2440    }
2441    ;
2442
2443 expression_statement:
2444    ';'
2445    {
2446       void *ctx = state->linalloc;
2447       $$ = new(ctx) ast_expression_statement(NULL);
2448       $$->set_location(@1);
2449    }
2450    | expression ';'
2451    {
2452       void *ctx = state->linalloc;
2453       $$ = new(ctx) ast_expression_statement($1);
2454       $$->set_location(@1);
2455    }
2456    ;
2457
2458 selection_statement:
2459    IF '(' expression ')' selection_rest_statement
2460    {
2461       $$ = new(state->linalloc) ast_selection_statement($3, $5.then_statement,
2462                                                         $5.else_statement);
2463       $$->set_location_range(@1, @5);
2464    }
2465    ;
2466
2467 selection_rest_statement:
2468    statement ELSE statement
2469    {
2470       $$.then_statement = $1;
2471       $$.else_statement = $3;
2472    }
2473    | statement %prec THEN
2474    {
2475       $$.then_statement = $1;
2476       $$.else_statement = NULL;
2477    }
2478    ;
2479
2480 condition:
2481    expression
2482    {
2483       $$ = (ast_node *) $1;
2484    }
2485    | fully_specified_type any_identifier '=' initializer
2486    {
2487       void *ctx = state->linalloc;
2488       ast_declaration *decl = new(ctx) ast_declaration($2, NULL, $4);
2489       ast_declarator_list *declarator = new(ctx) ast_declarator_list($1);
2490       decl->set_location_range(@2, @4);
2491       declarator->set_location(@1);
2492
2493       declarator->declarations.push_tail(&decl->link);
2494       $$ = declarator;
2495    }
2496    ;
2497
2498 /*
2499  * switch_statement grammar is based on the syntax described in the body
2500  * of the GLSL spec, not in it's appendix!!!
2501  */
2502 switch_statement:
2503    SWITCH '(' expression ')' switch_body
2504    {
2505       $$ = new(state->linalloc) ast_switch_statement($3, $5);
2506       $$->set_location_range(@1, @5);
2507    }
2508    ;
2509
2510 switch_body:
2511    '{' '}'
2512    {
2513       $$ = new(state->linalloc) ast_switch_body(NULL);
2514       $$->set_location_range(@1, @2);
2515    }
2516    | '{' case_statement_list '}'
2517    {
2518       $$ = new(state->linalloc) ast_switch_body($2);
2519       $$->set_location_range(@1, @3);
2520    }
2521    ;
2522
2523 case_label:
2524    CASE expression ':'
2525    {
2526       $$ = new(state->linalloc) ast_case_label($2);
2527       $$->set_location(@2);
2528    }
2529    | DEFAULT ':'
2530    {
2531       $$ = new(state->linalloc) ast_case_label(NULL);
2532       $$->set_location(@2);
2533    }
2534    ;
2535
2536 case_label_list:
2537    case_label
2538    {
2539       ast_case_label_list *labels = new(state->linalloc) ast_case_label_list();
2540
2541       labels->labels.push_tail(& $1->link);
2542       $$ = labels;
2543       $$->set_location(@1);
2544    }
2545    | case_label_list case_label
2546    {
2547       $$ = $1;
2548       $$->labels.push_tail(& $2->link);
2549    }
2550    ;
2551
2552 case_statement:
2553    case_label_list statement
2554    {
2555       ast_case_statement *stmts = new(state->linalloc) ast_case_statement($1);
2556       stmts->set_location(@2);
2557
2558       stmts->stmts.push_tail(& $2->link);
2559       $$ = stmts;
2560    }
2561    | case_statement statement
2562    {
2563       $$ = $1;
2564       $$->stmts.push_tail(& $2->link);
2565    }
2566    ;
2567
2568 case_statement_list:
2569    case_statement
2570    {
2571       ast_case_statement_list *cases= new(state->linalloc) ast_case_statement_list();
2572       cases->set_location(@1);
2573
2574       cases->cases.push_tail(& $1->link);
2575       $$ = cases;
2576    }
2577    | case_statement_list case_statement
2578    {
2579       $$ = $1;
2580       $$->cases.push_tail(& $2->link);
2581    }
2582    ;
2583
2584 iteration_statement:
2585    WHILE '(' condition ')' statement_no_new_scope
2586    {
2587       void *ctx = state->linalloc;
2588       $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_while,
2589                                             NULL, $3, NULL, $5);
2590       $$->set_location_range(@1, @4);
2591    }
2592    | DO statement WHILE '(' expression ')' ';'
2593    {
2594       void *ctx = state->linalloc;
2595       $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_do_while,
2596                                             NULL, $5, NULL, $2);
2597       $$->set_location_range(@1, @6);
2598    }
2599    | FOR '(' for_init_statement for_rest_statement ')' statement_no_new_scope
2600    {
2601       void *ctx = state->linalloc;
2602       $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_for,
2603                                             $3, $4.cond, $4.rest, $6);
2604       $$->set_location_range(@1, @6);
2605    }
2606    ;
2607
2608 for_init_statement:
2609    expression_statement
2610    | declaration_statement
2611    ;
2612
2613 conditionopt:
2614    condition
2615    | /* empty */
2616    {
2617       $$ = NULL;
2618    }
2619    ;
2620
2621 for_rest_statement:
2622    conditionopt ';'
2623    {
2624       $$.cond = $1;
2625       $$.rest = NULL;
2626    }
2627    | conditionopt ';' expression
2628    {
2629       $$.cond = $1;
2630       $$.rest = $3;
2631    }
2632    ;
2633
2634    // Grammar Note: No 'goto'. Gotos are not supported.
2635 jump_statement:
2636    CONTINUE ';'
2637    {
2638       void *ctx = state->linalloc;
2639       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_continue, NULL);
2640       $$->set_location(@1);
2641    }
2642    | BREAK ';'
2643    {
2644       void *ctx = state->linalloc;
2645       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_break, NULL);
2646       $$->set_location(@1);
2647    }
2648    | RETURN ';'
2649    {
2650       void *ctx = state->linalloc;
2651       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, NULL);
2652       $$->set_location(@1);
2653    }
2654    | RETURN expression ';'
2655    {
2656       void *ctx = state->linalloc;
2657       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, $2);
2658       $$->set_location_range(@1, @2);
2659    }
2660    | DISCARD ';' // Fragment shader only.
2661    {
2662       void *ctx = state->linalloc;
2663       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_discard, NULL);
2664       $$->set_location(@1);
2665    }
2666    ;
2667
2668 external_declaration:
2669    function_definition      { $$ = $1; }
2670    | declaration            { $$ = $1; }
2671    | pragma_statement       { $$ = NULL; }
2672    | layout_defaults        { $$ = $1; }
2673    ;
2674
2675 function_definition:
2676    function_prototype compound_statement_no_new_scope
2677    {
2678       void *ctx = state->linalloc;
2679       $$ = new(ctx) ast_function_definition();
2680       $$->set_location_range(@1, @2);
2681       $$->prototype = $1;
2682       $$->body = $2;
2683
2684       state->symbols->pop_scope();
2685    }
2686    ;
2687
2688 /* layout_qualifieropt is packed into this rule */
2689 interface_block:
2690    basic_interface_block
2691    {
2692       $$ = $1;
2693    }
2694    | layout_qualifier interface_block
2695    {
2696       ast_interface_block *block = (ast_interface_block *) $2;
2697
2698       if (!$1.merge_qualifier(& @1, state, block->layout, false,
2699                               block->layout.has_layout())) {
2700          YYERROR;
2701       }
2702
2703       block->layout = $1;
2704
2705       $$ = block;
2706    }
2707    | memory_qualifier interface_block
2708    {
2709       ast_interface_block *block = (ast_interface_block *)$2;
2710
2711       if (!block->default_layout.flags.q.buffer) {
2712             _mesa_glsl_error(& @1, state,
2713                              "memory qualifiers can only be used in the "
2714                              "declaration of shader storage blocks");
2715       }
2716       if (!$1.merge_qualifier(& @1, state, block->layout, false)) {
2717          YYERROR;
2718       }
2719       block->layout = $1;
2720       $$ = block;
2721    }
2722    ;
2723
2724 basic_interface_block:
2725    interface_qualifier NEW_IDENTIFIER '{' member_list '}' instance_name_opt ';'
2726    {
2727       ast_interface_block *const block = $6;
2728
2729       if ($1.flags.q.uniform) {
2730          block->default_layout = *state->default_uniform_qualifier;
2731       } else if ($1.flags.q.buffer) {
2732          block->default_layout = *state->default_shader_storage_qualifier;
2733       }
2734       block->block_name = $2;
2735       block->declarations.push_degenerate_list_at_head(& $4->link);
2736
2737       _mesa_ast_process_interface_block(& @1, state, block, $1);
2738
2739       $$ = block;
2740    }
2741    ;
2742
2743 interface_qualifier:
2744    IN_TOK
2745    {
2746       memset(& $$, 0, sizeof($$));
2747       $$.flags.q.in = 1;
2748    }
2749    | OUT_TOK
2750    {
2751       memset(& $$, 0, sizeof($$));
2752       $$.flags.q.out = 1;
2753    }
2754    | UNIFORM
2755    {
2756       memset(& $$, 0, sizeof($$));
2757       $$.flags.q.uniform = 1;
2758    }
2759    | BUFFER
2760    {
2761       memset(& $$, 0, sizeof($$));
2762       $$.flags.q.buffer = 1;
2763    }
2764    | auxiliary_storage_qualifier interface_qualifier
2765    {
2766       if (!$1.flags.q.patch) {
2767          _mesa_glsl_error(&@1, state, "invalid interface qualifier");
2768       }
2769       if ($2.has_auxiliary_storage()) {
2770          _mesa_glsl_error(&@1, state, "duplicate patch qualifier");
2771       }
2772       $$ = $2;
2773       $$.flags.q.patch = 1;
2774    }
2775    ;
2776
2777 instance_name_opt:
2778    /* empty */
2779    {
2780       $$ = new(state->linalloc) ast_interface_block(NULL, NULL);
2781    }
2782    | NEW_IDENTIFIER
2783    {
2784       $$ = new(state->linalloc) ast_interface_block($1, NULL);
2785       $$->set_location(@1);
2786    }
2787    | NEW_IDENTIFIER array_specifier
2788    {
2789       $$ = new(state->linalloc) ast_interface_block($1, $2);
2790       $$->set_location_range(@1, @2);
2791    }
2792    ;
2793
2794 member_list:
2795    member_declaration
2796    {
2797       $$ = $1;
2798       $1->link.self_link();
2799    }
2800    | member_declaration member_list
2801    {
2802       $$ = $1;
2803       $2->link.insert_before(& $$->link);
2804    }
2805    ;
2806
2807 member_declaration:
2808    fully_specified_type struct_declarator_list ';'
2809    {
2810       void *ctx = state->linalloc;
2811       ast_fully_specified_type *type = $1;
2812       type->set_location(@1);
2813
2814       if (type->qualifier.flags.q.attribute) {
2815          _mesa_glsl_error(& @1, state,
2816                           "keyword 'attribute' cannot be used with "
2817                           "interface block member");
2818       } else if (type->qualifier.flags.q.varying) {
2819          _mesa_glsl_error(& @1, state,
2820                           "keyword 'varying' cannot be used with "
2821                           "interface block member");
2822       }
2823
2824       $$ = new(ctx) ast_declarator_list(type);
2825       $$->set_location(@2);
2826
2827       $$->declarations.push_degenerate_list_at_head(& $2->link);
2828    }
2829    ;
2830
2831 layout_uniform_defaults:
2832    layout_qualifier layout_uniform_defaults
2833    {
2834       $$ = $1;
2835       if (!$$.merge_qualifier(& @1, state, $2, false, true)) {
2836          YYERROR;
2837       }
2838    }
2839    | layout_qualifier UNIFORM ';'
2840    ;
2841
2842 layout_buffer_defaults:
2843    layout_qualifier layout_buffer_defaults
2844    {
2845       $$ = $1;
2846       if (!$$.merge_qualifier(& @1, state, $2, false, true)) {
2847          YYERROR;
2848       }
2849    }
2850    | layout_qualifier BUFFER ';'
2851    ;
2852
2853 layout_in_defaults:
2854    layout_qualifier layout_in_defaults
2855    {
2856       $$ = $1;
2857       if (!$$.merge_qualifier(& @1, state, $2, false, true)) {
2858          YYERROR;
2859       }
2860       if (!$$.validate_in_qualifier(& @1, state)) {
2861          YYERROR;
2862       }
2863    }
2864    | layout_qualifier IN_TOK ';'
2865    {
2866       if (!$1.validate_in_qualifier(& @1, state)) {
2867          YYERROR;
2868       }
2869    }
2870    ;
2871
2872 layout_out_defaults:
2873    layout_qualifier layout_out_defaults
2874    {
2875       $$ = $1;
2876       if (!$$.merge_qualifier(& @1, state, $2, false, true)) {
2877          YYERROR;
2878       }
2879       if (!$$.validate_out_qualifier(& @1, state)) {
2880          YYERROR;
2881       }
2882    }
2883    | layout_qualifier OUT_TOK ';'
2884    {
2885       if (!$1.validate_out_qualifier(& @1, state)) {
2886          YYERROR;
2887       }
2888    }
2889    ;
2890
2891 layout_defaults:
2892    layout_uniform_defaults
2893    {
2894       $$ = NULL;
2895       if (!state->default_uniform_qualifier->
2896              merge_qualifier(& @1, state, $1, false)) {
2897          YYERROR;
2898       }
2899       if (!state->default_uniform_qualifier->
2900              push_to_global(& @1, state)) {
2901          YYERROR;
2902       }
2903    }
2904    | layout_buffer_defaults
2905    {
2906       $$ = NULL;
2907       if (!state->default_shader_storage_qualifier->
2908              merge_qualifier(& @1, state, $1, false)) {
2909          YYERROR;
2910       }
2911       if (!state->default_shader_storage_qualifier->
2912              push_to_global(& @1, state)) {
2913          YYERROR;
2914       }
2915
2916       /* From the GLSL 4.50 spec, section 4.4.5:
2917        *
2918        *     "It is a compile-time error to specify the binding identifier for
2919        *     the global scope or for block member declarations."
2920        */
2921       if (state->default_shader_storage_qualifier->flags.q.explicit_binding) {
2922          _mesa_glsl_error(& @1, state,
2923                           "binding qualifier cannot be set for default layout");
2924       }
2925    }
2926    | layout_in_defaults
2927    {
2928       $$ = NULL;
2929       if (!$1.merge_into_in_qualifier(& @1, state, $$)) {
2930          YYERROR;
2931       }
2932       if (!state->in_qualifier->push_to_global(& @1, state)) {
2933          YYERROR;
2934       }
2935    }
2936    | layout_out_defaults
2937    {
2938       $$ = NULL;
2939       if (!$1.merge_into_out_qualifier(& @1, state, $$)) {
2940          YYERROR;
2941       }
2942       if (!state->out_qualifier->push_to_global(& @1, state)) {
2943          YYERROR;
2944       }
2945    }
2946    ;