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