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#include <assert.h> 28 29#include "ast.h" 30#include "glsl_parser_extras.h" 31#include "glsl_types.h" 32#include "main/context.h" 33 34#define YYLEX_PARAM state->scanner 35 36#undef yyerror 37 38static void yyerror(YYLTYPE *loc, _mesa_glsl_parse_state *st, const char *msg) 39{ 40 _mesa_glsl_error(loc, st, "%s", msg); 41} 42%} 43 44%pure-parser 45%error-verbose 46 47%locations 48%initial-action { 49 @$.first_line = 1; 50 @$.first_column = 1; 51 @$.last_line = 1; 52 @$.last_column = 1; 53 @$.source = 0; 54} 55 56%lex-param {void *scanner} 57%parse-param {struct _mesa_glsl_parse_state *state} 58 59%union { 60 int n; 61 float real; 62 const char *identifier; 63 64 struct ast_type_qualifier type_qualifier; 65 66 ast_node *node; 67 ast_type_specifier *type_specifier; 68 ast_fully_specified_type *fully_specified_type; 69 ast_function *function; 70 ast_parameter_declarator *parameter_declarator; 71 ast_function_definition *function_definition; 72 ast_compound_statement *compound_statement; 73 ast_expression *expression; 74 ast_declarator_list *declarator_list; 75 ast_struct_specifier *struct_specifier; 76 ast_declaration *declaration; 77 ast_switch_body *switch_body; 78 ast_case_label *case_label; 79 ast_case_label_list *case_label_list; 80 ast_case_statement *case_statement; 81 ast_case_statement_list *case_statement_list; 82 83 struct { 84 ast_node *cond; 85 ast_expression *rest; 86 } for_rest_statement; 87 88 struct { 89 ast_node *then_statement; 90 ast_node *else_statement; 91 } selection_rest_statement; 92} 93 94%token ATTRIBUTE CONST_TOK BOOL_TOK FLOAT_TOK INT_TOK UINT_TOK 95%token BREAK CONTINUE DO ELSE FOR IF DISCARD RETURN SWITCH CASE DEFAULT 96%token BVEC2 BVEC3 BVEC4 IVEC2 IVEC3 IVEC4 UVEC2 UVEC3 UVEC4 VEC2 VEC3 VEC4 97%token CENTROID IN_TOK OUT_TOK INOUT_TOK UNIFORM VARYING 98%token NOPERSPECTIVE FLAT SMOOTH 99%token MAT2X2 MAT2X3 MAT2X4 100%token MAT3X2 MAT3X3 MAT3X4 101%token MAT4X2 MAT4X3 MAT4X4 102%token SAMPLER1D SAMPLER2D SAMPLER3D SAMPLERCUBE SAMPLER1DSHADOW SAMPLER2DSHADOW 103%token SAMPLERCUBESHADOW SAMPLER1DARRAY SAMPLER2DARRAY SAMPLER1DARRAYSHADOW 104%token SAMPLER2DARRAYSHADOW ISAMPLER1D ISAMPLER2D ISAMPLER3D ISAMPLERCUBE 105%token ISAMPLER1DARRAY ISAMPLER2DARRAY USAMPLER1D USAMPLER2D USAMPLER3D 106%token USAMPLERCUBE USAMPLER1DARRAY USAMPLER2DARRAY 107%token SAMPLER2DRECT ISAMPLER2DRECT USAMPLER2DRECT SAMPLER2DRECTSHADOW 108%token SAMPLERBUFFER ISAMPLERBUFFER USAMPLERBUFFER 109%token SAMPLEREXTERNALOES 110%token STRUCT VOID_TOK WHILE 111%token <identifier> IDENTIFIER TYPE_IDENTIFIER NEW_IDENTIFIER 112%type <identifier> any_identifier 113%token <real> FLOATCONSTANT 114%token <n> INTCONSTANT UINTCONSTANT BOOLCONSTANT 115%token <identifier> FIELD_SELECTION 116%token LEFT_OP RIGHT_OP 117%token INC_OP DEC_OP LE_OP GE_OP EQ_OP NE_OP 118%token AND_OP OR_OP XOR_OP MUL_ASSIGN DIV_ASSIGN ADD_ASSIGN 119%token MOD_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN XOR_ASSIGN OR_ASSIGN 120%token SUB_ASSIGN 121%token INVARIANT 122%token LOWP MEDIUMP HIGHP SUPERP PRECISION 123 124%token VERSION_TOK EXTENSION LINE COLON EOL INTERFACE OUTPUT 125%token PRAGMA_DEBUG_ON PRAGMA_DEBUG_OFF 126%token PRAGMA_OPTIMIZE_ON PRAGMA_OPTIMIZE_OFF 127%token PRAGMA_INVARIANT_ALL 128%token LAYOUT_TOK 129 130 /* Reserved words that are not actually used in the grammar. 131 */ 132%token ASM CLASS UNION ENUM TYPEDEF TEMPLATE THIS PACKED_TOK GOTO 133%token INLINE_TOK NOINLINE VOLATILE PUBLIC_TOK STATIC EXTERN EXTERNAL 134%token LONG_TOK SHORT_TOK DOUBLE_TOK HALF FIXED_TOK UNSIGNED INPUT_TOK OUPTUT 135%token HVEC2 HVEC3 HVEC4 DVEC2 DVEC3 DVEC4 FVEC2 FVEC3 FVEC4 136%token SAMPLER3DRECT 137%token SIZEOF CAST NAMESPACE USING 138 139%token ERROR_TOK 140 141%token COMMON PARTITION ACTIVE FILTER 142%token IMAGE1D IMAGE2D IMAGE3D IMAGECUBE IMAGE1DARRAY IMAGE2DARRAY 143%token IIMAGE1D IIMAGE2D IIMAGE3D IIMAGECUBE IIMAGE1DARRAY IIMAGE2DARRAY 144%token UIMAGE1D UIMAGE2D UIMAGE3D UIMAGECUBE UIMAGE1DARRAY UIMAGE2DARRAY 145%token IMAGE1DSHADOW IMAGE2DSHADOW IMAGEBUFFER IIMAGEBUFFER UIMAGEBUFFER 146%token IMAGE1DARRAYSHADOW IMAGE2DARRAYSHADOW 147%token ROW_MAJOR 148 149%type <identifier> variable_identifier 150%type <node> statement 151%type <node> statement_list 152%type <node> simple_statement 153%type <n> precision_qualifier 154%type <type_qualifier> type_qualifier 155%type <type_qualifier> storage_qualifier 156%type <type_qualifier> interpolation_qualifier 157%type <type_qualifier> layout_qualifier 158%type <type_qualifier> layout_qualifier_id_list layout_qualifier_id 159%type <type_qualifier> uniform_block_layout_qualifier 160%type <type_specifier> type_specifier 161%type <type_specifier> type_specifier_no_prec 162%type <type_specifier> type_specifier_nonarray 163%type <identifier> basic_type_specifier_nonarray 164%type <fully_specified_type> fully_specified_type 165%type <function> function_prototype 166%type <function> function_header 167%type <function> function_header_with_parameters 168%type <function> function_declarator 169%type <parameter_declarator> parameter_declarator 170%type <parameter_declarator> parameter_declaration 171%type <type_qualifier> parameter_qualifier 172%type <type_qualifier> parameter_type_qualifier 173%type <type_specifier> parameter_type_specifier 174%type <function_definition> function_definition 175%type <compound_statement> compound_statement_no_new_scope 176%type <compound_statement> compound_statement 177%type <node> statement_no_new_scope 178%type <node> expression_statement 179%type <expression> expression 180%type <expression> primary_expression 181%type <expression> assignment_expression 182%type <expression> conditional_expression 183%type <expression> logical_or_expression 184%type <expression> logical_xor_expression 185%type <expression> logical_and_expression 186%type <expression> inclusive_or_expression 187%type <expression> exclusive_or_expression 188%type <expression> and_expression 189%type <expression> equality_expression 190%type <expression> relational_expression 191%type <expression> shift_expression 192%type <expression> additive_expression 193%type <expression> multiplicative_expression 194%type <expression> unary_expression 195%type <expression> constant_expression 196%type <expression> integer_expression 197%type <expression> postfix_expression 198%type <expression> function_call_header_with_parameters 199%type <expression> function_call_header_no_parameters 200%type <expression> function_call_header 201%type <expression> function_call_generic 202%type <expression> function_call_or_method 203%type <expression> function_call 204%type <expression> method_call_generic 205%type <expression> method_call_header_with_parameters 206%type <expression> method_call_header_no_parameters 207%type <expression> method_call_header 208%type <n> assignment_operator 209%type <n> unary_operator 210%type <expression> function_identifier 211%type <node> external_declaration 212%type <declarator_list> init_declarator_list 213%type <declarator_list> single_declaration 214%type <expression> initializer 215%type <node> declaration 216%type <node> declaration_statement 217%type <node> jump_statement 218%type <node> uniform_block 219%type <struct_specifier> struct_specifier 220%type <declarator_list> struct_declaration_list 221%type <declarator_list> struct_declaration 222%type <declaration> struct_declarator 223%type <declaration> struct_declarator_list 224%type <declarator_list> member_list 225%type <declarator_list> member_declaration 226%type <node> selection_statement 227%type <selection_rest_statement> selection_rest_statement 228%type <node> switch_statement 229%type <switch_body> switch_body 230%type <case_label_list> case_label_list 231%type <case_label> case_label 232%type <case_statement> case_statement 233%type <case_statement_list> case_statement_list 234%type <node> iteration_statement 235%type <node> condition 236%type <node> conditionopt 237%type <node> for_init_statement 238%type <for_rest_statement> for_rest_statement 239%% 240 241translation_unit: 242 version_statement extension_statement_list 243 { 244 _mesa_glsl_initialize_types(state); 245 } 246 external_declaration_list 247 { 248 delete state->symbols; 249 state->symbols = new(ralloc_parent(state)) glsl_symbol_table; 250 _mesa_glsl_initialize_types(state); 251 } 252 ; 253 254version_statement: 255 /* blank - no #version specified: defaults are already set */ 256 | VERSION_TOK INTCONSTANT EOL 257 { 258 bool supported = false; 259 260 switch ($2) { 261 case 100: 262 state->es_shader = true; 263 supported = state->ctx->API == API_OPENGLES2 || 264 state->ctx->Extensions.ARB_ES2_compatibility; 265 break; 266 case 110: 267 case 120: 268 /* FINISHME: Once the OpenGL 3.0 'forward compatible' context or 269 * the OpenGL 3.2 Core context is supported, this logic will need 270 * change. Older versions of GLSL are no longer supported 271 * outside the compatibility contexts of 3.x. 272 */ 273 case 130: 274 case 140: 275 case 150: 276 case 330: 277 case 400: 278 case 410: 279 case 420: 280 supported = _mesa_is_desktop_gl(state->ctx) && 281 ((unsigned) $2) <= state->ctx->Const.GLSLVersion; 282 break; 283 default: 284 supported = false; 285 break; 286 } 287 288 state->language_version = $2; 289 state->version_string = 290 ralloc_asprintf(state, "GLSL%s %d.%02d", 291 state->es_shader ? " ES" : "", 292 state->language_version / 100, 293 state->language_version % 100); 294 295 if (!supported) { 296 _mesa_glsl_error(& @2, state, "%s is not supported. " 297 "Supported versions are: %s\n", 298 state->version_string, 299 state->supported_version_string); 300 } 301 302 if (state->language_version >= 140) { 303 state->ARB_uniform_buffer_object_enable = true; 304 } 305 } 306 ; 307 308pragma_statement: 309 PRAGMA_DEBUG_ON EOL 310 | PRAGMA_DEBUG_OFF EOL 311 | PRAGMA_OPTIMIZE_ON EOL 312 | PRAGMA_OPTIMIZE_OFF EOL 313 | PRAGMA_INVARIANT_ALL EOL 314 { 315 if (state->language_version == 110) { 316 _mesa_glsl_warning(& @1, state, 317 "pragma `invariant(all)' not supported in %s", 318 state->version_string); 319 } else { 320 state->all_invariant = true; 321 } 322 } 323 ; 324 325extension_statement_list: 326 327 | extension_statement_list extension_statement 328 ; 329 330any_identifier: 331 IDENTIFIER 332 | TYPE_IDENTIFIER 333 | NEW_IDENTIFIER 334 ; 335 336extension_statement: 337 EXTENSION any_identifier COLON any_identifier EOL 338 { 339 if (!_mesa_glsl_process_extension($2, & @2, $4, & @4, state)) { 340 YYERROR; 341 } 342 } 343 ; 344 345external_declaration_list: 346 external_declaration 347 { 348 /* FINISHME: The NULL test is required because pragmas are set to 349 * FINISHME: NULL. (See production rule for external_declaration.) 350 */ 351 if ($1 != NULL) 352 state->translation_unit.push_tail(& $1->link); 353 } 354 | external_declaration_list external_declaration 355 { 356 /* FINISHME: The NULL test is required because pragmas are set to 357 * FINISHME: NULL. (See production rule for external_declaration.) 358 */ 359 if ($2 != NULL) 360 state->translation_unit.push_tail(& $2->link); 361 } 362 ; 363 364variable_identifier: 365 IDENTIFIER 366 | NEW_IDENTIFIER 367 ; 368 369primary_expression: 370 variable_identifier 371 { 372 void *ctx = state; 373 $$ = new(ctx) ast_expression(ast_identifier, NULL, NULL, NULL); 374 $$->set_location(yylloc); 375 $$->primary_expression.identifier = $1; 376 } 377 | INTCONSTANT 378 { 379 void *ctx = state; 380 $$ = new(ctx) ast_expression(ast_int_constant, NULL, NULL, NULL); 381 $$->set_location(yylloc); 382 $$->primary_expression.int_constant = $1; 383 } 384 | UINTCONSTANT 385 { 386 void *ctx = state; 387 $$ = new(ctx) ast_expression(ast_uint_constant, NULL, NULL, NULL); 388 $$->set_location(yylloc); 389 $$->primary_expression.uint_constant = $1; 390 } 391 | FLOATCONSTANT 392 { 393 void *ctx = state; 394 $$ = new(ctx) ast_expression(ast_float_constant, NULL, NULL, NULL); 395 $$->set_location(yylloc); 396 $$->primary_expression.float_constant = $1; 397 } 398 | BOOLCONSTANT 399 { 400 void *ctx = state; 401 $$ = new(ctx) ast_expression(ast_bool_constant, NULL, NULL, NULL); 402 $$->set_location(yylloc); 403 $$->primary_expression.bool_constant = $1; 404 } 405 | '(' expression ')' 406 { 407 $$ = $2; 408 } 409 ; 410 411postfix_expression: 412 primary_expression 413 | postfix_expression '[' integer_expression ']' 414 { 415 void *ctx = state; 416 $$ = new(ctx) ast_expression(ast_array_index, $1, $3, NULL); 417 $$->set_location(yylloc); 418 } 419 | function_call 420 { 421 $$ = $1; 422 } 423 | postfix_expression '.' any_identifier 424 { 425 void *ctx = state; 426 $$ = new(ctx) ast_expression(ast_field_selection, $1, NULL, NULL); 427 $$->set_location(yylloc); 428 $$->primary_expression.identifier = $3; 429 } 430 | postfix_expression INC_OP 431 { 432 void *ctx = state; 433 $$ = new(ctx) ast_expression(ast_post_inc, $1, NULL, NULL); 434 $$->set_location(yylloc); 435 } 436 | postfix_expression DEC_OP 437 { 438 void *ctx = state; 439 $$ = new(ctx) ast_expression(ast_post_dec, $1, NULL, NULL); 440 $$->set_location(yylloc); 441 } 442 ; 443 444integer_expression: 445 expression 446 ; 447 448function_call: 449 function_call_or_method 450 ; 451 452function_call_or_method: 453 function_call_generic 454 | postfix_expression '.' method_call_generic 455 { 456 void *ctx = state; 457 $$ = new(ctx) ast_expression(ast_field_selection, $1, $3, NULL); 458 $$->set_location(yylloc); 459 } 460 ; 461 462function_call_generic: 463 function_call_header_with_parameters ')' 464 | function_call_header_no_parameters ')' 465 ; 466 467function_call_header_no_parameters: 468 function_call_header VOID_TOK 469 | function_call_header 470 ; 471 472function_call_header_with_parameters: 473 function_call_header assignment_expression 474 { 475 $$ = $1; 476 $$->set_location(yylloc); 477 $$->expressions.push_tail(& $2->link); 478 } 479 | function_call_header_with_parameters ',' assignment_expression 480 { 481 $$ = $1; 482 $$->set_location(yylloc); 483 $$->expressions.push_tail(& $3->link); 484 } 485 ; 486 487 // Grammar Note: Constructors look like functions, but lexical 488 // analysis recognized most of them as keywords. They are now 489 // recognized through "type_specifier". 490function_call_header: 491 function_identifier '(' 492 ; 493 494function_identifier: 495 type_specifier 496 { 497 void *ctx = state; 498 $$ = new(ctx) ast_function_expression($1); 499 $$->set_location(yylloc); 500 } 501 | variable_identifier 502 { 503 void *ctx = state; 504 ast_expression *callee = new(ctx) ast_expression($1); 505 $$ = new(ctx) ast_function_expression(callee); 506 $$->set_location(yylloc); 507 } 508 | FIELD_SELECTION 509 { 510 void *ctx = state; 511 ast_expression *callee = new(ctx) ast_expression($1); 512 $$ = new(ctx) ast_function_expression(callee); 513 $$->set_location(yylloc); 514 } 515 ; 516 517method_call_generic: 518 method_call_header_with_parameters ')' 519 | method_call_header_no_parameters ')' 520 ; 521 522method_call_header_no_parameters: 523 method_call_header VOID_TOK 524 | method_call_header 525 ; 526 527method_call_header_with_parameters: 528 method_call_header assignment_expression 529 { 530 $$ = $1; 531 $$->set_location(yylloc); 532 $$->expressions.push_tail(& $2->link); 533 } 534 | method_call_header_with_parameters ',' assignment_expression 535 { 536 $$ = $1; 537 $$->set_location(yylloc); 538 $$->expressions.push_tail(& $3->link); 539 } 540 ; 541 542 // Grammar Note: Constructors look like methods, but lexical 543 // analysis recognized most of them as keywords. They are now 544 // recognized through "type_specifier". 545method_call_header: 546 variable_identifier '(' 547 { 548 void *ctx = state; 549 ast_expression *callee = new(ctx) ast_expression($1); 550 $$ = new(ctx) ast_function_expression(callee); 551 $$->set_location(yylloc); 552 } 553 ; 554 555 // Grammar Note: No traditional style type casts. 556unary_expression: 557 postfix_expression 558 | INC_OP unary_expression 559 { 560 void *ctx = state; 561 $$ = new(ctx) ast_expression(ast_pre_inc, $2, NULL, NULL); 562 $$->set_location(yylloc); 563 } 564 | DEC_OP unary_expression 565 { 566 void *ctx = state; 567 $$ = new(ctx) ast_expression(ast_pre_dec, $2, NULL, NULL); 568 $$->set_location(yylloc); 569 } 570 | unary_operator unary_expression 571 { 572 void *ctx = state; 573 $$ = new(ctx) ast_expression($1, $2, NULL, NULL); 574 $$->set_location(yylloc); 575 } 576 ; 577 578 // Grammar Note: No '*' or '&' unary ops. Pointers are not supported. 579unary_operator: 580 '+' { $$ = ast_plus; } 581 | '-' { $$ = ast_neg; } 582 | '!' { $$ = ast_logic_not; } 583 | '~' { $$ = ast_bit_not; } 584 ; 585 586multiplicative_expression: 587 unary_expression 588 | multiplicative_expression '*' unary_expression 589 { 590 void *ctx = state; 591 $$ = new(ctx) ast_expression_bin(ast_mul, $1, $3); 592 $$->set_location(yylloc); 593 } 594 | multiplicative_expression '/' unary_expression 595 { 596 void *ctx = state; 597 $$ = new(ctx) ast_expression_bin(ast_div, $1, $3); 598 $$->set_location(yylloc); 599 } 600 | multiplicative_expression '%' unary_expression 601 { 602 void *ctx = state; 603 $$ = new(ctx) ast_expression_bin(ast_mod, $1, $3); 604 $$->set_location(yylloc); 605 } 606 ; 607 608additive_expression: 609 multiplicative_expression 610 | additive_expression '+' multiplicative_expression 611 { 612 void *ctx = state; 613 $$ = new(ctx) ast_expression_bin(ast_add, $1, $3); 614 $$->set_location(yylloc); 615 } 616 | additive_expression '-' multiplicative_expression 617 { 618 void *ctx = state; 619 $$ = new(ctx) ast_expression_bin(ast_sub, $1, $3); 620 $$->set_location(yylloc); 621 } 622 ; 623 624shift_expression: 625 additive_expression 626 | shift_expression LEFT_OP additive_expression 627 { 628 void *ctx = state; 629 $$ = new(ctx) ast_expression_bin(ast_lshift, $1, $3); 630 $$->set_location(yylloc); 631 } 632 | shift_expression RIGHT_OP additive_expression 633 { 634 void *ctx = state; 635 $$ = new(ctx) ast_expression_bin(ast_rshift, $1, $3); 636 $$->set_location(yylloc); 637 } 638 ; 639 640relational_expression: 641 shift_expression 642 | relational_expression '<' shift_expression 643 { 644 void *ctx = state; 645 $$ = new(ctx) ast_expression_bin(ast_less, $1, $3); 646 $$->set_location(yylloc); 647 } 648 | relational_expression '>' shift_expression 649 { 650 void *ctx = state; 651 $$ = new(ctx) ast_expression_bin(ast_greater, $1, $3); 652 $$->set_location(yylloc); 653 } 654 | relational_expression LE_OP shift_expression 655 { 656 void *ctx = state; 657 $$ = new(ctx) ast_expression_bin(ast_lequal, $1, $3); 658 $$->set_location(yylloc); 659 } 660 | relational_expression GE_OP shift_expression 661 { 662 void *ctx = state; 663 $$ = new(ctx) ast_expression_bin(ast_gequal, $1, $3); 664 $$->set_location(yylloc); 665 } 666 ; 667 668equality_expression: 669 relational_expression 670 | equality_expression EQ_OP relational_expression 671 { 672 void *ctx = state; 673 $$ = new(ctx) ast_expression_bin(ast_equal, $1, $3); 674 $$->set_location(yylloc); 675 } 676 | equality_expression NE_OP relational_expression 677 { 678 void *ctx = state; 679 $$ = new(ctx) ast_expression_bin(ast_nequal, $1, $3); 680 $$->set_location(yylloc); 681 } 682 ; 683 684and_expression: 685 equality_expression 686 | and_expression '&' equality_expression 687 { 688 void *ctx = state; 689 $$ = new(ctx) ast_expression_bin(ast_bit_and, $1, $3); 690 $$->set_location(yylloc); 691 } 692 ; 693 694exclusive_or_expression: 695 and_expression 696 | exclusive_or_expression '^' and_expression 697 { 698 void *ctx = state; 699 $$ = new(ctx) ast_expression_bin(ast_bit_xor, $1, $3); 700 $$->set_location(yylloc); 701 } 702 ; 703 704inclusive_or_expression: 705 exclusive_or_expression 706 | inclusive_or_expression '|' exclusive_or_expression 707 { 708 void *ctx = state; 709 $$ = new(ctx) ast_expression_bin(ast_bit_or, $1, $3); 710 $$->set_location(yylloc); 711 } 712 ; 713 714logical_and_expression: 715 inclusive_or_expression 716 | logical_and_expression AND_OP inclusive_or_expression 717 { 718 void *ctx = state; 719 $$ = new(ctx) ast_expression_bin(ast_logic_and, $1, $3); 720 $$->set_location(yylloc); 721 } 722 ; 723 724logical_xor_expression: 725 logical_and_expression 726 | logical_xor_expression XOR_OP logical_and_expression 727 { 728 void *ctx = state; 729 $$ = new(ctx) ast_expression_bin(ast_logic_xor, $1, $3); 730 $$->set_location(yylloc); 731 } 732 ; 733 734logical_or_expression: 735 logical_xor_expression 736 | logical_or_expression OR_OP logical_xor_expression 737 { 738 void *ctx = state; 739 $$ = new(ctx) ast_expression_bin(ast_logic_or, $1, $3); 740 $$->set_location(yylloc); 741 } 742 ; 743 744conditional_expression: 745 logical_or_expression 746 | logical_or_expression '?' expression ':' assignment_expression 747 { 748 void *ctx = state; 749 $$ = new(ctx) ast_expression(ast_conditional, $1, $3, $5); 750 $$->set_location(yylloc); 751 } 752 ; 753 754assignment_expression: 755 conditional_expression 756 | unary_expression assignment_operator assignment_expression 757 { 758 void *ctx = state; 759 $$ = new(ctx) ast_expression($2, $1, $3, NULL); 760 $$->set_location(yylloc); 761 } 762 ; 763 764assignment_operator: 765 '=' { $$ = ast_assign; } 766 | MUL_ASSIGN { $$ = ast_mul_assign; } 767 | DIV_ASSIGN { $$ = ast_div_assign; } 768 | MOD_ASSIGN { $$ = ast_mod_assign; } 769 | ADD_ASSIGN { $$ = ast_add_assign; } 770 | SUB_ASSIGN { $$ = ast_sub_assign; } 771 | LEFT_ASSIGN { $$ = ast_ls_assign; } 772 | RIGHT_ASSIGN { $$ = ast_rs_assign; } 773 | AND_ASSIGN { $$ = ast_and_assign; } 774 | XOR_ASSIGN { $$ = ast_xor_assign; } 775 | OR_ASSIGN { $$ = ast_or_assign; } 776 ; 777 778expression: 779 assignment_expression 780 { 781 $$ = $1; 782 } 783 | expression ',' assignment_expression 784 { 785 void *ctx = state; 786 if ($1->oper != ast_sequence) { 787 $$ = new(ctx) ast_expression(ast_sequence, NULL, NULL, NULL); 788 $$->set_location(yylloc); 789 $$->expressions.push_tail(& $1->link); 790 } else { 791 $$ = $1; 792 } 793 794 $$->expressions.push_tail(& $3->link); 795 } 796 ; 797 798constant_expression: 799 conditional_expression 800 ; 801 802declaration: 803 function_prototype ';' 804 { 805 state->symbols->pop_scope(); 806 $$ = $1; 807 } 808 | init_declarator_list ';' 809 { 810 $$ = $1; 811 } 812 | PRECISION precision_qualifier type_specifier_no_prec ';' 813 { 814 $3->precision = $2; 815 $3->is_precision_statement = true; 816 $$ = $3; 817 } 818 | uniform_block 819 { 820 $$ = $1; 821 } 822 ; 823 824function_prototype: 825 function_declarator ')' 826 ; 827 828function_declarator: 829 function_header 830 | function_header_with_parameters 831 ; 832 833function_header_with_parameters: 834 function_header parameter_declaration 835 { 836 $$ = $1; 837 $$->parameters.push_tail(& $2->link); 838 } 839 | function_header_with_parameters ',' parameter_declaration 840 { 841 $$ = $1; 842 $$->parameters.push_tail(& $3->link); 843 } 844 ; 845 846function_header: 847 fully_specified_type variable_identifier '(' 848 { 849 void *ctx = state; 850 $$ = new(ctx) ast_function(); 851 $$->set_location(yylloc); 852 $$->return_type = $1; 853 $$->identifier = $2; 854 855 state->symbols->add_function(new(state) ir_function($2)); 856 state->symbols->push_scope(); 857 } 858 ; 859 860parameter_declarator: 861 type_specifier any_identifier 862 { 863 void *ctx = state; 864 $$ = new(ctx) ast_parameter_declarator(); 865 $$->set_location(yylloc); 866 $$->type = new(ctx) ast_fully_specified_type(); 867 $$->type->set_location(yylloc); 868 $$->type->specifier = $1; 869 $$->identifier = $2; 870 } 871 | type_specifier any_identifier '[' constant_expression ']' 872 { 873 void *ctx = state; 874 $$ = new(ctx) ast_parameter_declarator(); 875 $$->set_location(yylloc); 876 $$->type = new(ctx) ast_fully_specified_type(); 877 $$->type->set_location(yylloc); 878 $$->type->specifier = $1; 879 $$->identifier = $2; 880 $$->is_array = true; 881 $$->array_size = $4; 882 } 883 ; 884 885parameter_declaration: 886 parameter_type_qualifier parameter_qualifier parameter_declarator 887 { 888 $1.flags.i |= $2.flags.i; 889 890 $$ = $3; 891 $$->type->qualifier = $1; 892 } 893 | parameter_qualifier parameter_declarator 894 { 895 $$ = $2; 896 $$->type->qualifier = $1; 897 } 898 | parameter_type_qualifier parameter_qualifier parameter_type_specifier 899 { 900 void *ctx = state; 901 $1.flags.i |= $2.flags.i; 902 903 $$ = new(ctx) ast_parameter_declarator(); 904 $$->set_location(yylloc); 905 $$->type = new(ctx) ast_fully_specified_type(); 906 $$->type->qualifier = $1; 907 $$->type->specifier = $3; 908 } 909 | parameter_qualifier parameter_type_specifier 910 { 911 void *ctx = state; 912 $$ = new(ctx) ast_parameter_declarator(); 913 $$->set_location(yylloc); 914 $$->type = new(ctx) ast_fully_specified_type(); 915 $$->type->qualifier = $1; 916 $$->type->specifier = $2; 917 } 918 ; 919 920parameter_qualifier: 921 /* empty */ 922 { 923 memset(& $$, 0, sizeof($$)); 924 } 925 | IN_TOK 926 { 927 memset(& $$, 0, sizeof($$)); 928 $$.flags.q.in = 1; 929 } 930 | OUT_TOK 931 { 932 memset(& $$, 0, sizeof($$)); 933 $$.flags.q.out = 1; 934 } 935 | INOUT_TOK 936 { 937 memset(& $$, 0, sizeof($$)); 938 $$.flags.q.in = 1; 939 $$.flags.q.out = 1; 940 } 941 ; 942 943parameter_type_specifier: 944 type_specifier 945 ; 946 947init_declarator_list: 948 single_declaration 949 | init_declarator_list ',' any_identifier 950 { 951 void *ctx = state; 952 ast_declaration *decl = new(ctx) ast_declaration($3, false, NULL, NULL); 953 decl->set_location(yylloc); 954 955 $$ = $1; 956 $$->declarations.push_tail(&decl->link); 957 state->symbols->add_variable(new(state) ir_variable(NULL, $3, ir_var_auto)); 958 } 959 | init_declarator_list ',' any_identifier '[' ']' 960 { 961 void *ctx = state; 962 ast_declaration *decl = new(ctx) ast_declaration($3, true, NULL, NULL); 963 decl->set_location(yylloc); 964 965 $$ = $1; 966 $$->declarations.push_tail(&decl->link); 967 state->symbols->add_variable(new(state) ir_variable(NULL, $3, ir_var_auto)); 968 } 969 | init_declarator_list ',' any_identifier '[' constant_expression ']' 970 { 971 void *ctx = state; 972 ast_declaration *decl = new(ctx) ast_declaration($3, true, $5, NULL); 973 decl->set_location(yylloc); 974 975 $$ = $1; 976 $$->declarations.push_tail(&decl->link); 977 state->symbols->add_variable(new(state) ir_variable(NULL, $3, ir_var_auto)); 978 } 979 | init_declarator_list ',' any_identifier '[' ']' '=' initializer 980 { 981 void *ctx = state; 982 ast_declaration *decl = new(ctx) ast_declaration($3, true, NULL, $7); 983 decl->set_location(yylloc); 984 985 $$ = $1; 986 $$->declarations.push_tail(&decl->link); 987 state->symbols->add_variable(new(state) ir_variable(NULL, $3, ir_var_auto)); 988 } 989 | init_declarator_list ',' any_identifier '[' constant_expression ']' '=' initializer 990 { 991 void *ctx = state; 992 ast_declaration *decl = new(ctx) ast_declaration($3, true, $5, $8); 993 decl->set_location(yylloc); 994 995 $$ = $1; 996 $$->declarations.push_tail(&decl->link); 997 state->symbols->add_variable(new(state) ir_variable(NULL, $3, ir_var_auto)); 998 } 999 | init_declarator_list ',' any_identifier '=' initializer 1000 { 1001 void *ctx = state; 1002 ast_declaration *decl = new(ctx) ast_declaration($3, false, NULL, $5); 1003 decl->set_location(yylloc); 1004 1005 $$ = $1; 1006 $$->declarations.push_tail(&decl->link); 1007 state->symbols->add_variable(new(state) ir_variable(NULL, $3, ir_var_auto)); 1008 } 1009 ; 1010 1011 // Grammar Note: No 'enum', or 'typedef'. 1012single_declaration: 1013 fully_specified_type 1014 { 1015 void *ctx = state; 1016 /* Empty declaration list is valid. */ 1017 $$ = new(ctx) ast_declarator_list($1); 1018 $$->set_location(yylloc); 1019 } 1020 | fully_specified_type any_identifier 1021 { 1022 void *ctx = state; 1023 ast_declaration *decl = new(ctx) ast_declaration($2, false, NULL, NULL); 1024 1025 $$ = new(ctx) ast_declarator_list($1); 1026 $$->set_location(yylloc); 1027 $$->declarations.push_tail(&decl->link); 1028 } 1029 | fully_specified_type any_identifier '[' ']' 1030 { 1031 void *ctx = state; 1032 ast_declaration *decl = new(ctx) ast_declaration($2, true, NULL, NULL); 1033 1034 $$ = new(ctx) ast_declarator_list($1); 1035 $$->set_location(yylloc); 1036 $$->declarations.push_tail(&decl->link); 1037 } 1038 | fully_specified_type any_identifier '[' constant_expression ']' 1039 { 1040 void *ctx = state; 1041 ast_declaration *decl = new(ctx) ast_declaration($2, true, $4, NULL); 1042 1043 $$ = new(ctx) ast_declarator_list($1); 1044 $$->set_location(yylloc); 1045 $$->declarations.push_tail(&decl->link); 1046 } 1047 | fully_specified_type any_identifier '[' ']' '=' initializer 1048 { 1049 void *ctx = state; 1050 ast_declaration *decl = new(ctx) ast_declaration($2, true, NULL, $6); 1051 1052 $$ = new(ctx) ast_declarator_list($1); 1053 $$->set_location(yylloc); 1054 $$->declarations.push_tail(&decl->link); 1055 } 1056 | fully_specified_type any_identifier '[' constant_expression ']' '=' initializer 1057 { 1058 void *ctx = state; 1059 ast_declaration *decl = new(ctx) ast_declaration($2, true, $4, $7); 1060 1061 $$ = new(ctx) ast_declarator_list($1); 1062 $$->set_location(yylloc); 1063 $$->declarations.push_tail(&decl->link); 1064 } 1065 | fully_specified_type any_identifier '=' initializer 1066 { 1067 void *ctx = state; 1068 ast_declaration *decl = new(ctx) ast_declaration($2, false, NULL, $4); 1069 1070 $$ = new(ctx) ast_declarator_list($1); 1071 $$->set_location(yylloc); 1072 $$->declarations.push_tail(&decl->link); 1073 } 1074 | INVARIANT variable_identifier // Vertex only. 1075 { 1076 void *ctx = state; 1077 ast_declaration *decl = new(ctx) ast_declaration($2, false, NULL, NULL); 1078 1079 $$ = new(ctx) ast_declarator_list(NULL); 1080 $$->set_location(yylloc); 1081 $$->invariant = true; 1082 1083 $$->declarations.push_tail(&decl->link); 1084 } 1085 ; 1086 1087fully_specified_type: 1088 type_specifier 1089 { 1090 void *ctx = state; 1091 $$ = new(ctx) ast_fully_specified_type(); 1092 $$->set_location(yylloc); 1093 $$->specifier = $1; 1094 } 1095 | type_qualifier type_specifier 1096 { 1097 void *ctx = state; 1098 $$ = new(ctx) ast_fully_specified_type(); 1099 $$->set_location(yylloc); 1100 $$->qualifier = $1; 1101 $$->specifier = $2; 1102 } 1103 ; 1104 1105layout_qualifier: 1106 LAYOUT_TOK '(' layout_qualifier_id_list ')' 1107 { 1108 $$ = $3; 1109 } 1110 ; 1111 1112layout_qualifier_id_list: 1113 layout_qualifier_id 1114 | layout_qualifier_id_list ',' layout_qualifier_id 1115 { 1116 $$ = $1; 1117 if (!$$.merge_qualifier(& @3, state, $3)) { 1118 YYERROR; 1119 } 1120 } 1121 ; 1122 1123layout_qualifier_id: 1124 any_identifier 1125 { 1126 memset(& $$, 0, sizeof($$)); 1127 1128 /* Layout qualifiers for ARB_fragment_coord_conventions. */ 1129 if (!$$.flags.i && state->ARB_fragment_coord_conventions_enable) { 1130 if (strcmp($1, "origin_upper_left") == 0) { 1131 $$.flags.q.origin_upper_left = 1; 1132 } else if (strcmp($1, "pixel_center_integer") == 0) { 1133 $$.flags.q.pixel_center_integer = 1; 1134 } 1135 1136 if ($$.flags.i && state->ARB_fragment_coord_conventions_warn) { 1137 _mesa_glsl_warning(& @1, state, 1138 "GL_ARB_fragment_coord_conventions layout " 1139 "identifier `%s' used\n", $1); 1140 } 1141 } 1142 1143 /* Layout qualifiers for AMD/ARB_conservative_depth. */ 1144 if (!$$.flags.i && 1145 (state->AMD_conservative_depth_enable || 1146 state->ARB_conservative_depth_enable)) { 1147 if (strcmp($1, "depth_any") == 0) { 1148 $$.flags.q.depth_any = 1; 1149 } else if (strcmp($1, "depth_greater") == 0) { 1150 $$.flags.q.depth_greater = 1; 1151 } else if (strcmp($1, "depth_less") == 0) { 1152 $$.flags.q.depth_less = 1; 1153 } else if (strcmp($1, "depth_unchanged") == 0) { 1154 $$.flags.q.depth_unchanged = 1; 1155 } 1156 1157 if ($$.flags.i && state->AMD_conservative_depth_warn) { 1158 _mesa_glsl_warning(& @1, state, 1159 "GL_AMD_conservative_depth " 1160 "layout qualifier `%s' is used\n", $1); 1161 } 1162 if ($$.flags.i && state->ARB_conservative_depth_warn) { 1163 _mesa_glsl_warning(& @1, state, 1164 "GL_ARB_conservative_depth " 1165 "layout qualifier `%s' is used\n", $1); 1166 } 1167 } 1168 1169 /* See also uniform_block_layout_qualifier. */ 1170 if (!$$.flags.i && state->ARB_uniform_buffer_object_enable) { 1171 if (strcmp($1, "std140") == 0) { 1172 $$.flags.q.std140 = 1; 1173 } else if (strcmp($1, "shared") == 0) { 1174 $$.flags.q.shared = 1; 1175 } else if (strcmp($1, "column_major") == 0) { 1176 $$.flags.q.column_major = 1; 1177 } 1178 1179 if ($$.flags.i && state->ARB_uniform_buffer_object_warn) { 1180 _mesa_glsl_warning(& @1, state, 1181 "#version 140 / GL_ARB_uniform_buffer_object " 1182 "layout qualifier `%s' is used\n", $1); 1183 } 1184 } 1185 1186 if (!$$.flags.i) { 1187 _mesa_glsl_error(& @1, state, "unrecognized layout identifier " 1188 "`%s'\n", $1); 1189 YYERROR; 1190 } 1191 } 1192 | any_identifier '=' INTCONSTANT 1193 { 1194 memset(& $$, 0, sizeof($$)); 1195 1196 if (state->ARB_explicit_attrib_location_enable) { 1197 /* FINISHME: Handle 'index' once GL_ARB_blend_func_exteneded and 1198 * FINISHME: GLSL 1.30 (or later) are supported. 1199 */ 1200 if (strcmp("location", $1) == 0) { 1201 $$.flags.q.explicit_location = 1; 1202 1203 if ($3 >= 0) { 1204 $$.location = $3; 1205 } else { 1206 _mesa_glsl_error(& @3, state, 1207 "invalid location %d specified\n", $3); 1208 YYERROR; 1209 } 1210 } 1211 1212 if (strcmp("index", $1) == 0) { 1213 $$.flags.q.explicit_index = 1; 1214 1215 if ($3 >= 0) { 1216 $$.index = $3; 1217 } else { 1218 _mesa_glsl_error(& @3, state, 1219 "invalid index %d specified\n", $3); 1220 YYERROR; 1221 } 1222 } 1223 } 1224 1225 /* If the identifier didn't match any known layout identifiers, 1226 * emit an error. 1227 */ 1228 if (!$$.flags.i) { 1229 _mesa_glsl_error(& @1, state, "unrecognized layout identifier " 1230 "`%s'\n", $1); 1231 YYERROR; 1232 } else if (state->ARB_explicit_attrib_location_warn) { 1233 _mesa_glsl_warning(& @1, state, 1234 "GL_ARB_explicit_attrib_location layout " 1235 "identifier `%s' used\n", $1); 1236 } 1237 } 1238 | uniform_block_layout_qualifier 1239 { 1240 $$ = $1; 1241 /* Layout qualifiers for ARB_uniform_buffer_object. */ 1242 if (!state->ARB_uniform_buffer_object_enable) { 1243 _mesa_glsl_error(& @1, state, 1244 "#version 140 / GL_ARB_uniform_buffer_object " 1245 "layout qualifier `%s' is used\n", $1); 1246 } else if (state->ARB_uniform_buffer_object_warn) { 1247 _mesa_glsl_warning(& @1, state, 1248 "#version 140 / GL_ARB_uniform_buffer_object " 1249 "layout qualifier `%s' is used\n", $1); 1250 } 1251 } 1252 ; 1253 1254/* This is a separate language rule because we parse these as tokens 1255 * (due to them being reserved keywords) instead of identifiers like 1256 * most qualifiers. See the any_identifier path of 1257 * layout_qualifier_id for the others. 1258 */ 1259uniform_block_layout_qualifier: 1260 ROW_MAJOR 1261 { 1262 memset(& $$, 0, sizeof($$)); 1263 $$.flags.q.row_major = 1; 1264 } 1265 | PACKED_TOK 1266 { 1267 memset(& $$, 0, sizeof($$)); 1268 $$.flags.q.packed = 1; 1269 } 1270 ; 1271 1272interpolation_qualifier: 1273 SMOOTH 1274 { 1275 memset(& $$, 0, sizeof($$)); 1276 $$.flags.q.smooth = 1; 1277 } 1278 | FLAT 1279 { 1280 memset(& $$, 0, sizeof($$)); 1281 $$.flags.q.flat = 1; 1282 } 1283 | NOPERSPECTIVE 1284 { 1285 memset(& $$, 0, sizeof($$)); 1286 $$.flags.q.noperspective = 1; 1287 } 1288 ; 1289 1290parameter_type_qualifier: 1291 CONST_TOK 1292 { 1293 memset(& $$, 0, sizeof($$)); 1294 $$.flags.q.constant = 1; 1295 } 1296 ; 1297 1298type_qualifier: 1299 storage_qualifier 1300 | layout_qualifier 1301 | layout_qualifier storage_qualifier 1302 { 1303 $$ = $1; 1304 $$.flags.i |= $2.flags.i; 1305 } 1306 | interpolation_qualifier 1307 | interpolation_qualifier storage_qualifier 1308 { 1309 $$ = $1; 1310 $$.flags.i |= $2.flags.i; 1311 } 1312 | INVARIANT storage_qualifier 1313 { 1314 $$ = $2; 1315 $$.flags.q.invariant = 1; 1316 } 1317 | INVARIANT interpolation_qualifier storage_qualifier 1318 { 1319 $$ = $2; 1320 $$.flags.i |= $3.flags.i; 1321 $$.flags.q.invariant = 1; 1322 } 1323 | INVARIANT 1324 { 1325 memset(& $$, 0, sizeof($$)); 1326 $$.flags.q.invariant = 1; 1327 } 1328 ; 1329 1330storage_qualifier: 1331 CONST_TOK 1332 { 1333 memset(& $$, 0, sizeof($$)); 1334 $$.flags.q.constant = 1; 1335 } 1336 | ATTRIBUTE 1337 { 1338 memset(& $$, 0, sizeof($$)); 1339 $$.flags.q.attribute = 1; 1340 } 1341 | VARYING 1342 { 1343 memset(& $$, 0, sizeof($$)); 1344 $$.flags.q.varying = 1; 1345 } 1346 | CENTROID VARYING 1347 { 1348 memset(& $$, 0, sizeof($$)); 1349 $$.flags.q.centroid = 1; 1350 $$.flags.q.varying = 1; 1351 } 1352 | IN_TOK 1353 { 1354 memset(& $$, 0, sizeof($$)); 1355 $$.flags.q.in = 1; 1356 } 1357 | OUT_TOK 1358 { 1359 memset(& $$, 0, sizeof($$)); 1360 $$.flags.q.out = 1; 1361 } 1362 | CENTROID IN_TOK 1363 { 1364 memset(& $$, 0, sizeof($$)); 1365 $$.flags.q.centroid = 1; $$.flags.q.in = 1; 1366 } 1367 | CENTROID OUT_TOK 1368 { 1369 memset(& $$, 0, sizeof($$)); 1370 $$.flags.q.centroid = 1; $$.flags.q.out = 1; 1371 } 1372 | UNIFORM 1373 { 1374 memset(& $$, 0, sizeof($$)); 1375 $$.flags.q.uniform = 1; 1376 } 1377 ; 1378 1379type_specifier: 1380 type_specifier_no_prec 1381 { 1382 $$ = $1; 1383 } 1384 | precision_qualifier type_specifier_no_prec 1385 { 1386 $$ = $2; 1387 $$->precision = $1; 1388 } 1389 ; 1390 1391type_specifier_no_prec: 1392 type_specifier_nonarray 1393 | type_specifier_nonarray '[' ']' 1394 { 1395 $$ = $1; 1396 $$->is_array = true; 1397 $$->array_size = NULL; 1398 } 1399 | type_specifier_nonarray '[' constant_expression ']' 1400 { 1401 $$ = $1; 1402 $$->is_array = true; 1403 $$->array_size = $3; 1404 } 1405 ; 1406 1407type_specifier_nonarray: 1408 basic_type_specifier_nonarray 1409 { 1410 void *ctx = state; 1411 $$ = new(ctx) ast_type_specifier($1); 1412 $$->set_location(yylloc); 1413 } 1414 | struct_specifier 1415 { 1416 void *ctx = state; 1417 $$ = new(ctx) ast_type_specifier($1); 1418 $$->set_location(yylloc); 1419 } 1420 | TYPE_IDENTIFIER 1421 { 1422 void *ctx = state; 1423 $$ = new(ctx) ast_type_specifier($1); 1424 $$->set_location(yylloc); 1425 } 1426 ; 1427 1428basic_type_specifier_nonarray: 1429 VOID_TOK { $$ = "void"; } 1430 | FLOAT_TOK { $$ = "float"; } 1431 | INT_TOK { $$ = "int"; } 1432 | UINT_TOK { $$ = "uint"; } 1433 | BOOL_TOK { $$ = "bool"; } 1434 | VEC2 { $$ = "vec2"; } 1435 | VEC3 { $$ = "vec3"; } 1436 | VEC4 { $$ = "vec4"; } 1437 | BVEC2 { $$ = "bvec2"; } 1438 | BVEC3 { $$ = "bvec3"; } 1439 | BVEC4 { $$ = "bvec4"; } 1440 | IVEC2 { $$ = "ivec2"; } 1441 | IVEC3 { $$ = "ivec3"; } 1442 | IVEC4 { $$ = "ivec4"; } 1443 | UVEC2 { $$ = "uvec2"; } 1444 | UVEC3 { $$ = "uvec3"; } 1445 | UVEC4 { $$ = "uvec4"; } 1446 | MAT2X2 { $$ = "mat2"; } 1447 | MAT2X3 { $$ = "mat2x3"; } 1448 | MAT2X4 { $$ = "mat2x4"; } 1449 | MAT3X2 { $$ = "mat3x2"; } 1450 | MAT3X3 { $$ = "mat3"; } 1451 | MAT3X4 { $$ = "mat3x4"; } 1452 | MAT4X2 { $$ = "mat4x2"; } 1453 | MAT4X3 { $$ = "mat4x3"; } 1454 | MAT4X4 { $$ = "mat4"; } 1455 | SAMPLER1D { $$ = "sampler1D"; } 1456 | SAMPLER2D { $$ = "sampler2D"; } 1457 | SAMPLER2DRECT { $$ = "sampler2DRect"; } 1458 | SAMPLER3D { $$ = "sampler3D"; } 1459 | SAMPLERCUBE { $$ = "samplerCube"; } 1460 | SAMPLEREXTERNALOES { $$ = "samplerExternalOES"; } 1461 | SAMPLER1DSHADOW { $$ = "sampler1DShadow"; } 1462 | SAMPLER2DSHADOW { $$ = "sampler2DShadow"; } 1463 | SAMPLER2DRECTSHADOW { $$ = "sampler2DRectShadow"; } 1464 | SAMPLERCUBESHADOW { $$ = "samplerCubeShadow"; } 1465 | SAMPLER1DARRAY { $$ = "sampler1DArray"; } 1466 | SAMPLER2DARRAY { $$ = "sampler2DArray"; } 1467 | SAMPLER1DARRAYSHADOW { $$ = "sampler1DArrayShadow"; } 1468 | SAMPLER2DARRAYSHADOW { $$ = "sampler2DArrayShadow"; } 1469 | SAMPLERBUFFER { $$ = "samplerBuffer"; } 1470 | ISAMPLER1D { $$ = "isampler1D"; } 1471 | ISAMPLER2D { $$ = "isampler2D"; } 1472 | ISAMPLER2DRECT { $$ = "isampler2DRect"; } 1473 | ISAMPLER3D { $$ = "isampler3D"; } 1474 | ISAMPLERCUBE { $$ = "isamplerCube"; } 1475 | ISAMPLER1DARRAY { $$ = "isampler1DArray"; } 1476 | ISAMPLER2DARRAY { $$ = "isampler2DArray"; } 1477 | ISAMPLERBUFFER { $$ = "isamplerBuffer"; } 1478 | USAMPLER1D { $$ = "usampler1D"; } 1479 | USAMPLER2D { $$ = "usampler2D"; } 1480 | USAMPLER2DRECT { $$ = "usampler2DRect"; } 1481 | USAMPLER3D { $$ = "usampler3D"; } 1482 | USAMPLERCUBE { $$ = "usamplerCube"; } 1483 | USAMPLER1DARRAY { $$ = "usampler1DArray"; } 1484 | USAMPLER2DARRAY { $$ = "usampler2DArray"; } 1485 | USAMPLERBUFFER { $$ = "usamplerBuffer"; } 1486 ; 1487 1488precision_qualifier: 1489 HIGHP { 1490 if (!state->es_shader && state->language_version < 130) 1491 _mesa_glsl_error(& @1, state, 1492 "precision qualifier forbidden " 1493 "in %s (1.30 or later " 1494 "required)\n", 1495 state->version_string); 1496 1497 $$ = ast_precision_high; 1498 } 1499 | MEDIUMP { 1500 if (!state->es_shader && state->language_version < 130) 1501 _mesa_glsl_error(& @1, state, 1502 "precision qualifier forbidden " 1503 "in %s (1.30 or later " 1504 "required)\n", 1505 state->version_string); 1506 1507 $$ = ast_precision_medium; 1508 } 1509 | LOWP { 1510 if (!state->es_shader && state->language_version < 130) 1511 _mesa_glsl_error(& @1, state, 1512 "precision qualifier forbidden " 1513 "in %s (1.30 or later " 1514 "required)\n", 1515 state->version_string); 1516 1517 $$ = ast_precision_low; 1518 } 1519 ; 1520 1521struct_specifier: 1522 STRUCT any_identifier '{' struct_declaration_list '}' 1523 { 1524 void *ctx = state; 1525 $$ = new(ctx) ast_struct_specifier($2, $4); 1526 $$->set_location(yylloc); 1527 state->symbols->add_type($2, glsl_type::void_type); 1528 } 1529 | STRUCT '{' struct_declaration_list '}' 1530 { 1531 void *ctx = state; 1532 $$ = new(ctx) ast_struct_specifier(NULL, $3); 1533 $$->set_location(yylloc); 1534 } 1535 ; 1536 1537struct_declaration_list: 1538 struct_declaration 1539 { 1540 $$ = $1; 1541 $1->link.self_link(); 1542 } 1543 | struct_declaration_list struct_declaration 1544 { 1545 $$ = $1; 1546 $$->link.insert_before(& $2->link); 1547 } 1548 ; 1549 1550struct_declaration: 1551 type_specifier struct_declarator_list ';' 1552 { 1553 void *ctx = state; 1554 ast_fully_specified_type *type = new(ctx) ast_fully_specified_type(); 1555 type->set_location(yylloc); 1556 1557 type->specifier = $1; 1558 $$ = new(ctx) ast_declarator_list(type); 1559 $$->set_location(yylloc); 1560 1561 $$->declarations.push_degenerate_list_at_head(& $2->link); 1562 } 1563 ; 1564 1565struct_declarator_list: 1566 struct_declarator 1567 { 1568 $$ = $1; 1569 $1->link.self_link(); 1570 } 1571 | struct_declarator_list ',' struct_declarator 1572 { 1573 $$ = $1; 1574 $$->link.insert_before(& $3->link); 1575 } 1576 ; 1577 1578struct_declarator: 1579 any_identifier 1580 { 1581 void *ctx = state; 1582 $$ = new(ctx) ast_declaration($1, false, NULL, NULL); 1583 $$->set_location(yylloc); 1584 } 1585 | any_identifier '[' constant_expression ']' 1586 { 1587 void *ctx = state; 1588 $$ = new(ctx) ast_declaration($1, true, $3, NULL); 1589 $$->set_location(yylloc); 1590 } 1591 ; 1592 1593initializer: 1594 assignment_expression 1595 ; 1596 1597declaration_statement: 1598 declaration 1599 ; 1600 1601 // Grammar Note: labeled statements for SWITCH only; 'goto' is not 1602 // supported. 1603statement: 1604 compound_statement { $$ = (ast_node *) $1; } 1605 | simple_statement 1606 ; 1607 1608simple_statement: 1609 declaration_statement 1610 | expression_statement 1611 | selection_statement 1612 | switch_statement 1613 | iteration_statement 1614 | jump_statement 1615 ; 1616 1617compound_statement: 1618 '{' '}' 1619 { 1620 void *ctx = state; 1621 $$ = new(ctx) ast_compound_statement(true, NULL); 1622 $$->set_location(yylloc); 1623 } 1624 | '{' 1625 { 1626 state->symbols->push_scope(); 1627 } 1628 statement_list '}' 1629 { 1630 void *ctx = state; 1631 $$ = new(ctx) ast_compound_statement(true, $3); 1632 $$->set_location(yylloc); 1633 state->symbols->pop_scope(); 1634 } 1635 ; 1636 1637statement_no_new_scope: 1638 compound_statement_no_new_scope { $$ = (ast_node *) $1; } 1639 | simple_statement 1640 ; 1641 1642compound_statement_no_new_scope: 1643 '{' '}' 1644 { 1645 void *ctx = state; 1646 $$ = new(ctx) ast_compound_statement(false, NULL); 1647 $$->set_location(yylloc); 1648 } 1649 | '{' statement_list '}' 1650 { 1651 void *ctx = state; 1652 $$ = new(ctx) ast_compound_statement(false, $2); 1653 $$->set_location(yylloc); 1654 } 1655 ; 1656 1657statement_list: 1658 statement 1659 { 1660 if ($1 == NULL) { 1661 _mesa_glsl_error(& @1, state, "<nil> statement\n"); 1662 assert($1 != NULL); 1663 } 1664 1665 $$ = $1; 1666 $$->link.self_link(); 1667 } 1668 | statement_list statement 1669 { 1670 if ($2 == NULL) { 1671 _mesa_glsl_error(& @2, state, "<nil> statement\n"); 1672 assert($2 != NULL); 1673 } 1674 $$ = $1; 1675 $$->link.insert_before(& $2->link); 1676 } 1677 ; 1678 1679expression_statement: 1680 ';' 1681 { 1682 void *ctx = state; 1683 $$ = new(ctx) ast_expression_statement(NULL); 1684 $$->set_location(yylloc); 1685 } 1686 | expression ';' 1687 { 1688 void *ctx = state; 1689 $$ = new(ctx) ast_expression_statement($1); 1690 $$->set_location(yylloc); 1691 } 1692 ; 1693 1694selection_statement: 1695 IF '(' expression ')' selection_rest_statement 1696 { 1697 $$ = new(state) ast_selection_statement($3, $5.then_statement, 1698 $5.else_statement); 1699 $$->set_location(yylloc); 1700 } 1701 ; 1702 1703selection_rest_statement: 1704 statement ELSE statement 1705 { 1706 $$.then_statement = $1; 1707 $$.else_statement = $3; 1708 } 1709 | statement 1710 { 1711 $$.then_statement = $1; 1712 $$.else_statement = NULL; 1713 } 1714 ; 1715 1716condition: 1717 expression 1718 { 1719 $$ = (ast_node *) $1; 1720 } 1721 | fully_specified_type any_identifier '=' initializer 1722 { 1723 void *ctx = state; 1724 ast_declaration *decl = new(ctx) ast_declaration($2, false, NULL, $4); 1725 ast_declarator_list *declarator = new(ctx) ast_declarator_list($1); 1726 decl->set_location(yylloc); 1727 declarator->set_location(yylloc); 1728 1729 declarator->declarations.push_tail(&decl->link); 1730 $$ = declarator; 1731 } 1732 ; 1733 1734/* 1735 * siwtch_statement grammar is based on the syntax described in the body 1736 * of the GLSL spec, not in it's appendix!!! 1737 */ 1738switch_statement: 1739 SWITCH '(' expression ')' switch_body 1740 { 1741 $$ = new(state) ast_switch_statement($3, $5); 1742 $$->set_location(yylloc); 1743 } 1744 ; 1745 1746switch_body: 1747 '{' '}' 1748 { 1749 $$ = new(state) ast_switch_body(NULL); 1750 $$->set_location(yylloc); 1751 } 1752 | '{' case_statement_list '}' 1753 { 1754 $$ = new(state) ast_switch_body($2); 1755 $$->set_location(yylloc); 1756 } 1757 ; 1758 1759case_label: 1760 CASE expression ':' 1761 { 1762 $$ = new(state) ast_case_label($2); 1763 $$->set_location(yylloc); 1764 } 1765 | DEFAULT ':' 1766 { 1767 $$ = new(state) ast_case_label(NULL); 1768 $$->set_location(yylloc); 1769 } 1770 ; 1771 1772case_label_list: 1773 case_label 1774 { 1775 ast_case_label_list *labels = new(state) ast_case_label_list(); 1776 1777 labels->labels.push_tail(& $1->link); 1778 $$ = labels; 1779 $$->set_location(yylloc); 1780 } 1781 | case_label_list case_label 1782 { 1783 $$ = $1; 1784 $$->labels.push_tail(& $2->link); 1785 } 1786 ; 1787 1788case_statement: 1789 case_label_list statement 1790 { 1791 ast_case_statement *stmts = new(state) ast_case_statement($1); 1792 stmts->set_location(yylloc); 1793 1794 stmts->stmts.push_tail(& $2->link); 1795 $$ = stmts; 1796 } 1797 | case_statement statement 1798 { 1799 $$ = $1; 1800 $$->stmts.push_tail(& $2->link); 1801 } 1802 ; 1803 1804case_statement_list: 1805 case_statement 1806 { 1807 ast_case_statement_list *cases= new(state) ast_case_statement_list(); 1808 cases->set_location(yylloc); 1809 1810 cases->cases.push_tail(& $1->link); 1811 $$ = cases; 1812 } 1813 | case_statement_list case_statement 1814 { 1815 $$ = $1; 1816 $$->cases.push_tail(& $2->link); 1817 } 1818 ; 1819 1820iteration_statement: 1821 WHILE '(' condition ')' statement_no_new_scope 1822 { 1823 void *ctx = state; 1824 $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_while, 1825 NULL, $3, NULL, $5); 1826 $$->set_location(yylloc); 1827 } 1828 | DO statement WHILE '(' expression ')' ';' 1829 { 1830 void *ctx = state; 1831 $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_do_while, 1832 NULL, $5, NULL, $2); 1833 $$->set_location(yylloc); 1834 } 1835 | FOR '(' for_init_statement for_rest_statement ')' statement_no_new_scope 1836 { 1837 void *ctx = state; 1838 $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_for, 1839 $3, $4.cond, $4.rest, $6); 1840 $$->set_location(yylloc); 1841 } 1842 ; 1843 1844for_init_statement: 1845 expression_statement 1846 | declaration_statement 1847 ; 1848 1849conditionopt: 1850 condition 1851 | /* empty */ 1852 { 1853 $$ = NULL; 1854 } 1855 ; 1856 1857for_rest_statement: 1858 conditionopt ';' 1859 { 1860 $$.cond = $1; 1861 $$.rest = NULL; 1862 } 1863 | conditionopt ';' expression 1864 { 1865 $$.cond = $1; 1866 $$.rest = $3; 1867 } 1868 ; 1869 1870 // Grammar Note: No 'goto'. Gotos are not supported. 1871jump_statement: 1872 CONTINUE ';' 1873 { 1874 void *ctx = state; 1875 $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_continue, NULL); 1876 $$->set_location(yylloc); 1877 } 1878 | BREAK ';' 1879 { 1880 void *ctx = state; 1881 $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_break, NULL); 1882 $$->set_location(yylloc); 1883 } 1884 | RETURN ';' 1885 { 1886 void *ctx = state; 1887 $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, NULL); 1888 $$->set_location(yylloc); 1889 } 1890 | RETURN expression ';' 1891 { 1892 void *ctx = state; 1893 $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, $2); 1894 $$->set_location(yylloc); 1895 } 1896 | DISCARD ';' // Fragment shader only. 1897 { 1898 void *ctx = state; 1899 $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_discard, NULL); 1900 $$->set_location(yylloc); 1901 } 1902 ; 1903 1904external_declaration: 1905 function_definition { $$ = $1; } 1906 | declaration { $$ = $1; } 1907 | pragma_statement { $$ = NULL; } 1908 | layout_defaults { $$ = NULL; } 1909 ; 1910 1911function_definition: 1912 function_prototype compound_statement_no_new_scope 1913 { 1914 void *ctx = state; 1915 $$ = new(ctx) ast_function_definition(); 1916 $$->set_location(yylloc); 1917 $$->prototype = $1; 1918 $$->body = $2; 1919 1920 state->symbols->pop_scope(); 1921 } 1922 ; 1923 1924/* layout_qualifieropt is packed into this rule */ 1925uniform_block: 1926 UNIFORM NEW_IDENTIFIER '{' member_list '}' ';' 1927 { 1928 void *ctx = state; 1929 $$ = new(ctx) ast_uniform_block(*state->default_uniform_qualifier, 1930 $2, $4); 1931 1932 if (!state->ARB_uniform_buffer_object_enable) { 1933 _mesa_glsl_error(& @1, state, 1934 "#version 140 / GL_ARB_uniform_buffer_object " 1935 "required for defining uniform blocks\n"); 1936 } else if (state->ARB_uniform_buffer_object_warn) { 1937 _mesa_glsl_warning(& @1, state, 1938 "#version 140 / GL_ARB_uniform_buffer_object " 1939 "required for defining uniform blocks\n"); 1940 } 1941 } 1942 | layout_qualifier UNIFORM NEW_IDENTIFIER '{' member_list '}' ';' 1943 { 1944 void *ctx = state; 1945 1946 ast_type_qualifier qual = *state->default_uniform_qualifier; 1947 if (!qual.merge_qualifier(& @1, state, $1)) { 1948 YYERROR; 1949 } 1950 $$ = new(ctx) ast_uniform_block(qual, $3, $5); 1951 1952 if (!state->ARB_uniform_buffer_object_enable) { 1953 _mesa_glsl_error(& @1, state, 1954 "#version 140 / GL_ARB_uniform_buffer_object " 1955 "required for defining uniform blocks\n"); 1956 } else if (state->ARB_uniform_buffer_object_warn) { 1957 _mesa_glsl_warning(& @1, state, 1958 "#version 140 / GL_ARB_uniform_buffer_object " 1959 "required for defining uniform blocks\n"); 1960 } 1961 } 1962 ; 1963 1964member_list: 1965 member_declaration 1966 { 1967 $$ = $1; 1968 $1->link.self_link(); 1969 } 1970 | member_declaration member_list 1971 { 1972 $$ = $1; 1973 $2->link.insert_before(& $$->link); 1974 } 1975 ; 1976 1977/* Specifying "uniform" inside of a uniform block is redundant. */ 1978uniformopt: 1979 /* nothing */ 1980 | UNIFORM 1981 ; 1982 1983member_declaration: 1984 layout_qualifier uniformopt type_specifier struct_declarator_list ';' 1985 { 1986 void *ctx = state; 1987 ast_fully_specified_type *type = new(ctx) ast_fully_specified_type(); 1988 type->set_location(yylloc); 1989 1990 type->qualifier = $1; 1991 type->qualifier.flags.q.uniform = true; 1992 type->specifier = $3; 1993 $$ = new(ctx) ast_declarator_list(type); 1994 $$->set_location(yylloc); 1995 $$->ubo_qualifiers_valid = true; 1996 1997 $$->declarations.push_degenerate_list_at_head(& $4->link); 1998 } 1999 | uniformopt type_specifier struct_declarator_list ';' 2000 { 2001 void *ctx = state; 2002 ast_fully_specified_type *type = new(ctx) ast_fully_specified_type(); 2003 type->set_location(yylloc); 2004 2005 type->qualifier.flags.q.uniform = true; 2006 type->specifier = $2; 2007 $$ = new(ctx) ast_declarator_list(type); 2008 $$->set_location(yylloc); 2009 $$->ubo_qualifiers_valid = true; 2010 2011 $$->declarations.push_degenerate_list_at_head(& $3->link); 2012 } 2013 ; 2014 2015layout_defaults: 2016 layout_qualifier UNIFORM ';' 2017 { 2018 if (!state->default_uniform_qualifier->merge_qualifier(& @1, state, 2019 $1)) { 2020 YYERROR; 2021 } 2022 } 2023