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