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