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("num_views", $1, state) == 0) { 1769 $$.flags.q.explicit_numviews = 1; 1770 $$.num_views = $3; 1771 } 1772 1773 if (match_layout_qualifier("component", $1, state) == 0) { 1774 if (!state->has_enhanced_layouts()) { 1775 _mesa_glsl_error(& @1, state, 1776 "component qualifier requires " 1777 "GLSL 4.40 or ARB_enhanced_layouts"); 1778 } else { 1779 $$.flags.q.explicit_component = 1; 1780 $$.component = $3; 1781 } 1782 } 1783 1784 if (match_layout_qualifier("index", $1, state) == 0) { 1785 if (state->es_shader && !state->EXT_blend_func_extended_enable) { 1786 _mesa_glsl_error(& @3, state, "index layout qualifier requires EXT_blend_func_extended"); 1787 YYERROR; 1788 } 1789 1790 $$.flags.q.explicit_index = 1; 1791 $$.index = $3; 1792 } 1793 1794 if ((state->has_420pack_or_es31() || 1795 state->has_atomic_counters() || 1796 state->has_shader_storage_buffer_objects()) && 1797 match_layout_qualifier("binding", $1, state) == 0) { 1798 $$.flags.q.explicit_binding = 1; 1799 $$.binding = $3; 1800 } 1801 1802 if ((state->has_atomic_counters() || 1803 state->has_enhanced_layouts()) && 1804 match_layout_qualifier("offset", $1, state) == 0) { 1805 $$.flags.q.explicit_offset = 1; 1806 $$.offset = $3; 1807 } 1808 1809 if (match_layout_qualifier("max_vertices", $1, state) == 0) { 1810 $$.flags.q.max_vertices = 1; 1811 $$.max_vertices = new(ctx) ast_layout_expression(@1, $3); 1812 if (!state->has_geometry_shader()) { 1813 _mesa_glsl_error(& @3, state, 1814 "#version 150 max_vertices qualifier " 1815 "specified"); 1816 } 1817 } 1818 1819 if (state->stage == MESA_SHADER_GEOMETRY) { 1820 if (match_layout_qualifier("stream", $1, state) == 0 && 1821 state->check_explicit_attrib_stream_allowed(& @3)) { 1822 $$.flags.q.stream = 1; 1823 $$.flags.q.explicit_stream = 1; 1824 $$.stream = $3; 1825 } 1826 } 1827 1828 if (state->has_enhanced_layouts()) { 1829 if (match_layout_qualifier("xfb_buffer", $1, state) == 0) { 1830 $$.flags.q.xfb_buffer = 1; 1831 $$.flags.q.explicit_xfb_buffer = 1; 1832 $$.xfb_buffer = $3; 1833 } 1834 1835 if (match_layout_qualifier("xfb_offset", $1, state) == 0) { 1836 $$.flags.q.explicit_xfb_offset = 1; 1837 $$.offset = $3; 1838 } 1839 1840 if (match_layout_qualifier("xfb_stride", $1, state) == 0) { 1841 $$.flags.q.xfb_stride = 1; 1842 $$.flags.q.explicit_xfb_stride = 1; 1843 $$.xfb_stride = $3; 1844 } 1845 } 1846 1847 static const char * const local_size_qualifiers[3] = { 1848 "local_size_x", 1849 "local_size_y", 1850 "local_size_z", 1851 }; 1852 for (int i = 0; i < 3; i++) { 1853 if (match_layout_qualifier(local_size_qualifiers[i], $1, 1854 state) == 0) { 1855 if (!state->has_compute_shader()) { 1856 _mesa_glsl_error(& @3, state, 1857 "%s qualifier requires GLSL 4.30 or " 1858 "GLSL ES 3.10 or ARB_compute_shader", 1859 local_size_qualifiers[i]); 1860 YYERROR; 1861 } else { 1862 $$.flags.q.local_size |= (1 << i); 1863 $$.local_size[i] = new(ctx) ast_layout_expression(@1, $3); 1864 } 1865 break; 1866 } 1867 } 1868 1869 if (match_layout_qualifier("invocations", $1, state) == 0) { 1870 $$.flags.q.invocations = 1; 1871 $$.invocations = new(ctx) ast_layout_expression(@1, $3); 1872 if (!state->is_version(400, 320) && 1873 !state->ARB_gpu_shader5_enable && 1874 !state->OES_geometry_shader_enable && 1875 !state->EXT_geometry_shader_enable) { 1876 _mesa_glsl_error(& @3, state, 1877 "GL_ARB_gpu_shader5 invocations " 1878 "qualifier specified"); 1879 } 1880 } 1881 1882 /* Layout qualifiers for tessellation control shaders. */ 1883 if (match_layout_qualifier("vertices", $1, state) == 0) { 1884 $$.flags.q.vertices = 1; 1885 $$.vertices = new(ctx) ast_layout_expression(@1, $3); 1886 if (!state->has_tessellation_shader()) { 1887 _mesa_glsl_error(& @1, state, 1888 "vertices qualifier requires GLSL 4.00 or " 1889 "ARB_tessellation_shader"); 1890 } 1891 } 1892 1893 /* If the identifier didn't match any known layout identifiers, 1894 * emit an error. 1895 */ 1896 if (!$$.flags.i) { 1897 _mesa_glsl_error(& @1, state, "unrecognized layout identifier " 1898 "`%s'", $1); 1899 YYERROR; 1900 } 1901 } 1902 | interface_block_layout_qualifier 1903 { 1904 $$ = $1; 1905 /* Layout qualifiers for ARB_uniform_buffer_object. */ 1906 if ($$.flags.q.uniform && !state->has_uniform_buffer_objects()) { 1907 _mesa_glsl_error(& @1, state, 1908 "#version 140 / GL_ARB_uniform_buffer_object " 1909 "layout qualifier `uniform' is used"); 1910 } else if ($$.flags.q.uniform && state->ARB_uniform_buffer_object_warn) { 1911 _mesa_glsl_warning(& @1, state, 1912 "#version 140 / GL_ARB_uniform_buffer_object " 1913 "layout qualifier `uniform' is used"); 1914 } 1915 } 1916 ; 1917 1918/* This is a separate language rule because we parse these as tokens 1919 * (due to them being reserved keywords) instead of identifiers like 1920 * most qualifiers. See the any_identifier path of 1921 * layout_qualifier_id for the others. 1922 * 1923 * Note that since layout qualifiers are case-insensitive in desktop 1924 * GLSL, all of these qualifiers need to be handled as identifiers as 1925 * well (by the any_identifier path of layout_qualifier_id). 1926 */ 1927interface_block_layout_qualifier: 1928 ROW_MAJOR 1929 { 1930 memset(& $$, 0, sizeof($$)); 1931 $$.flags.q.row_major = 1; 1932 } 1933 | PACKED_TOK 1934 { 1935 memset(& $$, 0, sizeof($$)); 1936 $$.flags.q.packed = 1; 1937 } 1938 | SHARED 1939 { 1940 memset(& $$, 0, sizeof($$)); 1941 $$.flags.q.shared = 1; 1942 } 1943 ; 1944 1945subroutine_qualifier: 1946 SUBROUTINE 1947 { 1948 memset(& $$, 0, sizeof($$)); 1949 $$.flags.q.subroutine = 1; 1950 } 1951 | SUBROUTINE '(' subroutine_type_list ')' 1952 { 1953 memset(& $$, 0, sizeof($$)); 1954 $$.flags.q.subroutine = 1; 1955 $$.subroutine_list = $3; 1956 } 1957 ; 1958 1959subroutine_type_list: 1960 any_identifier 1961 { 1962 linear_ctx *ctx = state->linalloc; 1963 ast_declaration *decl = new(ctx) ast_declaration($1, NULL, NULL); 1964 decl->set_location(@1); 1965 1966 $$ = new(ctx) ast_subroutine_list(); 1967 $$->declarations.push_tail(&decl->link); 1968 } 1969 | subroutine_type_list ',' any_identifier 1970 { 1971 linear_ctx *ctx = state->linalloc; 1972 ast_declaration *decl = new(ctx) ast_declaration($3, NULL, NULL); 1973 decl->set_location(@3); 1974 1975 $$ = $1; 1976 $$->declarations.push_tail(&decl->link); 1977 } 1978 ; 1979 1980interpolation_qualifier: 1981 SMOOTH 1982 { 1983 memset(& $$, 0, sizeof($$)); 1984 $$.flags.q.smooth = 1; 1985 } 1986 | FLAT 1987 { 1988 memset(& $$, 0, sizeof($$)); 1989 $$.flags.q.flat = 1; 1990 } 1991 | NOPERSPECTIVE 1992 { 1993 memset(& $$, 0, sizeof($$)); 1994 $$.flags.q.noperspective = 1; 1995 } 1996 ; 1997 1998type_qualifier: 1999 /* Single qualifiers */ 2000 INVARIANT 2001 { 2002 memset(& $$, 0, sizeof($$)); 2003 $$.flags.q.invariant = 1; 2004 } 2005 | PRECISE 2006 { 2007 memset(& $$, 0, sizeof($$)); 2008 $$.flags.q.precise = 1; 2009 } 2010 | auxiliary_storage_qualifier 2011 | storage_qualifier 2012 | interpolation_qualifier 2013 | layout_qualifier 2014 | memory_qualifier 2015 | subroutine_qualifier 2016 | precision_qualifier 2017 { 2018 memset(&$$, 0, sizeof($$)); 2019 $$.precision = $1; 2020 } 2021 2022 /* Multiple qualifiers: 2023 * In GLSL 4.20, these can be specified in any order. In earlier versions, 2024 * they appear in this order (see GLSL 1.50 section 4.7 & comments below): 2025 * 2026 * invariant interpolation auxiliary storage precision ...or... 2027 * layout storage precision 2028 * 2029 * Each qualifier's rule ensures that the accumulated qualifiers on the right 2030 * side don't contain any that must appear on the left hand side. 2031 * For example, when processing a storage qualifier, we check that there are 2032 * no auxiliary, interpolation, layout, invariant, or precise qualifiers to the right. 2033 */ 2034 | PRECISE type_qualifier 2035 { 2036 if ($2.flags.q.precise) 2037 _mesa_glsl_error(&@1, state, "duplicate \"precise\" qualifier"); 2038 2039 $$ = $2; 2040 $$.flags.q.precise = 1; 2041 } 2042 | INVARIANT type_qualifier 2043 { 2044 if ($2.flags.q.invariant) 2045 _mesa_glsl_error(&@1, state, "duplicate \"invariant\" qualifier"); 2046 2047 if (!state->has_420pack_or_es31() && $2.flags.q.precise) 2048 _mesa_glsl_error(&@1, state, 2049 "\"invariant\" must come after \"precise\""); 2050 2051 $$ = $2; 2052 $$.flags.q.invariant = 1; 2053 2054 /* GLSL ES 3.00 spec, section 4.6.1 "The Invariant Qualifier": 2055 * 2056 * "Only variables output from a shader can be candidates for invariance. 2057 * This includes user-defined output variables and the built-in output 2058 * variables. As only outputs can be declared as invariant, an invariant 2059 * output from one shader stage will still match an input of a subsequent 2060 * stage without the input being declared as invariant." 2061 * 2062 * On the desktop side, this text first appears in GLSL 4.20. 2063 */ 2064 if (state->is_version(420, 300) && $$.flags.q.in) 2065 _mesa_glsl_error(&@1, state, "invariant qualifiers cannot be used with shader inputs"); 2066 } 2067 | interpolation_qualifier type_qualifier 2068 { 2069 /* Section 4.3 of the GLSL 1.40 specification states: 2070 * "...qualified with one of these interpolation qualifiers" 2071 * 2072 * GLSL 1.30 claims to allow "one or more", but insists that: 2073 * "These interpolation qualifiers may only precede the qualifiers in, 2074 * centroid in, out, or centroid out in a declaration." 2075 * 2076 * ...which means that e.g. smooth can't precede smooth, so there can be 2077 * only one after all, and the 1.40 text is a clarification, not a change. 2078 */ 2079 if ($2.has_interpolation()) 2080 _mesa_glsl_error(&@1, state, "duplicate interpolation qualifier"); 2081 2082 if (!state->has_420pack_or_es31() && 2083 ($2.flags.q.precise || $2.flags.q.invariant)) { 2084 _mesa_glsl_error(&@1, state, "interpolation qualifiers must come " 2085 "after \"precise\" or \"invariant\""); 2086 } 2087 2088 $$ = $1; 2089 $$.merge_qualifier(&@1, state, $2, false); 2090 } 2091 | layout_qualifier type_qualifier 2092 { 2093 /* In the absence of ARB_shading_language_420pack, layout qualifiers may 2094 * appear no later than auxiliary storage qualifiers. There is no 2095 * particularly clear spec language mandating this, but in all examples 2096 * the layout qualifier precedes the storage qualifier. 2097 * 2098 * We allow combinations of layout with interpolation, invariant or 2099 * precise qualifiers since these are useful in ARB_separate_shader_objects. 2100 * There is no clear spec guidance on this either. 2101 */ 2102 $$ = $1; 2103 $$.merge_qualifier(& @1, state, $2, false, $2.has_layout()); 2104 } 2105 | subroutine_qualifier type_qualifier 2106 { 2107 $$ = $1; 2108 $$.merge_qualifier(&@1, state, $2, false); 2109 } 2110 | auxiliary_storage_qualifier type_qualifier 2111 { 2112 if ($2.has_auxiliary_storage()) { 2113 _mesa_glsl_error(&@1, state, 2114 "duplicate auxiliary storage qualifier (centroid or sample)"); 2115 } 2116 2117 if ((!state->has_420pack_or_es31() && !state->EXT_gpu_shader4_enable) && 2118 ($2.flags.q.precise || $2.flags.q.invariant || 2119 $2.has_interpolation() || $2.has_layout())) { 2120 _mesa_glsl_error(&@1, state, "auxiliary storage qualifiers must come " 2121 "just before storage qualifiers"); 2122 } 2123 $$ = $1; 2124 $$.merge_qualifier(&@1, state, $2, false); 2125 } 2126 | storage_qualifier type_qualifier 2127 { 2128 /* Section 4.3 of the GLSL 1.20 specification states: 2129 * "Variable declarations may have a storage qualifier specified..." 2130 * 1.30 clarifies this to "may have one storage qualifier". 2131 * 2132 * GL_EXT_gpu_shader4 allows "varying out" in fragment shaders. 2133 */ 2134 if ($2.has_storage() && 2135 (!state->EXT_gpu_shader4_enable || 2136 state->stage != MESA_SHADER_FRAGMENT || 2137 !$1.flags.q.varying || !$2.flags.q.out)) 2138 _mesa_glsl_error(&@1, state, "duplicate storage qualifier"); 2139 2140 if (!state->has_420pack_or_es31() && 2141 ($2.flags.q.precise || $2.flags.q.invariant || $2.has_interpolation() || 2142 $2.has_layout() || $2.has_auxiliary_storage())) { 2143 _mesa_glsl_error(&@1, state, "storage qualifiers must come after " 2144 "precise, invariant, interpolation, layout and auxiliary " 2145 "storage qualifiers"); 2146 } 2147 2148 $$ = $1; 2149 $$.merge_qualifier(&@1, state, $2, false); 2150 } 2151 | precision_qualifier type_qualifier 2152 { 2153 if ($2.precision != ast_precision_none) 2154 _mesa_glsl_error(&@1, state, "duplicate precision qualifier"); 2155 2156 if (!(state->has_420pack_or_es31()) && 2157 $2.flags.i != 0) 2158 _mesa_glsl_error(&@1, state, "precision qualifiers must come last"); 2159 2160 $$ = $2; 2161 $$.precision = $1; 2162 } 2163 | memory_qualifier type_qualifier 2164 { 2165 $$ = $1; 2166 $$.merge_qualifier(&@1, state, $2, false); 2167 } 2168 ; 2169 2170auxiliary_storage_qualifier: 2171 CENTROID 2172 { 2173 memset(& $$, 0, sizeof($$)); 2174 $$.flags.q.centroid = 1; 2175 } 2176 | SAMPLE 2177 { 2178 memset(& $$, 0, sizeof($$)); 2179 $$.flags.q.sample = 1; 2180 } 2181 | PATCH 2182 { 2183 memset(& $$, 0, sizeof($$)); 2184 $$.flags.q.patch = 1; 2185 } 2186 2187storage_qualifier: 2188 CONST_TOK 2189 { 2190 memset(& $$, 0, sizeof($$)); 2191 $$.flags.q.constant = 1; 2192 } 2193 | ATTRIBUTE 2194 { 2195 memset(& $$, 0, sizeof($$)); 2196 $$.flags.q.attribute = 1; 2197 } 2198 | VARYING 2199 { 2200 memset(& $$, 0, sizeof($$)); 2201 $$.flags.q.varying = 1; 2202 } 2203 | IN_TOK 2204 { 2205 memset(& $$, 0, sizeof($$)); 2206 $$.flags.q.in = 1; 2207 } 2208 | OUT_TOK 2209 { 2210 memset(& $$, 0, sizeof($$)); 2211 $$.flags.q.out = 1; 2212 2213 if (state->stage == MESA_SHADER_GEOMETRY && 2214 state->has_explicit_attrib_stream()) { 2215 /* Section 4.3.8.2 (Output Layout Qualifiers) of the GLSL 4.00 2216 * spec says: 2217 * 2218 * "If the block or variable is declared with the stream 2219 * identifier, it is associated with the specified stream; 2220 * otherwise, it is associated with the current default stream." 2221 */ 2222 $$.flags.q.stream = 1; 2223 $$.flags.q.explicit_stream = 0; 2224 $$.stream = state->out_qualifier->stream; 2225 } 2226 2227 if (state->has_enhanced_layouts() && state->exts->ARB_transform_feedback3) { 2228 $$.flags.q.xfb_buffer = 1; 2229 $$.flags.q.explicit_xfb_buffer = 0; 2230 $$.xfb_buffer = state->out_qualifier->xfb_buffer; 2231 } 2232 } 2233 | INOUT_TOK 2234 { 2235 memset(& $$, 0, sizeof($$)); 2236 $$.flags.q.in = 1; 2237 $$.flags.q.out = 1; 2238 2239 if (!state->has_framebuffer_fetch() || 2240 !state->is_version(130, 300) || 2241 state->stage != MESA_SHADER_FRAGMENT) 2242 _mesa_glsl_error(&@1, state, "A single interface variable cannot be " 2243 "declared as both input and output"); 2244 } 2245 | UNIFORM 2246 { 2247 memset(& $$, 0, sizeof($$)); 2248 $$.flags.q.uniform = 1; 2249 } 2250 | BUFFER 2251 { 2252 memset(& $$, 0, sizeof($$)); 2253 $$.flags.q.buffer = 1; 2254 } 2255 | SHARED 2256 { 2257 memset(& $$, 0, sizeof($$)); 2258 $$.flags.q.shared_storage = 1; 2259 } 2260 ; 2261 2262memory_qualifier: 2263 COHERENT 2264 { 2265 memset(& $$, 0, sizeof($$)); 2266 $$.flags.q.coherent = 1; 2267 } 2268 | VOLATILE 2269 { 2270 memset(& $$, 0, sizeof($$)); 2271 $$.flags.q._volatile = 1; 2272 } 2273 | RESTRICT 2274 { 2275 STATIC_ASSERT(sizeof($$.flags.q) <= sizeof($$.flags.i)); 2276 memset(& $$, 0, sizeof($$)); 2277 $$.flags.q.restrict_flag = 1; 2278 } 2279 | READONLY 2280 { 2281 memset(& $$, 0, sizeof($$)); 2282 $$.flags.q.read_only = 1; 2283 } 2284 | WRITEONLY 2285 { 2286 memset(& $$, 0, sizeof($$)); 2287 $$.flags.q.write_only = 1; 2288 } 2289 ; 2290 2291array_specifier: 2292 '[' ']' 2293 { 2294 linear_ctx *ctx = state->linalloc; 2295 $$ = new(ctx) ast_array_specifier(@1, new(ctx) ast_expression( 2296 ast_unsized_array_dim, NULL, 2297 NULL, NULL)); 2298 $$->set_location_range(@1, @2); 2299 } 2300 | '[' constant_expression ']' 2301 { 2302 linear_ctx *ctx = state->linalloc; 2303 $$ = new(ctx) ast_array_specifier(@1, $2); 2304 $$->set_location_range(@1, @3); 2305 } 2306 | array_specifier '[' ']' 2307 { 2308 linear_ctx *ctx = state->linalloc; 2309 $$ = $1; 2310 2311 if (state->check_arrays_of_arrays_allowed(& @1)) { 2312 $$->add_dimension(new(ctx) ast_expression(ast_unsized_array_dim, NULL, 2313 NULL, NULL)); 2314 } 2315 } 2316 | array_specifier '[' constant_expression ']' 2317 { 2318 $$ = $1; 2319 2320 if (state->check_arrays_of_arrays_allowed(& @1)) { 2321 $$->add_dimension($3); 2322 } 2323 } 2324 ; 2325 2326type_specifier: 2327 type_specifier_nonarray 2328 | type_specifier_nonarray array_specifier 2329 { 2330 $$ = $1; 2331 $$->array_specifier = $2; 2332 } 2333 ; 2334 2335type_specifier_nonarray: 2336 basic_type_specifier_nonarray 2337 { 2338 linear_ctx *ctx = state->linalloc; 2339 $$ = new(ctx) ast_type_specifier($1); 2340 $$->set_location(@1); 2341 } 2342 | struct_specifier 2343 { 2344 linear_ctx *ctx = state->linalloc; 2345 $$ = new(ctx) ast_type_specifier($1); 2346 $$->set_location(@1); 2347 } 2348 | TYPE_IDENTIFIER 2349 { 2350 linear_ctx *ctx = state->linalloc; 2351 $$ = new(ctx) ast_type_specifier($1); 2352 $$->set_location(@1); 2353 } 2354 ; 2355 2356basic_type_specifier_nonarray: 2357 VOID_TOK { $$ = &glsl_type_builtin_void; } 2358 | BASIC_TYPE_TOK { $$ = $1; } 2359 | UNSIGNED BASIC_TYPE_TOK 2360 { 2361 if ($2 == &glsl_type_builtin_int) { 2362 $$ = &glsl_type_builtin_uint; 2363 } else { 2364 _mesa_glsl_error(&@1, state, 2365 "\"unsigned\" is only allowed before \"int\""); 2366 } 2367 } 2368 ; 2369 2370precision_qualifier: 2371 HIGHP 2372 { 2373 state->check_precision_qualifiers_allowed(&@1); 2374 $$ = ast_precision_high; 2375 } 2376 | MEDIUMP 2377 { 2378 state->check_precision_qualifiers_allowed(&@1); 2379 $$ = ast_precision_medium; 2380 } 2381 | LOWP 2382 { 2383 state->check_precision_qualifiers_allowed(&@1); 2384 $$ = ast_precision_low; 2385 } 2386 ; 2387 2388struct_specifier: 2389 STRUCT any_identifier '{' struct_declaration_list '}' 2390 { 2391 linear_ctx *ctx = state->linalloc; 2392 $$ = new(ctx) ast_struct_specifier($2, $4); 2393 $$->set_location_range(@2, @5); 2394 state->symbols->add_type($2, &glsl_type_builtin_void); 2395 } 2396 | STRUCT '{' struct_declaration_list '}' 2397 { 2398 linear_ctx *ctx = state->linalloc; 2399 2400 /* All anonymous structs have the same name. This simplifies matching of 2401 * globals whose type is an unnamed struct. 2402 * 2403 * It also avoids a memory leak when the same shader is compiled over and 2404 * over again. 2405 */ 2406 $$ = new(ctx) ast_struct_specifier("#anon_struct", $3); 2407 2408 $$->set_location_range(@2, @4); 2409 } 2410 ; 2411 2412struct_declaration_list: 2413 struct_declaration 2414 { 2415 $$ = $1; 2416 $1->link.self_link(); 2417 } 2418 | struct_declaration_list struct_declaration 2419 { 2420 $$ = $1; 2421 $$->link.insert_before(& $2->link); 2422 } 2423 ; 2424 2425struct_declaration: 2426 fully_specified_type struct_declarator_list ';' 2427 { 2428 linear_ctx *ctx = state->linalloc; 2429 ast_fully_specified_type *const type = $1; 2430 type->set_location(@1); 2431 2432 if (state->has_bindless()) { 2433 ast_type_qualifier input_layout_mask; 2434 2435 /* Allow to declare qualifiers for images. */ 2436 input_layout_mask.flags.i = 0; 2437 input_layout_mask.flags.q.coherent = 1; 2438 input_layout_mask.flags.q._volatile = 1; 2439 input_layout_mask.flags.q.restrict_flag = 1; 2440 input_layout_mask.flags.q.read_only = 1; 2441 input_layout_mask.flags.q.write_only = 1; 2442 input_layout_mask.flags.q.explicit_image_format = 1; 2443 2444 if ((type->qualifier.flags.i & ~input_layout_mask.flags.i) != 0) { 2445 _mesa_glsl_error(&@1, state, 2446 "only precision and image qualifiers may be " 2447 "applied to structure members"); 2448 } 2449 } else { 2450 if (type->qualifier.flags.i != 0) 2451 _mesa_glsl_error(&@1, state, 2452 "only precision qualifiers may be applied to " 2453 "structure members"); 2454 } 2455 2456 $$ = new(ctx) ast_declarator_list(type); 2457 $$->set_location(@2); 2458 2459 $$->declarations.push_degenerate_list_at_head(& $2->link); 2460 } 2461 ; 2462 2463struct_declarator_list: 2464 struct_declarator 2465 { 2466 $$ = $1; 2467 $1->link.self_link(); 2468 } 2469 | struct_declarator_list ',' struct_declarator 2470 { 2471 $$ = $1; 2472 $$->link.insert_before(& $3->link); 2473 } 2474 ; 2475 2476struct_declarator: 2477 any_identifier 2478 { 2479 linear_ctx *ctx = state->linalloc; 2480 $$ = new(ctx) ast_declaration($1, NULL, NULL); 2481 $$->set_location(@1); 2482 } 2483 | any_identifier array_specifier 2484 { 2485 linear_ctx *ctx = state->linalloc; 2486 $$ = new(ctx) ast_declaration($1, $2, NULL); 2487 $$->set_location_range(@1, @2); 2488 } 2489 ; 2490 2491initializer: 2492 assignment_expression 2493 | '{' initializer_list '}' 2494 { 2495 $$ = $2; 2496 } 2497 | '{' initializer_list ',' '}' 2498 { 2499 $$ = $2; 2500 } 2501 ; 2502 2503initializer_list: 2504 initializer 2505 { 2506 linear_ctx *ctx = state->linalloc; 2507 $$ = new(ctx) ast_aggregate_initializer(); 2508 $$->set_location(@1); 2509 $$->expressions.push_tail(& $1->link); 2510 } 2511 | initializer_list ',' initializer 2512 { 2513 $1->expressions.push_tail(& $3->link); 2514 } 2515 ; 2516 2517declaration_statement: 2518 declaration 2519 ; 2520 2521 // Grammar Note: labeled statements for SWITCH only; 'goto' is not 2522 // supported. 2523statement: 2524 compound_statement { $$ = (ast_node *) $1; } 2525 | simple_statement 2526 ; 2527 2528simple_statement: 2529 declaration_statement 2530 | expression_statement 2531 | selection_statement 2532 | switch_statement 2533 | iteration_statement 2534 | jump_statement 2535 | demote_statement 2536 ; 2537 2538compound_statement: 2539 '{' '}' 2540 { 2541 linear_ctx *ctx = state->linalloc; 2542 $$ = new(ctx) ast_compound_statement(true, NULL); 2543 $$->set_location_range(@1, @2); 2544 } 2545 | '{' 2546 { 2547 state->symbols->push_scope(); 2548 } 2549 statement_list '}' 2550 { 2551 linear_ctx *ctx = state->linalloc; 2552 $$ = new(ctx) ast_compound_statement(true, $3); 2553 $$->set_location_range(@1, @4); 2554 state->symbols->pop_scope(); 2555 } 2556 ; 2557 2558statement_no_new_scope: 2559 compound_statement_no_new_scope { $$ = (ast_node *) $1; } 2560 | simple_statement 2561 ; 2562 2563compound_statement_no_new_scope: 2564 '{' '}' 2565 { 2566 linear_ctx *ctx = state->linalloc; 2567 $$ = new(ctx) ast_compound_statement(false, NULL); 2568 $$->set_location_range(@1, @2); 2569 } 2570 | '{' statement_list '}' 2571 { 2572 linear_ctx *ctx = state->linalloc; 2573 $$ = new(ctx) ast_compound_statement(false, $2); 2574 $$->set_location_range(@1, @3); 2575 } 2576 ; 2577 2578statement_list: 2579 statement 2580 { 2581 if ($1 == NULL) { 2582 _mesa_glsl_error(& @1, state, "<nil> statement"); 2583 assert($1 != NULL); 2584 } 2585 2586 $$ = $1; 2587 $$->link.self_link(); 2588 } 2589 | statement_list statement 2590 { 2591 if ($2 == NULL) { 2592 _mesa_glsl_error(& @2, state, "<nil> statement"); 2593 assert($2 != NULL); 2594 } 2595 $$ = $1; 2596 $$->link.insert_before(& $2->link); 2597 } 2598 | statement_list extension_statement 2599 { 2600 if (!state->allow_extension_directive_midshader) { 2601 _mesa_glsl_error(& @1, state, 2602 "#extension directive is not allowed " 2603 "in the middle of a shader"); 2604 YYERROR; 2605 } 2606 } 2607 ; 2608 2609expression_statement: 2610 ';' 2611 { 2612 linear_ctx *ctx = state->linalloc; 2613 $$ = new(ctx) ast_expression_statement(NULL); 2614 $$->set_location(@1); 2615 } 2616 | expression ';' 2617 { 2618 linear_ctx *ctx = state->linalloc; 2619 $$ = new(ctx) ast_expression_statement($1); 2620 $$->set_location(@1); 2621 } 2622 ; 2623 2624selection_statement: 2625 IF '(' expression ')' selection_rest_statement 2626 { 2627 $$ = new(state->linalloc) ast_selection_statement($3, $5.then_statement, 2628 $5.else_statement); 2629 $$->set_location_range(@1, @5); 2630 } 2631 ; 2632 2633selection_rest_statement: 2634 statement ELSE statement 2635 { 2636 $$.then_statement = $1; 2637 $$.else_statement = $3; 2638 } 2639 | statement %prec THEN 2640 { 2641 $$.then_statement = $1; 2642 $$.else_statement = NULL; 2643 } 2644 ; 2645 2646condition: 2647 expression 2648 { 2649 $$ = (ast_node *) $1; 2650 } 2651 | fully_specified_type any_identifier '=' initializer 2652 { 2653 linear_ctx *ctx = state->linalloc; 2654 ast_declaration *decl = new(ctx) ast_declaration($2, NULL, $4); 2655 ast_declarator_list *declarator = new(ctx) ast_declarator_list($1); 2656 decl->set_location_range(@2, @4); 2657 declarator->set_location(@1); 2658 2659 declarator->declarations.push_tail(&decl->link); 2660 $$ = declarator; 2661 } 2662 ; 2663 2664/* 2665 * switch_statement grammar is based on the syntax described in the body 2666 * of the GLSL spec, not in it's appendix!!! 2667 */ 2668switch_statement: 2669 SWITCH '(' expression ')' switch_body 2670 { 2671 $$ = new(state->linalloc) ast_switch_statement($3, $5); 2672 $$->set_location_range(@1, @5); 2673 } 2674 ; 2675 2676switch_body: 2677 '{' '}' 2678 { 2679 $$ = new(state->linalloc) ast_switch_body(NULL); 2680 $$->set_location_range(@1, @2); 2681 } 2682 | '{' case_statement_list '}' 2683 { 2684 $$ = new(state->linalloc) ast_switch_body($2); 2685 $$->set_location_range(@1, @3); 2686 } 2687 ; 2688 2689case_label: 2690 CASE expression ':' 2691 { 2692 $$ = new(state->linalloc) ast_case_label($2); 2693 $$->set_location(@2); 2694 } 2695 | DEFAULT ':' 2696 { 2697 $$ = new(state->linalloc) ast_case_label(NULL); 2698 $$->set_location(@2); 2699 } 2700 ; 2701 2702case_label_list: 2703 case_label 2704 { 2705 ast_case_label_list *labels = new(state->linalloc) ast_case_label_list(); 2706 2707 labels->labels.push_tail(& $1->link); 2708 $$ = labels; 2709 $$->set_location(@1); 2710 } 2711 | case_label_list case_label 2712 { 2713 $$ = $1; 2714 $$->labels.push_tail(& $2->link); 2715 } 2716 ; 2717 2718case_statement: 2719 case_label_list statement 2720 { 2721 ast_case_statement *stmts = new(state->linalloc) ast_case_statement($1); 2722 stmts->set_location(@2); 2723 2724 stmts->stmts.push_tail(& $2->link); 2725 $$ = stmts; 2726 } 2727 | case_statement statement 2728 { 2729 $$ = $1; 2730 $$->stmts.push_tail(& $2->link); 2731 } 2732 ; 2733 2734case_statement_list: 2735 case_statement 2736 { 2737 ast_case_statement_list *cases= new(state->linalloc) ast_case_statement_list(); 2738 cases->set_location(@1); 2739 2740 cases->cases.push_tail(& $1->link); 2741 $$ = cases; 2742 } 2743 | case_statement_list case_statement 2744 { 2745 $$ = $1; 2746 $$->cases.push_tail(& $2->link); 2747 } 2748 ; 2749 2750iteration_statement: 2751 WHILE '(' condition ')' statement_no_new_scope 2752 { 2753 linear_ctx *ctx = state->linalloc; 2754 $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_while, 2755 NULL, $3, NULL, $5); 2756 $$->set_location_range(@1, @4); 2757 } 2758 | DO statement_no_new_scope WHILE '(' expression ')' ';' 2759 { 2760 linear_ctx *ctx = state->linalloc; 2761 $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_do_while, 2762 NULL, $5, NULL, $2); 2763 $$->set_location_range(@1, @6); 2764 } 2765 | FOR '(' for_init_statement for_rest_statement ')' statement_no_new_scope 2766 { 2767 linear_ctx *ctx = state->linalloc; 2768 $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_for, 2769 $3, $4.cond, $4.rest, $6); 2770 $$->set_location_range(@1, @6); 2771 } 2772 ; 2773 2774for_init_statement: 2775 expression_statement 2776 | declaration_statement 2777 ; 2778 2779conditionopt: 2780 condition 2781 | /* empty */ 2782 { 2783 $$ = NULL; 2784 } 2785 ; 2786 2787for_rest_statement: 2788 conditionopt ';' 2789 { 2790 $$.cond = $1; 2791 $$.rest = NULL; 2792 } 2793 | conditionopt ';' expression 2794 { 2795 $$.cond = $1; 2796 $$.rest = $3; 2797 } 2798 ; 2799 2800 // Grammar Note: No 'goto'. Gotos are not supported. 2801jump_statement: 2802 CONTINUE ';' 2803 { 2804 linear_ctx *ctx = state->linalloc; 2805 $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_continue, NULL); 2806 $$->set_location(@1); 2807 } 2808 | BREAK ';' 2809 { 2810 linear_ctx *ctx = state->linalloc; 2811 $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_break, NULL); 2812 $$->set_location(@1); 2813 } 2814 | RETURN ';' 2815 { 2816 linear_ctx *ctx = state->linalloc; 2817 $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, NULL); 2818 $$->set_location(@1); 2819 } 2820 | RETURN expression ';' 2821 { 2822 linear_ctx *ctx = state->linalloc; 2823 $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, $2); 2824 $$->set_location_range(@1, @2); 2825 } 2826 | DISCARD ';' // Fragment shader only. 2827 { 2828 linear_ctx *ctx = state->linalloc; 2829 $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_discard, NULL); 2830 $$->set_location(@1); 2831 } 2832 ; 2833 2834demote_statement: 2835 DEMOTE ';' 2836 { 2837 linear_ctx *ctx = state->linalloc; 2838 $$ = new(ctx) ast_demote_statement(); 2839 $$->set_location(@1); 2840 } 2841 ; 2842 2843external_declaration: 2844 function_definition { $$ = $1; } 2845 | declaration { $$ = $1; } 2846 | pragma_statement { $$ = $1; } 2847 | layout_defaults { $$ = $1; } 2848 | ';' { $$ = NULL; } 2849 ; 2850 2851function_definition: 2852 function_prototype compound_statement_no_new_scope 2853 { 2854 linear_ctx *ctx = state->linalloc; 2855 $$ = new(ctx) ast_function_definition(); 2856 $$->set_location_range(@1, @2); 2857 $$->prototype = $1; 2858 $$->body = $2; 2859 2860 state->symbols->pop_scope(); 2861 } 2862 ; 2863 2864/* layout_qualifieropt is packed into this rule */ 2865interface_block: 2866 basic_interface_block 2867 { 2868 $$ = $1; 2869 } 2870 | layout_qualifier interface_block 2871 { 2872 ast_interface_block *block = (ast_interface_block *) $2; 2873 2874 if (!$1.merge_qualifier(& @1, state, block->layout, false, 2875 block->layout.has_layout())) { 2876 YYERROR; 2877 } 2878 2879 block->layout = $1; 2880 2881 $$ = block; 2882 } 2883 | memory_qualifier interface_block 2884 { 2885 ast_interface_block *block = (ast_interface_block *)$2; 2886 2887 if (!block->default_layout.flags.q.buffer) { 2888 _mesa_glsl_error(& @1, state, 2889 "memory qualifiers can only be used in the " 2890 "declaration of shader storage blocks"); 2891 } 2892 if (!$1.merge_qualifier(& @1, state, block->layout, false)) { 2893 YYERROR; 2894 } 2895 block->layout = $1; 2896 $$ = block; 2897 } 2898 ; 2899 2900basic_interface_block: 2901 interface_qualifier NEW_IDENTIFIER '{' member_list '}' instance_name_opt ';' 2902 { 2903 ast_interface_block *const block = $6; 2904 2905 if ($1.flags.q.uniform) { 2906 block->default_layout = *state->default_uniform_qualifier; 2907 } else if ($1.flags.q.buffer) { 2908 block->default_layout = *state->default_shader_storage_qualifier; 2909 } 2910 block->block_name = $2; 2911 block->declarations.push_degenerate_list_at_head(& $4->link); 2912 2913 _mesa_ast_process_interface_block(& @1, state, block, $1); 2914 2915 $$ = block; 2916 } 2917 ; 2918 2919interface_qualifier: 2920 IN_TOK 2921 { 2922 memset(& $$, 0, sizeof($$)); 2923 $$.flags.q.in = 1; 2924 } 2925 | OUT_TOK 2926 { 2927 memset(& $$, 0, sizeof($$)); 2928 $$.flags.q.out = 1; 2929 } 2930 | UNIFORM 2931 { 2932 memset(& $$, 0, sizeof($$)); 2933 $$.flags.q.uniform = 1; 2934 } 2935 | BUFFER 2936 { 2937 memset(& $$, 0, sizeof($$)); 2938 $$.flags.q.buffer = 1; 2939 } 2940 | auxiliary_storage_qualifier interface_qualifier 2941 { 2942 if (!$1.flags.q.patch) { 2943 _mesa_glsl_error(&@1, state, "invalid interface qualifier"); 2944 } 2945 if ($2.has_auxiliary_storage()) { 2946 _mesa_glsl_error(&@1, state, "duplicate patch qualifier"); 2947 } 2948 $$ = $2; 2949 $$.flags.q.patch = 1; 2950 } 2951 ; 2952 2953instance_name_opt: 2954 /* empty */ 2955 { 2956 $$ = new(state->linalloc) ast_interface_block(NULL, NULL); 2957 } 2958 | NEW_IDENTIFIER 2959 { 2960 $$ = new(state->linalloc) ast_interface_block($1, NULL); 2961 $$->set_location(@1); 2962 } 2963 | NEW_IDENTIFIER array_specifier 2964 { 2965 $$ = new(state->linalloc) ast_interface_block($1, $2); 2966 $$->set_location_range(@1, @2); 2967 } 2968 ; 2969 2970member_list: 2971 member_declaration 2972 { 2973 $$ = $1; 2974 $1->link.self_link(); 2975 } 2976 | member_declaration member_list 2977 { 2978 $$ = $1; 2979 $2->link.insert_before(& $$->link); 2980 } 2981 ; 2982 2983member_declaration: 2984 fully_specified_type struct_declarator_list ';' 2985 { 2986 linear_ctx *ctx = state->linalloc; 2987 ast_fully_specified_type *type = $1; 2988 type->set_location(@1); 2989 2990 if (type->qualifier.flags.q.attribute) { 2991 _mesa_glsl_error(& @1, state, 2992 "keyword 'attribute' cannot be used with " 2993 "interface block member"); 2994 } else if (type->qualifier.flags.q.varying) { 2995 _mesa_glsl_error(& @1, state, 2996 "keyword 'varying' cannot be used with " 2997 "interface block member"); 2998 } 2999 3000 $$ = new(ctx) ast_declarator_list(type); 3001 $$->set_location(@2); 3002 3003 $$->declarations.push_degenerate_list_at_head(& $2->link); 3004 } 3005 ; 3006 3007layout_uniform_defaults: 3008 layout_qualifier layout_uniform_defaults 3009 { 3010 $$ = $1; 3011 if (!$$.merge_qualifier(& @1, state, $2, false, true)) { 3012 YYERROR; 3013 } 3014 } 3015 | layout_qualifier UNIFORM ';' 3016 ; 3017 3018layout_buffer_defaults: 3019 layout_qualifier layout_buffer_defaults 3020 { 3021 $$ = $1; 3022 if (!$$.merge_qualifier(& @1, state, $2, false, true)) { 3023 YYERROR; 3024 } 3025 } 3026 | layout_qualifier BUFFER ';' 3027 ; 3028 3029layout_in_defaults: 3030 layout_qualifier layout_in_defaults 3031 { 3032 $$ = $1; 3033 if (!$$.merge_qualifier(& @1, state, $2, false, true)) { 3034 YYERROR; 3035 } 3036 if (!$$.validate_in_qualifier(& @1, state)) { 3037 YYERROR; 3038 } 3039 } 3040 | layout_qualifier IN_TOK ';' 3041 { 3042 if (!$1.validate_in_qualifier(& @1, state)) { 3043 YYERROR; 3044 } 3045 } 3046 ; 3047 3048layout_out_defaults: 3049 layout_qualifier layout_out_defaults 3050 { 3051 $$ = $1; 3052 if (!$$.merge_qualifier(& @1, state, $2, false, true)) { 3053 YYERROR; 3054 } 3055 if (!$$.validate_out_qualifier(& @1, state)) { 3056 YYERROR; 3057 } 3058 } 3059 | layout_qualifier OUT_TOK ';' 3060 { 3061 if (!$1.validate_out_qualifier(& @1, state)) { 3062 YYERROR; 3063 } 3064 } 3065 ; 3066 3067layout_defaults: 3068 layout_uniform_defaults 3069 { 3070 $$ = NULL; 3071 if (!state->default_uniform_qualifier-> 3072 merge_qualifier(& @1, state, $1, false)) { 3073 YYERROR; 3074 } 3075 if (!state->default_uniform_qualifier-> 3076 push_to_global(& @1, state)) { 3077 YYERROR; 3078 } 3079 } 3080 | layout_buffer_defaults 3081 { 3082 $$ = NULL; 3083 if (!state->default_shader_storage_qualifier-> 3084 merge_qualifier(& @1, state, $1, false)) { 3085 YYERROR; 3086 } 3087 if (!state->default_shader_storage_qualifier-> 3088 push_to_global(& @1, state)) { 3089 YYERROR; 3090 } 3091 3092 /* From the GLSL 4.50 spec, section 4.4.5: 3093 * 3094 * "It is a compile-time error to specify the binding identifier for 3095 * the global scope or for block member declarations." 3096 */ 3097 if (state->default_shader_storage_qualifier->flags.q.explicit_binding) { 3098 _mesa_glsl_error(& @1, state, 3099 "binding qualifier cannot be set for default layout"); 3100 } 3101 } 3102 | layout_in_defaults 3103 { 3104 $$ = NULL; 3105 if (!$1.merge_into_in_qualifier(& @1, state, $$)) { 3106 YYERROR; 3107 } 3108 if (!state->in_qualifier->push_to_global(& @1, state)) { 3109 YYERROR; 3110 } 3111 } 3112 | layout_out_defaults 3113 { 3114 $$ = NULL; 3115 if (!$1.merge_into_out_qualifier(& @1, state, $$)) { 3116 YYERROR; 3117 } 3118 if (!state->out_qualifier->push_to_global(& @1, state)) { 3119 YYERROR; 3120 } 3121 3122 (void)yynerrs; 3123 } 3124 ; 3125