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