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 ((state->ARB_shading_language_420pack_enable ||
1428            state->has_atomic_counters()) &&
1429           match_layout_qualifier("binding", $1, state) == 0) {
1430          $$.flags.q.explicit_binding = 1;
1431          $$.binding = $3;
1432       }
1433
1434       if (match_layout_qualifier("set", $1, state) == 0) {
1435          $$.flags.q.vk_set = 1;
1436          $$.set = $3;
1437       }
1438
1439       if (state->has_atomic_counters() &&
1440           match_layout_qualifier("offset", $1, state) == 0) {
1441          $$.flags.q.explicit_offset = 1;
1442          $$.offset = $3;
1443       }
1444
1445       if (match_layout_qualifier("max_vertices", $1, state) == 0) {
1446          $$.flags.q.max_vertices = 1;
1447
1448          if ($3 < 0) {
1449             _mesa_glsl_error(& @3, state,
1450                              "invalid max_vertices %d specified", $3);
1451             YYERROR;
1452          } else {
1453             $$.max_vertices = $3;
1454             if (!state->is_version(150, 0)) {
1455                _mesa_glsl_error(& @3, state,
1456                                 "#version 150 max_vertices qualifier "
1457                                 "specified", $3);
1458             }
1459          }
1460       }
1461
1462       if (state->stage == MESA_SHADER_GEOMETRY) {
1463          if (match_layout_qualifier("stream", $1, state) == 0 &&
1464              state->check_explicit_attrib_stream_allowed(& @3)) {
1465             $$.flags.q.stream = 1;
1466
1467             if ($3 < 0) {
1468                _mesa_glsl_error(& @3, state,
1469                                 "invalid stream %d specified", $3);
1470                YYERROR;
1471             } else {
1472                $$.flags.q.explicit_stream = 1;
1473                $$.stream = $3;
1474             }
1475          }
1476       }
1477
1478       static const char * const local_size_qualifiers[3] = {
1479          "local_size_x",
1480          "local_size_y",
1481          "local_size_z",
1482       };
1483       for (int i = 0; i < 3; i++) {
1484          if (match_layout_qualifier(local_size_qualifiers[i], $1,
1485                                     state) == 0) {
1486             if ($3 <= 0) {
1487                _mesa_glsl_error(& @3, state,
1488                                 "invalid %s of %d specified",
1489                                 local_size_qualifiers[i], $3);
1490                YYERROR;
1491             } else if (!state->is_version(430, 0) &&
1492                        !state->ARB_compute_shader_enable) {
1493                _mesa_glsl_error(& @3, state,
1494                                 "%s qualifier requires GLSL 4.30 or "
1495                                 "ARB_compute_shader",
1496                                 local_size_qualifiers[i]);
1497                YYERROR;
1498             } else {
1499                $$.flags.q.local_size |= (1 << i);
1500                $$.local_size[i] = $3;
1501             }
1502             break;
1503          }
1504       }
1505
1506       if (match_layout_qualifier("invocations", $1, state) == 0) {
1507          $$.flags.q.invocations = 1;
1508
1509          if ($3 <= 0) {
1510             _mesa_glsl_error(& @3, state,
1511                              "invalid invocations %d specified", $3);
1512             YYERROR;
1513          } else if ($3 > MAX_GEOMETRY_SHADER_INVOCATIONS) {
1514             _mesa_glsl_error(& @3, state,
1515                              "invocations (%d) exceeds "
1516                              "GL_MAX_GEOMETRY_SHADER_INVOCATIONS", $3);
1517             YYERROR;
1518          } else {
1519             $$.invocations = $3;
1520             if (!state->is_version(400, 0) &&
1521                 !state->ARB_gpu_shader5_enable) {
1522                _mesa_glsl_error(& @3, state,
1523                                 "GL_ARB_gpu_shader5 invocations "
1524                                 "qualifier specified", $3);
1525             }
1526          }
1527       }
1528
1529       /* If the identifier didn't match any known layout identifiers,
1530        * emit an error.
1531        */
1532       if (!$$.flags.i) {
1533          _mesa_glsl_error(& @1, state, "unrecognized layout identifier "
1534                           "`%s'", $1);
1535          YYERROR;
1536       }
1537    }
1538    | interface_block_layout_qualifier
1539    {
1540       $$ = $1;
1541       /* Layout qualifiers for ARB_uniform_buffer_object. */
1542       if ($$.flags.q.uniform && !state->has_uniform_buffer_objects()) {
1543          _mesa_glsl_error(& @1, state,
1544                           "#version 140 / GL_ARB_uniform_buffer_object "
1545                           "layout qualifier `%s' is used", $1);
1546       } else if ($$.flags.q.uniform && state->ARB_uniform_buffer_object_warn) {
1547          _mesa_glsl_warning(& @1, state,
1548                             "#version 140 / GL_ARB_uniform_buffer_object "
1549                             "layout qualifier `%s' is used", $1);
1550       }
1551    }
1552    ;
1553
1554 /* This is a separate language rule because we parse these as tokens
1555  * (due to them being reserved keywords) instead of identifiers like
1556  * most qualifiers.  See the any_identifier path of
1557  * layout_qualifier_id for the others.
1558  *
1559  * Note that since layout qualifiers are case-insensitive in desktop
1560  * GLSL, all of these qualifiers need to be handled as identifiers as
1561  * well (by the any_identifier path of layout_qualifier_id).
1562  */
1563 interface_block_layout_qualifier:
1564    ROW_MAJOR
1565    {
1566       memset(& $$, 0, sizeof($$));
1567       $$.flags.q.row_major = 1;
1568    }
1569    | PACKED_TOK
1570    {
1571       memset(& $$, 0, sizeof($$));
1572       $$.flags.q.packed = 1;
1573    }
1574    ;
1575
1576 interpolation_qualifier:
1577    SMOOTH
1578    {
1579       memset(& $$, 0, sizeof($$));
1580       $$.flags.q.smooth = 1;
1581    }
1582    | FLAT
1583    {
1584       memset(& $$, 0, sizeof($$));
1585       $$.flags.q.flat = 1;
1586    }
1587    | NOPERSPECTIVE
1588    {
1589       memset(& $$, 0, sizeof($$));
1590       $$.flags.q.noperspective = 1;
1591    }
1592    ;
1593
1594 type_qualifier:
1595    /* Single qualifiers */
1596    INVARIANT
1597    {
1598       memset(& $$, 0, sizeof($$));
1599       $$.flags.q.invariant = 1;
1600    }
1601    | PRECISE
1602    {
1603       memset(& $$, 0, sizeof($$));
1604       $$.flags.q.precise = 1;
1605    }
1606    | auxiliary_storage_qualifier
1607    | storage_qualifier
1608    | interpolation_qualifier
1609    | layout_qualifier
1610    | memory_qualifier
1611    | precision_qualifier
1612    {
1613       memset(&$$, 0, sizeof($$));
1614       $$.precision = $1;
1615    }
1616
1617    /* Multiple qualifiers:
1618     * In GLSL 4.20, these can be specified in any order.  In earlier versions,
1619     * they appear in this order (see GLSL 1.50 section 4.7 & comments below):
1620     *
1621     *    invariant interpolation auxiliary storage precision  ...or...
1622     *    layout storage precision
1623     *
1624     * Each qualifier's rule ensures that the accumulated qualifiers on the right
1625     * side don't contain any that must appear on the left hand side.
1626     * For example, when processing a storage qualifier, we check that there are
1627     * no auxiliary, interpolation, layout, invariant, or precise qualifiers to the right.
1628     */
1629    | PRECISE type_qualifier
1630    {
1631       if ($2.flags.q.precise)
1632          _mesa_glsl_error(&@1, state, "duplicate \"precise\" qualifier");
1633
1634       $$ = $2;
1635       $$.flags.q.precise = 1;
1636    }
1637    | INVARIANT type_qualifier
1638    {
1639       if ($2.flags.q.invariant)
1640          _mesa_glsl_error(&@1, state, "duplicate \"invariant\" qualifier");
1641
1642       if (!state->ARB_shading_language_420pack_enable && $2.flags.q.precise)
1643          _mesa_glsl_error(&@1, state,
1644                           "\"invariant\" must come after \"precise\"");
1645
1646       $$ = $2;
1647       $$.flags.q.invariant = 1;
1648
1649       /* GLSL ES 3.00 spec, section 4.6.1 "The Invariant Qualifier":
1650        *
1651        * "Only variables output from a shader can be candidates for invariance.
1652        * This includes user-defined output variables and the built-in output
1653        * variables. As only outputs can be declared as invariant, an invariant
1654        * output from one shader stage will still match an input of a subsequent
1655        * stage without the input being declared as invariant."
1656        */
1657       if (state->es_shader && state->language_version >= 300 && $$.flags.q.in)
1658          _mesa_glsl_error(&@1, state, "invariant qualifiers cannot be used with shader inputs");
1659    }
1660    | interpolation_qualifier type_qualifier
1661    {
1662       /* Section 4.3 of the GLSL 1.40 specification states:
1663        * "...qualified with one of these interpolation qualifiers"
1664        *
1665        * GLSL 1.30 claims to allow "one or more", but insists that:
1666        * "These interpolation qualifiers may only precede the qualifiers in,
1667        *  centroid in, out, or centroid out in a declaration."
1668        *
1669        * ...which means that e.g. smooth can't precede smooth, so there can be
1670        * only one after all, and the 1.40 text is a clarification, not a change.
1671        */
1672       if ($2.has_interpolation())
1673          _mesa_glsl_error(&@1, state, "duplicate interpolation qualifier");
1674
1675       if (!state->ARB_shading_language_420pack_enable &&
1676           ($2.flags.q.precise || $2.flags.q.invariant)) {
1677          _mesa_glsl_error(&@1, state, "interpolation qualifiers must come "
1678                           "after \"precise\" or \"invariant\"");
1679       }
1680
1681       $$ = $1;
1682       $$.merge_qualifier(&@1, state, $2);
1683    }
1684    | layout_qualifier type_qualifier
1685    {
1686       /* In the absence of ARB_shading_language_420pack, layout qualifiers may
1687        * appear no later than auxiliary storage qualifiers. There is no
1688        * particularly clear spec language mandating this, but in all examples
1689        * the layout qualifier precedes the storage qualifier.
1690        *
1691        * We allow combinations of layout with interpolation, invariant or
1692        * precise qualifiers since these are useful in ARB_separate_shader_objects.
1693        * There is no clear spec guidance on this either.
1694        */
1695       if (!state->ARB_shading_language_420pack_enable && $2.has_layout())
1696          _mesa_glsl_error(&@1, state, "duplicate layout(...) qualifiers");
1697
1698       $$ = $1;
1699       $$.merge_qualifier(&@1, state, $2);
1700    }
1701    | auxiliary_storage_qualifier type_qualifier
1702    {
1703       if ($2.has_auxiliary_storage()) {
1704          _mesa_glsl_error(&@1, state,
1705                           "duplicate auxiliary storage qualifier (centroid or sample)");
1706       }
1707
1708       if (!state->ARB_shading_language_420pack_enable &&
1709           ($2.flags.q.precise || $2.flags.q.invariant ||
1710            $2.has_interpolation() || $2.has_layout())) {
1711          _mesa_glsl_error(&@1, state, "auxiliary storage qualifiers must come "
1712                           "just before storage qualifiers");
1713       }
1714       $$ = $1;
1715       $$.merge_qualifier(&@1, state, $2);
1716    }
1717    | storage_qualifier type_qualifier
1718    {
1719       /* Section 4.3 of the GLSL 1.20 specification states:
1720        * "Variable declarations may have a storage qualifier specified..."
1721        *  1.30 clarifies this to "may have one storage qualifier".
1722        */
1723       if ($2.has_storage())
1724          _mesa_glsl_error(&@1, state, "duplicate storage qualifier");
1725
1726       if (!state->ARB_shading_language_420pack_enable &&
1727           ($2.flags.q.precise || $2.flags.q.invariant || $2.has_interpolation() ||
1728            $2.has_layout() || $2.has_auxiliary_storage())) {
1729          _mesa_glsl_error(&@1, state, "storage qualifiers must come after "
1730                           "precise, invariant, interpolation, layout and auxiliary "
1731                           "storage qualifiers");
1732       }
1733
1734       $$ = $1;
1735       $$.merge_qualifier(&@1, state, $2);
1736    }
1737    | precision_qualifier type_qualifier
1738    {
1739       if ($2.precision != ast_precision_none)
1740          _mesa_glsl_error(&@1, state, "duplicate precision qualifier");
1741
1742       if (!state->ARB_shading_language_420pack_enable && $2.flags.i != 0)
1743          _mesa_glsl_error(&@1, state, "precision qualifiers must come last");
1744
1745       $$ = $2;
1746       $$.precision = $1;
1747    }
1748    | memory_qualifier type_qualifier
1749    {
1750       $$ = $1;
1751       $$.merge_qualifier(&@1, state, $2);
1752    }
1753    ;
1754
1755 auxiliary_storage_qualifier:
1756    CENTROID
1757    {
1758       memset(& $$, 0, sizeof($$));
1759       $$.flags.q.centroid = 1;
1760    }
1761    | SAMPLE
1762    {
1763       memset(& $$, 0, sizeof($$));
1764       $$.flags.q.sample = 1;
1765    }
1766    /* TODO: "patch" also goes here someday. */
1767
1768 storage_qualifier:
1769    CONST_TOK
1770    {
1771       memset(& $$, 0, sizeof($$));
1772       $$.flags.q.constant = 1;
1773    }
1774    | ATTRIBUTE
1775    {
1776       memset(& $$, 0, sizeof($$));
1777       $$.flags.q.attribute = 1;
1778    }
1779    | VARYING
1780    {
1781       memset(& $$, 0, sizeof($$));
1782       $$.flags.q.varying = 1;
1783    }
1784    | IN_TOK
1785    {
1786       memset(& $$, 0, sizeof($$));
1787       $$.flags.q.in = 1;
1788    }
1789    | OUT_TOK
1790    {
1791       memset(& $$, 0, sizeof($$));
1792       $$.flags.q.out = 1;
1793
1794       if (state->stage == MESA_SHADER_GEOMETRY &&
1795           state->has_explicit_attrib_stream()) {
1796          /* Section 4.3.8.2 (Output Layout Qualifiers) of the GLSL 4.00
1797           * spec says:
1798           *
1799           *     "If the block or variable is declared with the stream
1800           *     identifier, it is associated with the specified stream;
1801           *     otherwise, it is associated with the current default stream."
1802           */
1803           $$.flags.q.stream = 1;
1804           $$.flags.q.explicit_stream = 0;
1805           $$.stream = state->out_qualifier->stream;
1806       }
1807    }
1808    | UNIFORM
1809    {
1810       memset(& $$, 0, sizeof($$));
1811       $$.flags.q.uniform = 1;
1812    }
1813    ;
1814
1815 memory_qualifier:
1816    COHERENT
1817    {
1818       memset(& $$, 0, sizeof($$));
1819       $$.flags.q.coherent = 1;
1820    }
1821    | VOLATILE
1822    {
1823       memset(& $$, 0, sizeof($$));
1824       $$.flags.q._volatile = 1;
1825    }
1826    | RESTRICT
1827    {
1828       STATIC_ASSERT(sizeof($$.flags.q) <= sizeof($$.flags.i));
1829       memset(& $$, 0, sizeof($$));
1830       $$.flags.q.restrict_flag = 1;
1831    }
1832    | READONLY
1833    {
1834       memset(& $$, 0, sizeof($$));
1835       $$.flags.q.read_only = 1;
1836    }
1837    | WRITEONLY
1838    {
1839       memset(& $$, 0, sizeof($$));
1840       $$.flags.q.write_only = 1;
1841    }
1842    ;
1843
1844 array_specifier:
1845    '[' ']'
1846    {
1847       void *ctx = state;
1848       $$ = new(ctx) ast_array_specifier(@1);
1849       $$->set_location_range(@1, @2);
1850    }
1851    | '[' constant_expression ']'
1852    {
1853       void *ctx = state;
1854       $$ = new(ctx) ast_array_specifier(@1, $2);
1855       $$->set_location_range(@1, @3);
1856    }
1857    | array_specifier '[' ']'
1858    {
1859       $$ = $1;
1860
1861       if (!state->ARB_arrays_of_arrays_enable) {
1862          _mesa_glsl_error(& @1, state,
1863                           "GL_ARB_arrays_of_arrays "
1864                           "required for defining arrays of arrays");
1865       } else {
1866          _mesa_glsl_error(& @1, state,
1867                           "only the outermost array dimension can "
1868                           "be unsized");
1869       }
1870    }
1871    | array_specifier '[' constant_expression ']'
1872    {
1873       $$ = $1;
1874
1875       if (!state->ARB_arrays_of_arrays_enable) {
1876          _mesa_glsl_error(& @1, state,
1877                           "GL_ARB_arrays_of_arrays "
1878                           "required for defining arrays of arrays");
1879       }
1880
1881       $$->add_dimension($3);
1882    }
1883    ;
1884
1885 type_specifier:
1886    type_specifier_nonarray
1887    | type_specifier_nonarray array_specifier
1888    {
1889       $$ = $1;
1890       $$->array_specifier = $2;
1891    }
1892    ;
1893
1894 type_specifier_nonarray:
1895    basic_type_specifier_nonarray
1896    {
1897       void *ctx = state;
1898       $$ = new(ctx) ast_type_specifier($1);
1899       $$->set_location(@1);
1900    }
1901    | struct_specifier
1902    {
1903       void *ctx = state;
1904       $$ = new(ctx) ast_type_specifier($1);
1905       $$->set_location(@1);
1906    }
1907    | TYPE_IDENTIFIER
1908    {
1909       void *ctx = state;
1910       $$ = new(ctx) ast_type_specifier($1);
1911       $$->set_location(@1);
1912    }
1913    ;
1914
1915 basic_type_specifier_nonarray:
1916    VOID_TOK                 { $$ = "void"; }
1917    | FLOAT_TOK              { $$ = "float"; }
1918    | DOUBLE_TOK             { $$ = "double"; }
1919    | INT_TOK                { $$ = "int"; }
1920    | UINT_TOK               { $$ = "uint"; }
1921    | BOOL_TOK               { $$ = "bool"; }
1922    | VEC2                   { $$ = "vec2"; }
1923    | VEC3                   { $$ = "vec3"; }
1924    | VEC4                   { $$ = "vec4"; }
1925    | BVEC2                  { $$ = "bvec2"; }
1926    | BVEC3                  { $$ = "bvec3"; }
1927    | BVEC4                  { $$ = "bvec4"; }
1928    | IVEC2                  { $$ = "ivec2"; }
1929    | IVEC3                  { $$ = "ivec3"; }
1930    | IVEC4                  { $$ = "ivec4"; }
1931    | UVEC2                  { $$ = "uvec2"; }
1932    | UVEC3                  { $$ = "uvec3"; }
1933    | UVEC4                  { $$ = "uvec4"; }
1934    | DVEC2                  { $$ = "dvec2"; }
1935    | DVEC3                  { $$ = "dvec3"; }
1936    | DVEC4                  { $$ = "dvec4"; }
1937    | MAT2X2                 { $$ = "mat2"; }
1938    | MAT2X3                 { $$ = "mat2x3"; }
1939    | MAT2X4                 { $$ = "mat2x4"; }
1940    | MAT3X2                 { $$ = "mat3x2"; }
1941    | MAT3X3                 { $$ = "mat3"; }
1942    | MAT3X4                 { $$ = "mat3x4"; }
1943    | MAT4X2                 { $$ = "mat4x2"; }
1944    | MAT4X3                 { $$ = "mat4x3"; }
1945    | MAT4X4                 { $$ = "mat4"; }
1946    | DMAT2X2                { $$ = "dmat2"; }
1947    | DMAT2X3                { $$ = "dmat2x3"; }
1948    | DMAT2X4                { $$ = "dmat2x4"; }
1949    | DMAT3X2                { $$ = "dmat3x2"; }
1950    | DMAT3X3                { $$ = "dmat3"; }
1951    | DMAT3X4                { $$ = "dmat3x4"; }
1952    | DMAT4X2                { $$ = "dmat4x2"; }
1953    | DMAT4X3                { $$ = "dmat4x3"; }
1954    | DMAT4X4                { $$ = "dmat4"; }
1955    | SAMPLER1D              { $$ = "sampler1D"; }
1956    | SAMPLER2D              { $$ = "sampler2D"; }
1957    | SAMPLER2DRECT          { $$ = "sampler2DRect"; }
1958    | SAMPLER3D              { $$ = "sampler3D"; }
1959    | SAMPLERCUBE            { $$ = "samplerCube"; }
1960    | SAMPLEREXTERNALOES     { $$ = "samplerExternalOES"; }
1961    | SAMPLER1DSHADOW        { $$ = "sampler1DShadow"; }
1962    | SAMPLER2DSHADOW        { $$ = "sampler2DShadow"; }
1963    | SAMPLER2DRECTSHADOW    { $$ = "sampler2DRectShadow"; }
1964    | SAMPLERCUBESHADOW      { $$ = "samplerCubeShadow"; }
1965    | SAMPLER1DARRAY         { $$ = "sampler1DArray"; }
1966    | SAMPLER2DARRAY         { $$ = "sampler2DArray"; }
1967    | SAMPLER1DARRAYSHADOW   { $$ = "sampler1DArrayShadow"; }
1968    | SAMPLER2DARRAYSHADOW   { $$ = "sampler2DArrayShadow"; }
1969    | SAMPLERBUFFER          { $$ = "samplerBuffer"; }
1970    | SAMPLERCUBEARRAY       { $$ = "samplerCubeArray"; }
1971    | SAMPLERCUBEARRAYSHADOW { $$ = "samplerCubeArrayShadow"; }
1972    | ISAMPLER1D             { $$ = "isampler1D"; }
1973    | ISAMPLER2D             { $$ = "isampler2D"; }
1974    | ISAMPLER2DRECT         { $$ = "isampler2DRect"; }
1975    | ISAMPLER3D             { $$ = "isampler3D"; }
1976    | ISAMPLERCUBE           { $$ = "isamplerCube"; }
1977    | ISAMPLER1DARRAY        { $$ = "isampler1DArray"; }
1978    | ISAMPLER2DARRAY        { $$ = "isampler2DArray"; }
1979    | ISAMPLERBUFFER         { $$ = "isamplerBuffer"; }
1980    | ISAMPLERCUBEARRAY      { $$ = "isamplerCubeArray"; }
1981    | USAMPLER1D             { $$ = "usampler1D"; }
1982    | USAMPLER2D             { $$ = "usampler2D"; }
1983    | USAMPLER2DRECT         { $$ = "usampler2DRect"; }
1984    | USAMPLER3D             { $$ = "usampler3D"; }
1985    | USAMPLERCUBE           { $$ = "usamplerCube"; }
1986    | USAMPLER1DARRAY        { $$ = "usampler1DArray"; }
1987    | USAMPLER2DARRAY        { $$ = "usampler2DArray"; }
1988    | USAMPLERBUFFER         { $$ = "usamplerBuffer"; }
1989    | USAMPLERCUBEARRAY      { $$ = "usamplerCubeArray"; }
1990    | SAMPLER2DMS            { $$ = "sampler2DMS"; }
1991    | ISAMPLER2DMS           { $$ = "isampler2DMS"; }
1992    | USAMPLER2DMS           { $$ = "usampler2DMS"; }
1993    | SAMPLER2DMSARRAY       { $$ = "sampler2DMSArray"; }
1994    | ISAMPLER2DMSARRAY      { $$ = "isampler2DMSArray"; }
1995    | USAMPLER2DMSARRAY      { $$ = "usampler2DMSArray"; }
1996    | IMAGE1D                { $$ = "image1D"; }
1997    | IMAGE2D                { $$ = "image2D"; }
1998    | IMAGE3D                { $$ = "image3D"; }
1999    | IMAGE2DRECT            { $$ = "image2DRect"; }
2000    | IMAGECUBE              { $$ = "imageCube"; }
2001    | IMAGEBUFFER            { $$ = "imageBuffer"; }
2002    | IMAGE1DARRAY           { $$ = "image1DArray"; }
2003    | IMAGE2DARRAY           { $$ = "image2DArray"; }
2004    | IMAGECUBEARRAY         { $$ = "imageCubeArray"; }
2005    | IMAGE2DMS              { $$ = "image2DMS"; }
2006    | IMAGE2DMSARRAY         { $$ = "image2DMSArray"; }
2007    | IIMAGE1D               { $$ = "iimage1D"; }
2008    | IIMAGE2D               { $$ = "iimage2D"; }
2009    | IIMAGE3D               { $$ = "iimage3D"; }
2010    | IIMAGE2DRECT           { $$ = "iimage2DRect"; }
2011    | IIMAGECUBE             { $$ = "iimageCube"; }
2012    | IIMAGEBUFFER           { $$ = "iimageBuffer"; }
2013    | IIMAGE1DARRAY          { $$ = "iimage1DArray"; }
2014    | IIMAGE2DARRAY          { $$ = "iimage2DArray"; }
2015    | IIMAGECUBEARRAY        { $$ = "iimageCubeArray"; }
2016    | IIMAGE2DMS             { $$ = "iimage2DMS"; }
2017    | IIMAGE2DMSARRAY        { $$ = "iimage2DMSArray"; }
2018    | UIMAGE1D               { $$ = "uimage1D"; }
2019    | UIMAGE2D               { $$ = "uimage2D"; }
2020    | UIMAGE3D               { $$ = "uimage3D"; }
2021    | UIMAGE2DRECT           { $$ = "uimage2DRect"; }
2022    | UIMAGECUBE             { $$ = "uimageCube"; }
2023    | UIMAGEBUFFER           { $$ = "uimageBuffer"; }
2024    | UIMAGE1DARRAY          { $$ = "uimage1DArray"; }
2025    | UIMAGE2DARRAY          { $$ = "uimage2DArray"; }
2026    | UIMAGECUBEARRAY        { $$ = "uimageCubeArray"; }
2027    | UIMAGE2DMS             { $$ = "uimage2DMS"; }
2028    | UIMAGE2DMSARRAY        { $$ = "uimage2DMSArray"; }
2029    | ATOMIC_UINT            { $$ = "atomic_uint"; }
2030    ;
2031
2032 precision_qualifier:
2033    HIGHP
2034    {
2035       state->check_precision_qualifiers_allowed(&@1);
2036       $$ = ast_precision_high;
2037    }
2038    | MEDIUMP
2039    {
2040       state->check_precision_qualifiers_allowed(&@1);
2041       $$ = ast_precision_medium;
2042    }
2043    | LOWP
2044    {
2045       state->check_precision_qualifiers_allowed(&@1);
2046       $$ = ast_precision_low;
2047    }
2048    ;
2049
2050 struct_specifier:
2051    STRUCT any_identifier '{' struct_declaration_list '}'
2052    {
2053       void *ctx = state;
2054       $$ = new(ctx) ast_struct_specifier($2, $4);
2055       $$->set_location_range(@2, @5);
2056       state->symbols->add_type($2, glsl_type::void_type);
2057    }
2058    | STRUCT '{' struct_declaration_list '}'
2059    {
2060       void *ctx = state;
2061       $$ = new(ctx) ast_struct_specifier(NULL, $3);
2062       $$->set_location_range(@2, @4);
2063    }
2064    ;
2065
2066 struct_declaration_list:
2067    struct_declaration
2068    {
2069       $$ = $1;
2070       $1->link.self_link();
2071    }
2072    | struct_declaration_list struct_declaration
2073    {
2074       $$ = $1;
2075       $$->link.insert_before(& $2->link);
2076    }
2077    ;
2078
2079 struct_declaration:
2080    fully_specified_type struct_declarator_list ';'
2081    {
2082       void *ctx = state;
2083       ast_fully_specified_type *const type = $1;
2084       type->set_location(@1);
2085
2086       if (type->qualifier.flags.i != 0)
2087          _mesa_glsl_error(&@1, state,
2088                           "only precision qualifiers may be applied to "
2089                           "structure members");
2090
2091       $$ = new(ctx) ast_declarator_list(type);
2092       $$->set_location(@2);
2093
2094       $$->declarations.push_degenerate_list_at_head(& $2->link);
2095    }
2096    ;
2097
2098 struct_declarator_list:
2099    struct_declarator
2100    {
2101       $$ = $1;
2102       $1->link.self_link();
2103    }
2104    | struct_declarator_list ',' struct_declarator
2105    {
2106       $$ = $1;
2107       $$->link.insert_before(& $3->link);
2108    }
2109    ;
2110
2111 struct_declarator:
2112    any_identifier
2113    {
2114       void *ctx = state;
2115       $$ = new(ctx) ast_declaration($1, NULL, NULL);
2116       $$->set_location(@1);
2117    }
2118    | any_identifier array_specifier
2119    {
2120       void *ctx = state;
2121       $$ = new(ctx) ast_declaration($1, $2, NULL);
2122       $$->set_location_range(@1, @2);
2123    }
2124    ;
2125
2126 initializer:
2127    assignment_expression
2128    | '{' initializer_list '}'
2129    {
2130       $$ = $2;
2131    }
2132    | '{' initializer_list ',' '}'
2133    {
2134       $$ = $2;
2135    }
2136    ;
2137
2138 initializer_list:
2139    initializer
2140    {
2141       void *ctx = state;
2142       $$ = new(ctx) ast_aggregate_initializer();
2143       $$->set_location(@1);
2144       $$->expressions.push_tail(& $1->link);
2145    }
2146    | initializer_list ',' initializer
2147    {
2148       $1->expressions.push_tail(& $3->link);
2149    }
2150    ;
2151
2152 declaration_statement:
2153    declaration
2154    ;
2155
2156    // Grammar Note: labeled statements for SWITCH only; 'goto' is not
2157    // supported.
2158 statement:
2159    compound_statement        { $$ = (ast_node *) $1; }
2160    | simple_statement
2161    ;
2162
2163 simple_statement:
2164    declaration_statement
2165    | expression_statement
2166    | selection_statement
2167    | switch_statement
2168    | iteration_statement
2169    | jump_statement
2170    ;
2171
2172 compound_statement:
2173    '{' '}'
2174    {
2175       void *ctx = state;
2176       $$ = new(ctx) ast_compound_statement(true, NULL);
2177       $$->set_location_range(@1, @2);
2178    }
2179    | '{'
2180    {
2181       state->symbols->push_scope();
2182    }
2183    statement_list '}'
2184    {
2185       void *ctx = state;
2186       $$ = new(ctx) ast_compound_statement(true, $3);
2187       $$->set_location_range(@1, @4);
2188       state->symbols->pop_scope();
2189    }
2190    ;
2191
2192 statement_no_new_scope:
2193    compound_statement_no_new_scope { $$ = (ast_node *) $1; }
2194    | simple_statement
2195    ;
2196
2197 compound_statement_no_new_scope:
2198    '{' '}'
2199    {
2200       void *ctx = state;
2201       $$ = new(ctx) ast_compound_statement(false, NULL);
2202       $$->set_location_range(@1, @2);
2203    }
2204    | '{' statement_list '}'
2205    {
2206       void *ctx = state;
2207       $$ = new(ctx) ast_compound_statement(false, $2);
2208       $$->set_location_range(@1, @3);
2209    }
2210    ;
2211
2212 statement_list:
2213    statement
2214    {
2215       if ($1 == NULL) {
2216          _mesa_glsl_error(& @1, state, "<nil> statement");
2217          assert($1 != NULL);
2218       }
2219
2220       $$ = $1;
2221       $$->link.self_link();
2222    }
2223    | statement_list statement
2224    {
2225       if ($2 == NULL) {
2226          _mesa_glsl_error(& @2, state, "<nil> statement");
2227          assert($2 != NULL);
2228       }
2229       $$ = $1;
2230       $$->link.insert_before(& $2->link);
2231    }
2232    ;
2233
2234 expression_statement:
2235    ';'
2236    {
2237       void *ctx = state;
2238       $$ = new(ctx) ast_expression_statement(NULL);
2239       $$->set_location(@1);
2240    }
2241    | expression ';'
2242    {
2243       void *ctx = state;
2244       $$ = new(ctx) ast_expression_statement($1);
2245       $$->set_location(@1);
2246    }
2247    ;
2248
2249 selection_statement:
2250    IF '(' expression ')' selection_rest_statement
2251    {
2252       $$ = new(state) ast_selection_statement($3, $5.then_statement,
2253                                               $5.else_statement);
2254       $$->set_location_range(@1, @5);
2255    }
2256    ;
2257
2258 selection_rest_statement:
2259    statement ELSE statement
2260    {
2261       $$.then_statement = $1;
2262       $$.else_statement = $3;
2263    }
2264    | statement %prec THEN
2265    {
2266       $$.then_statement = $1;
2267       $$.else_statement = NULL;
2268    }
2269    ;
2270
2271 condition:
2272    expression
2273    {
2274       $$ = (ast_node *) $1;
2275    }
2276    | fully_specified_type any_identifier '=' initializer
2277    {
2278       void *ctx = state;
2279       ast_declaration *decl = new(ctx) ast_declaration($2, NULL, $4);
2280       ast_declarator_list *declarator = new(ctx) ast_declarator_list($1);
2281       decl->set_location_range(@2, @4);
2282       declarator->set_location(@1);
2283
2284       declarator->declarations.push_tail(&decl->link);
2285       $$ = declarator;
2286    }
2287    ;
2288
2289 /*
2290  * switch_statement grammar is based on the syntax described in the body
2291  * of the GLSL spec, not in it's appendix!!!
2292  */
2293 switch_statement:
2294    SWITCH '(' expression ')' switch_body
2295    {
2296       $$ = new(state) ast_switch_statement($3, $5);
2297       $$->set_location_range(@1, @5);
2298    }
2299    ;
2300
2301 switch_body:
2302    '{' '}'
2303    {
2304       $$ = new(state) ast_switch_body(NULL);
2305       $$->set_location_range(@1, @2);
2306    }
2307    | '{' case_statement_list '}'
2308    {
2309       $$ = new(state) ast_switch_body($2);
2310       $$->set_location_range(@1, @3);
2311    }
2312    ;
2313
2314 case_label:
2315    CASE expression ':'
2316    {
2317       $$ = new(state) ast_case_label($2);
2318       $$->set_location(@2);
2319    }
2320    | DEFAULT ':'
2321    {
2322       $$ = new(state) ast_case_label(NULL);
2323       $$->set_location(@2);
2324    }
2325    ;
2326
2327 case_label_list:
2328    case_label
2329    {
2330       ast_case_label_list *labels = new(state) ast_case_label_list();
2331
2332       labels->labels.push_tail(& $1->link);
2333       $$ = labels;
2334       $$->set_location(@1);
2335    }
2336    | case_label_list case_label
2337    {
2338       $$ = $1;
2339       $$->labels.push_tail(& $2->link);
2340    }
2341    ;
2342
2343 case_statement:
2344    case_label_list statement
2345    {
2346       ast_case_statement *stmts = new(state) ast_case_statement($1);
2347       stmts->set_location(@2);
2348
2349       stmts->stmts.push_tail(& $2->link);
2350       $$ = stmts;
2351    }
2352    | case_statement statement
2353    {
2354       $$ = $1;
2355       $$->stmts.push_tail(& $2->link);
2356    }
2357    ;
2358
2359 case_statement_list:
2360    case_statement
2361    {
2362       ast_case_statement_list *cases= new(state) ast_case_statement_list();
2363       cases->set_location(@1);
2364
2365       cases->cases.push_tail(& $1->link);
2366       $$ = cases;
2367    }
2368    | case_statement_list case_statement
2369    {
2370       $$ = $1;
2371       $$->cases.push_tail(& $2->link);
2372    }
2373    ;
2374
2375 iteration_statement:
2376    WHILE '(' condition ')' statement_no_new_scope
2377    {
2378       void *ctx = state;
2379       $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_while,
2380                                             NULL, $3, NULL, $5);
2381       $$->set_location_range(@1, @4);
2382    }
2383    | DO statement WHILE '(' expression ')' ';'
2384    {
2385       void *ctx = state;
2386       $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_do_while,
2387                                             NULL, $5, NULL, $2);
2388       $$->set_location_range(@1, @6);
2389    }
2390    | FOR '(' for_init_statement for_rest_statement ')' statement_no_new_scope
2391    {
2392       void *ctx = state;
2393       $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_for,
2394                                             $3, $4.cond, $4.rest, $6);
2395       $$->set_location_range(@1, @6);
2396    }
2397    ;
2398
2399 for_init_statement:
2400    expression_statement
2401    | declaration_statement
2402    ;
2403
2404 conditionopt:
2405    condition
2406    | /* empty */
2407    {
2408       $$ = NULL;
2409    }
2410    ;
2411
2412 for_rest_statement:
2413    conditionopt ';'
2414    {
2415       $$.cond = $1;
2416       $$.rest = NULL;
2417    }
2418    | conditionopt ';' expression
2419    {
2420       $$.cond = $1;
2421       $$.rest = $3;
2422    }
2423    ;
2424
2425    // Grammar Note: No 'goto'. Gotos are not supported.
2426 jump_statement:
2427    CONTINUE ';'
2428    {
2429       void *ctx = state;
2430       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_continue, NULL);
2431       $$->set_location(@1);
2432    }
2433    | BREAK ';'
2434    {
2435       void *ctx = state;
2436       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_break, NULL);
2437       $$->set_location(@1);
2438    }
2439    | RETURN ';'
2440    {
2441       void *ctx = state;
2442       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, NULL);
2443       $$->set_location(@1);
2444    }
2445    | RETURN expression ';'
2446    {
2447       void *ctx = state;
2448       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, $2);
2449       $$->set_location_range(@1, @2);
2450    }
2451    | DISCARD ';' // Fragment shader only.
2452    {
2453       void *ctx = state;
2454       $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_discard, NULL);
2455       $$->set_location(@1);
2456    }
2457    ;
2458
2459 external_declaration:
2460    function_definition      { $$ = $1; }
2461    | declaration            { $$ = $1; }
2462    | pragma_statement       { $$ = NULL; }
2463    | layout_defaults        { $$ = $1; }
2464    ;
2465
2466 function_definition:
2467    function_prototype compound_statement_no_new_scope
2468    {
2469       void *ctx = state;
2470       $$ = new(ctx) ast_function_definition();
2471       $$->set_location_range(@1, @2);
2472       $$->prototype = $1;
2473       $$->body = $2;
2474
2475       state->symbols->pop_scope();
2476    }
2477    ;
2478
2479 /* layout_qualifieropt is packed into this rule */
2480 interface_block:
2481    basic_interface_block
2482    {
2483       $$ = $1;
2484    }
2485    | layout_qualifier basic_interface_block
2486    {
2487       ast_interface_block *block = $2;
2488       if (!block->layout.merge_qualifier(& @1, state, $1)) {
2489          YYERROR;
2490       }
2491
2492       foreach_list_typed (ast_declarator_list, member, link, &block->declarations) {
2493          ast_type_qualifier& qualifier = member->type->qualifier;
2494          if (qualifier.flags.q.stream && qualifier.stream != block->layout.stream) {
2495                _mesa_glsl_error(& @1, state,
2496                              "stream layout qualifier on "
2497                              "interface block member does not match "
2498                              "the interface block (%d vs %d)",
2499                              qualifier.stream, block->layout.stream);
2500                YYERROR;
2501          }
2502       }
2503       $$ = block;
2504    }
2505    ;
2506
2507 basic_interface_block:
2508    interface_qualifier NEW_IDENTIFIER '{' member_list '}' instance_name_opt ';'
2509    {
2510       ast_interface_block *const block = $6;
2511
2512       block->block_name = $2;
2513       block->declarations.push_degenerate_list_at_head(& $4->link);
2514
2515       if ($1.flags.q.uniform) {
2516          if (!state->has_uniform_buffer_objects()) {
2517             _mesa_glsl_error(& @1, state,
2518                              "#version 140 / GL_ARB_uniform_buffer_object "
2519                              "required for defining uniform blocks");
2520          } else if (state->ARB_uniform_buffer_object_warn) {
2521             _mesa_glsl_warning(& @1, state,
2522                                "#version 140 / GL_ARB_uniform_buffer_object "
2523                                "required for defining uniform blocks");
2524          }
2525       } else {
2526          if (state->es_shader || state->language_version < 150) {
2527             _mesa_glsl_error(& @1, state,
2528                              "#version 150 required for using "
2529                              "interface blocks");
2530          }
2531       }
2532
2533       /* From the GLSL 1.50.11 spec, section 4.3.7 ("Interface Blocks"):
2534        * "It is illegal to have an input block in a vertex shader
2535        *  or an output block in a fragment shader"
2536        */
2537       if ((state->stage == MESA_SHADER_VERTEX) && $1.flags.q.in) {
2538          _mesa_glsl_error(& @1, state,
2539                           "`in' interface block is not allowed for "
2540                           "a vertex shader");
2541       } else if ((state->stage == MESA_SHADER_FRAGMENT) && $1.flags.q.out) {
2542          _mesa_glsl_error(& @1, state,
2543                           "`out' interface block is not allowed for "
2544                           "a fragment shader");
2545       }
2546
2547       /* Since block arrays require names, and both features are added in
2548        * the same language versions, we don't have to explicitly
2549        * version-check both things.
2550        */
2551       if (block->instance_name != NULL) {
2552          state->check_version(150, 300, & @1, "interface blocks with "
2553                                "an instance name are not allowed");
2554       }
2555
2556       uint64_t interface_type_mask;
2557       struct ast_type_qualifier temp_type_qualifier;
2558
2559       /* Get a bitmask containing only the in/out/uniform flags, allowing us
2560        * to ignore other irrelevant flags like interpolation qualifiers.
2561        */
2562       temp_type_qualifier.flags.i = 0;
2563       temp_type_qualifier.flags.q.uniform = true;
2564       temp_type_qualifier.flags.q.in = true;
2565       temp_type_qualifier.flags.q.out = true;
2566       interface_type_mask = temp_type_qualifier.flags.i;
2567
2568       /* Get the block's interface qualifier.  The interface_qualifier
2569        * production rule guarantees that only one bit will be set (and
2570        * it will be in/out/uniform).
2571        */
2572       uint64_t block_interface_qualifier = $1.flags.i;
2573
2574       block->layout.flags.i |= block_interface_qualifier;
2575
2576       if (state->stage == MESA_SHADER_GEOMETRY &&
2577           state->has_explicit_attrib_stream()) {
2578          /* Assign global layout's stream value. */
2579          block->layout.flags.q.stream = 1;
2580          block->layout.flags.q.explicit_stream = 0;
2581          block->layout.stream = state->out_qualifier->stream;
2582       }
2583
2584       foreach_list_typed (ast_declarator_list, member, link, &block->declarations) {
2585          ast_type_qualifier& qualifier = member->type->qualifier;
2586          if ((qualifier.flags.i & interface_type_mask) == 0) {
2587             /* GLSLangSpec.1.50.11, 4.3.7 (Interface Blocks):
2588              * "If no optional qualifier is used in a member declaration, the
2589              *  qualifier of the variable is just in, out, or uniform as declared
2590              *  by interface-qualifier."
2591              */
2592             qualifier.flags.i |= block_interface_qualifier;
2593          } else if ((qualifier.flags.i & interface_type_mask) !=
2594                     block_interface_qualifier) {
2595             /* GLSLangSpec.1.50.11, 4.3.7 (Interface Blocks):
2596              * "If optional qualifiers are used, they can include interpolation
2597              *  and storage qualifiers and they must declare an input, output,
2598              *  or uniform variable consistent with the interface qualifier of
2599              *  the block."
2600              */
2601             _mesa_glsl_error(& @1, state,
2602                              "uniform/in/out qualifier on "
2603                              "interface block member does not match "
2604                              "the interface block");
2605          }
2606
2607          /* From GLSL ES 3.0, chapter 4.3.7 "Interface Blocks":
2608           *
2609           * "GLSL ES 3.0 does not support interface blocks for shader inputs or
2610           * outputs."
2611           *
2612           * And from GLSL ES 3.0, chapter 4.6.1 "The invariant qualifier":.
2613           *
2614           * "Only variables output from a shader can be candidates for
2615           * invariance."
2616           *
2617           * From GLSL 4.40 and GLSL 1.50, section "Interface Blocks":
2618           *
2619           * "If optional qualifiers are used, they can include interpolation
2620           * qualifiers, auxiliary storage qualifiers, and storage qualifiers
2621           * and they must declare an input, output, or uniform member
2622           * consistent with the interface qualifier of the block"
2623           */
2624          if (qualifier.flags.q.invariant)
2625             _mesa_glsl_error(&@1, state,
2626                              "invariant qualifiers cannot be used "
2627                              "with interface blocks members");
2628       }
2629
2630       $$ = block;
2631    }
2632    ;
2633
2634 interface_qualifier:
2635    IN_TOK
2636    {
2637       memset(& $$, 0, sizeof($$));
2638       $$.flags.q.in = 1;
2639    }
2640    | OUT_TOK
2641    {
2642       memset(& $$, 0, sizeof($$));
2643       $$.flags.q.out = 1;
2644    }
2645    | UNIFORM
2646    {
2647       memset(& $$, 0, sizeof($$));
2648       $$.flags.q.uniform = 1;
2649    }
2650    ;
2651
2652 instance_name_opt:
2653    /* empty */
2654    {
2655       $$ = new(state) ast_interface_block(*state->default_uniform_qualifier,
2656                                           NULL, NULL);
2657    }
2658    | NEW_IDENTIFIER
2659    {
2660       $$ = new(state) ast_interface_block(*state->default_uniform_qualifier,
2661                                           $1, NULL);
2662       $$->set_location(@1);
2663    }
2664    | NEW_IDENTIFIER array_specifier
2665    {
2666       $$ = new(state) ast_interface_block(*state->default_uniform_qualifier,
2667                                           $1, $2);
2668       $$->set_location_range(@1, @2);
2669    }
2670    ;
2671
2672 member_list:
2673    member_declaration
2674    {
2675       $$ = $1;
2676       $1->link.self_link();
2677    }
2678    | member_declaration member_list
2679    {
2680       $$ = $1;
2681       $2->link.insert_before(& $$->link);
2682    }
2683    ;
2684
2685 member_declaration:
2686    fully_specified_type struct_declarator_list ';'
2687    {
2688       void *ctx = state;
2689       ast_fully_specified_type *type = $1;
2690       type->set_location(@1);
2691
2692       if (type->qualifier.flags.q.attribute) {
2693          _mesa_glsl_error(& @1, state,
2694                           "keyword 'attribute' cannot be used with "
2695                           "interface block member");
2696       } else if (type->qualifier.flags.q.varying) {
2697          _mesa_glsl_error(& @1, state,
2698                           "keyword 'varying' cannot be used with "
2699                           "interface block member");
2700       }
2701
2702       $$ = new(ctx) ast_declarator_list(type);
2703       $$->set_location(@2);
2704
2705       $$->declarations.push_degenerate_list_at_head(& $2->link);
2706    }
2707    ;
2708
2709 layout_defaults:
2710    layout_qualifier UNIFORM ';'
2711    {
2712       if (!state->default_uniform_qualifier->merge_qualifier(& @1, state, $1)) {
2713          YYERROR;
2714       }
2715       $$ = NULL;
2716    }
2717
2718    | layout_qualifier IN_TOK ';'
2719    {
2720       $$ = NULL;
2721       if (!state->in_qualifier->merge_in_qualifier(& @1, state, $1, $$)) {
2722          YYERROR;
2723       }
2724    }
2725
2726    | layout_qualifier OUT_TOK ';'
2727    {
2728       if (state->stage != MESA_SHADER_GEOMETRY) {
2729          _mesa_glsl_error(& @1, state,
2730                           "out layout qualifiers only valid in "
2731                           "geometry shaders");
2732       } else {
2733          if ($1.flags.q.prim_type) {
2734             /* Make sure this is a valid output primitive type. */
2735             switch ($1.prim_type) {
2736             case GL_POINTS:
2737             case GL_LINE_STRIP:
2738             case GL_TRIANGLE_STRIP:
2739                break;
2740             default:
2741                _mesa_glsl_error(&@1, state, "invalid geometry shader output "
2742                                 "primitive type");
2743                break;
2744             }
2745          }
2746          if (!state->out_qualifier->merge_qualifier(& @1, state, $1))
2747             YYERROR;
2748
2749          /* Allow future assigments of global out's stream id value */
2750          state->out_qualifier->flags.q.explicit_stream = 0;
2751       }
2752       $$ = NULL;
2753    }