1----------------------------------------------------------------------------- 2-- 3-- Copyright (C) 2016 The Qt Company Ltd. 4-- Contact: https://www.qt.io/licensing/ 5-- 6-- This file is part of Qt Creator. 7-- 8-- Commercial License Usage 9-- Licensees holding valid commercial Qt licenses may use this file in 10-- accordance with the commercial license agreement provided with the 11-- Software or, alternatively, in accordance with the terms contained in 12-- a written agreement between you and The Qt Company. For licensing terms 13-- and conditions see https://www.qt.io/terms-conditions. For further 14-- information use the contact form at https://www.qt.io/contact-us. 15-- 16-- GNU General Public License Usage 17-- Alternatively, this file may be used under the terms of the GNU 18-- General Public License version 3 as published by the Free Software 19-- Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT 20-- included in the packaging of this file. Please review the following 21-- information to ensure the GNU General Public License requirements will 22-- be met: https://www.gnu.org/licenses/gpl-3.0.html. 23-- 24----------------------------------------------------------------------------- 25 26%decl glslparser.h 27%impl glslparser.cpp 28%parser GLSLParserTable 29%token_prefix T_ 30%expect 1 31 32%token FEED_GLSL "feed GLSL" 33%token FEED_EXPRESSION "feed expression" 34 35%token ADD_ASSIGN "+=" 36%token AMPERSAND "&" 37%token AND_ASSIGN "&=" 38%token AND_OP "&&" 39%token ATTRIBUTE "attribute" 40%token BANG "!" 41%token BOOL "bool" 42%token BREAK "break" 43%token BVEC2 "bvec2" 44%token BVEC3 "bvec3" 45%token BVEC4 "bvec4" 46%token CARET "^" 47%token CASE "case" 48%token CENTROID "centroid" 49%token COLON ":" 50%token COMMA "," 51%token CONST "const" 52%token CONTINUE "continue" 53%token DASH "-" 54%token DEC_OP "--" 55%token DEFAULT "default" 56%token DISCARD "discard" 57%token DIV_ASSIGN "/=" 58%token DMAT2 "dmat2" 59%token DMAT2X2 "dmat2x2" 60%token DMAT2X3 "dmat2x3" 61%token DMAT2X4 "dmat2x4" 62%token DMAT3 "dmat3" 63%token DMAT3X2 "dmat3x2" 64%token DMAT3X3 "dmat3x3" 65%token DMAT3X4 "dmat3x4" 66%token DMAT4 "dmat4" 67%token DMAT4X2 "dmat4x2" 68%token DMAT4X3 "dmat4x3" 69%token DMAT4X4 "dmat4x4" 70%token DO "do" 71%token DOT "." 72%token DOUBLE "double" 73%token DVEC2 "dvec2" 74%token DVEC3 "dvec3" 75%token DVEC4 "dvec4" 76%token ELSE "else" 77%token EQUAL "=" 78%token EQ_OP "==" 79%token FLAT "flat" 80%token FLOAT "float" 81%token FOR "for" 82%token GE_OP ">=" 83%token HIGHP "highp" 84%token IDENTIFIER "identifier" 85%token IF "if" 86%token IN "in" 87%token INC_OP "++" 88%token INOUT "inout" 89%token INT "int" 90%token INVARIANT "invariant" 91%token ISAMPLER1D "isampler1D" 92%token ISAMPLER1DARRAY "isampler1DArray" 93%token ISAMPLER2D "isampler2D" 94%token ISAMPLER2DARRAY "isampler2DArray" 95%token ISAMPLER2DMS "isampler2DMS" 96%token ISAMPLER2DMSARRAY "isampler2DMSArray" 97%token ISAMPLER2DRECT "isampler2DRect" 98%token ISAMPLER3D "isampler3D" 99%token ISAMPLERBUFFER "isamplerBuffer" 100%token ISAMPLERCUBE "isamplerCube" 101%token ISAMPLERCUBEARRAY "isamplerCubeArray" 102%token IVEC2 "ivec2" 103%token IVEC3 "ivec3" 104%token IVEC4 "ivec4" 105%token LAYOUT "layout" 106%token LEFT_ANGLE "<" 107%token LEFT_ASSIGN "<<=" 108%token LEFT_BRACE "{" 109%token LEFT_BRACKET "[" 110%token LEFT_OP "<<" 111%token LEFT_PAREN "(" 112%token LE_OP "<=" 113%token LOWP "lowp" 114%token MAT2 "mat2" 115%token MAT2X2 "mat2x2" 116%token MAT2X3 "mat2x3" 117%token MAT2X4 "mat2x4" 118%token MAT3 "mat3" 119%token MAT3X2 "mat3x2" 120%token MAT3X3 "mat3x3" 121%token MAT3X4 "mat3x4" 122%token MAT4 "mat4" 123%token MAT4X2 "mat4x2" 124%token MAT4X3 "mat4x3" 125%token MAT4X4 "mat4x4" 126%token MEDIUMP "mediump" 127%token MOD_ASSIGN "%=" 128%token MUL_ASSIGN "*=" 129%token NE_OP "!=" 130%token NOPERSPECTIVE "noperspective" 131%token NUMBER "number constant" 132%token OR_ASSIGN "|=" 133%token OR_OP "||" 134%token OUT "out" 135%token PATCH "patch" 136%token PERCENT "%" 137%token PLUS "plus" 138%token PRECISION "precision" 139%token QUESTION "?" 140%token RETURN "return" 141%token RIGHT_ANGLE ">" 142%token RIGHT_ASSIGN ">>=" 143%token RIGHT_BRACE "}" 144%token RIGHT_BRACKET "]" 145%token RIGHT_OP ">>" 146%token RIGHT_PAREN ")" 147%token SAMPLE "sample" 148%token SAMPLER1D "sampler1D" 149%token SAMPLER1DARRAY "sampler1DArray" 150%token SAMPLER1DARRAYSHADOW "sampler1DArrayShadow" 151%token SAMPLER1DSHADOW "sampler1DShadow" 152%token SAMPLER2D "sampler2D" 153%token SAMPLER2DARRAY "sampler2DArray" 154%token SAMPLER2DARRAYSHADOW "sampler2DArrayShadow" 155%token SAMPLER2DMS "sampler2DMS" 156%token SAMPLER2DMSARRAY "sampler2DMSArray" 157%token SAMPLER2DRECT "sampler2DRect" 158%token SAMPLER2DRECTSHADOW "sampler2DRectShadow" 159%token SAMPLER2DSHADOW "sampler2DShadow" 160%token SAMPLER3D "sampler3D" 161%token SAMPLERBUFFER "samplerBuffer" 162%token SAMPLERCUBE "samplerCube" 163%token SAMPLERCUBEARRAY "samplerCubeArray" 164%token SAMPLERCUBEARRAYSHADOW "samplerCubeArrayShadow" 165%token SAMPLERCUBESHADOW "samplerCubeShadow" 166%token SEMICOLON ";" 167%token SLASH "/" 168%token SMOOTH "smooth" 169%token STAR "*" 170%token STRUCT "struct" 171%token SUBROUTINE "subroutine" 172%token SUB_ASSIGN "-=" 173%token SWITCH "switch" 174%token TILDE "~" 175%token TYPE_NAME "type_name" 176%token UINT "uint" 177%token UNIFORM "uniform" 178%token USAMPLER1D "usampler1D" 179%token USAMPLER1DARRAY "usampler1DArray" 180%token USAMPLER2D "usampler2D" 181%token USAMPLER2DARRAY "usampler2DArray" 182%token USAMPLER2DMS "usampler2DMS" 183%token USAMPLER2DMSARRAY "usampler2DMSarray" 184%token USAMPLER2DRECT "usampler2DRect" 185%token USAMPLER3D "usampler3D" 186%token USAMPLERBUFFER "usamplerBuffer" 187%token USAMPLERCUBE "usamplerCube" 188%token USAMPLERCUBEARRAY "usamplerCubeArray" 189%token UVEC2 "uvec2" 190%token UVEC3 "uvec3" 191%token UVEC4 "uvec4" 192%token VARYING "varying" 193%token VEC2 "vec2" 194%token VEC3 "vec3" 195%token VEC4 "vec4" 196%token VERTICAL_BAR "|" 197%token VOID "void" 198%token WHILE "while" 199%token XOR_ASSIGN "^=" 200%token XOR_OP "^^" 201%token TRUE "true" 202%token FALSE "false" 203%token PREPROC "preprocessor directive" 204%token COMMENT "comment" 205%token ERROR "error" 206%token RESERVED "reserved word" 207 208%start toplevel 209 210/: 211/**************************************************************************** 212** 213** Copyright (C) 2016 The Qt Company Ltd. 214** Contact: https://www.qt.io/licensing/ 215** 216** This file is part of Qt Creator. 217** 218** Commercial License Usage 219** Licensees holding valid commercial Qt licenses may use this file in 220** accordance with the commercial license agreement provided with the 221** Software or, alternatively, in accordance with the terms contained in 222** a written agreement between you and The Qt Company. For licensing terms 223** and conditions see https://www.qt.io/terms-conditions. For further 224** information use the contact form at https://www.qt.io/contact-us. 225** 226** GNU General Public License Usage 227** Alternatively, this file may be used under the terms of the GNU 228** General Public License version 3 as published by the Free Software 229** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT 230** included in the packaging of this file. Please review the following 231** information to ensure the GNU General Public License requirements will 232** be met: https://www.gnu.org/licenses/gpl-3.0.html. 233** 234****************************************************************************/ 235 236#include "$header" 237#include "glsllexer.h" 238#include "glslast.h" 239#include "glslengine.h" 240#include <vector> 241#include <stack> 242 243namespace GLSL { 244 245class GLSL_EXPORT Parser: public $table 246{ 247public: 248 union Value { 249 void *ptr; 250 const QString *string; 251 AST *ast; 252 List<AST *> *ast_list; 253 DeclarationAST *declaration; 254 List<DeclarationAST *> *declaration_list; 255 ExpressionAST *expression; 256 List<ExpressionAST *> *expression_list; 257 StatementAST *statement; 258 List<StatementAST *> *statement_list; 259 TypeAST *type; 260 StructTypeAST::Field *field; 261 List<StructTypeAST::Field *> *field_list; 262 TranslationUnitAST *translation_unit; 263 FunctionIdentifierAST *function_identifier; 264 AST::Kind kind; 265 TypeAST::Precision precision; 266 struct { 267 StatementAST *thenClause; 268 StatementAST *elseClause; 269 } ifstmt; 270 struct { 271 ExpressionAST *condition; 272 ExpressionAST *increment; 273 } forstmt; 274 struct { 275 FunctionIdentifierAST *id; 276 List<ExpressionAST *> *arguments; 277 } function; 278 int qualifier; 279 LayoutQualifierAST *layout; 280 List<LayoutQualifierAST *> *layout_list; 281 struct { 282 int qualifier; 283 List<LayoutQualifierAST *> *layout_list; 284 } type_qualifier; 285 struct { 286 TypeAST *type; 287 const QString *name; 288 } param_declarator; 289 ParameterDeclarationAST *param_declaration; 290 FunctionDeclarationAST *function_declaration; 291 }; 292 293 Parser(Engine *engine, const char *source, unsigned size, int variant); 294 ~Parser(); 295 296 TranslationUnitAST *parse() { 297 if (AST *u = parse(T_FEED_GLSL)) 298 return u->asTranslationUnit(); 299 return 0; 300 } 301 302 ExpressionAST *parseExpression() { 303 if (AST *u = parse(T_FEED_EXPRESSION)) 304 return u->asExpression(); 305 return 0; 306 } 307 308 AST *parse(int startToken); 309 310private: 311 // 1-based 312 int &location(int n) { return _locationStack[_tos + n - 1]; } 313 Value &sym(int n) { return _symStack[_tos + n - 1]; } 314 AST *&ast(int n) { return _symStack[_tos + n - 1].ast; } 315 const QString *&string(int n) { return _symStack[_tos + n - 1].string; } 316 ExpressionAST *&expression(int n) { return _symStack[_tos + n - 1].expression; } 317 StatementAST *&statement(int n) { return _symStack[_tos + n - 1].statement; } 318 TypeAST *&type(int n) { return _symStack[_tos + n - 1].type; } 319 FunctionDeclarationAST *&function(int n) { return _symStack[_tos + n - 1].function_declaration; } 320 321 inline int consumeToken() { 322 if (_index < int(_tokens.size())) 323 return _index++; 324 return static_cast<int>(_tokens.size()) - 1; 325 } 326 inline const Token &tokenAt(int index) const { 327 if (index == 0) 328 return _startToken; 329 return _tokens.at(index); 330 } 331 inline int tokenKind(int index) const { 332 if (index == 0) 333 return _startToken.kind; 334 return _tokens.at(index).kind; 335 } 336 void reduce(int ruleno); 337 338 void warning(int line, const QString &message) 339 { 340 _engine->warning(line, message); 341 } 342 343 void error(int line, const QString &message) 344 { 345 _engine->error(line, message); 346 } 347 348 template <typename T> 349 T *makeAstNode() 350 { 351 T *node = new (_engine->pool()) T (); 352 node->lineno = yyloc >= 0 ? (_tokens[yyloc].line + 1) : 0; 353 return node; 354 } 355 356 template <typename T, typename A1> 357 T *makeAstNode(A1 a1) 358 { 359 T *node = new (_engine->pool()) T (a1); 360 node->lineno = yyloc >= 0 ? (_tokens[yyloc].line + 1) : 0; 361 return node; 362 } 363 364 template <typename T, typename A1, typename A2> 365 T *makeAstNode(A1 a1, A2 a2) 366 { 367 T *node = new (_engine->pool()) T (a1, a2); 368 node->lineno = yyloc >= 0 ? (_tokens[yyloc].line + 1) : 0; 369 return node; 370 } 371 372 template <typename T, typename A1, typename A2, typename A3> 373 T *makeAstNode(A1 a1, A2 a2, A3 a3) 374 { 375 T *node = new (_engine->pool()) T (a1, a2, a3); 376 node->lineno = yyloc >= 0 ? (_tokens[yyloc].line + 1) : 0; 377 return node; 378 } 379 380 template <typename T, typename A1, typename A2, typename A3, typename A4> 381 T *makeAstNode(A1 a1, A2 a2, A3 a3, A4 a4) 382 { 383 T *node = new (_engine->pool()) T (a1, a2, a3, a4); 384 node->lineno = yyloc >= 0 ? (_tokens[yyloc].line + 1) : 0; 385 return node; 386 } 387 388 TypeAST *makeBasicType(int token) 389 { 390 TypeAST *type = new (_engine->pool()) BasicTypeAST(token, spell[token]); 391 type->lineno = yyloc >= 0 ? (_tokens[yyloc].line + 1) : 0; 392 return type; 393 } 394 395private: 396 Engine *_engine; 397 int _tos; 398 int _index; 399 int yyloc; 400 int yytoken; 401 int yyrecovering; 402 bool _recovered; 403 Token _startToken; 404 std::vector<int> _stateStack; 405 std::vector<int> _locationStack; 406 std::vector<Value> _symStack; 407 std::vector<Token> _tokens; 408}; 409 410} // namespace GLSL 411:/ 412 413/. 414/**************************************************************************** 415** 416** Copyright (C) 2016 The Qt Company Ltd. 417** Contact: https://www.qt.io/licensing/ 418** 419** This file is part of Qt Creator. 420** 421** Commercial License Usage 422** Licensees holding valid commercial Qt licenses may use this file in 423** accordance with the commercial license agreement provided with the 424** Software or, alternatively, in accordance with the terms contained in 425** a written agreement between you and The Qt Company. For licensing terms 426** and conditions see https://www.qt.io/terms-conditions. For further 427** information use the contact form at https://www.qt.io/contact-us. 428** 429** GNU General Public License Usage 430** Alternatively, this file may be used under the terms of the GNU 431** General Public License version 3 as published by the Free Software 432** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT 433** included in the packaging of this file. Please review the following 434** information to ensure the GNU General Public License requirements will 435** be met: https://www.gnu.org/licenses/gpl-3.0.html. 436** 437****************************************************************************/ 438 439#include "glslparser.h" 440#include "glslengine.h" 441#include <iostream> 442#include <cstdio> 443#include <cassert> 444#include <QDebug> 445 446using namespace GLSL; 447 448Parser::Parser(Engine *engine, const char *source, unsigned size, int variant) 449 : _engine(engine), _tos(-1), _index(0), yyloc(-1), yytoken(-1), yyrecovering(0), _recovered(false) 450{ 451 _tokens.reserve(1024); 452 453 _stateStack.resize(128); 454 _locationStack.resize(128); 455 _symStack.resize(128); 456 457 _tokens.push_back(Token()); // invalid token 458 459 std::stack<int> parenStack; 460 std::stack<int> bracketStack; 461 std::stack<int> braceStack; 462 463 Lexer lexer(engine, source, size); 464 lexer.setVariant(variant); 465 Token tk; 466 do { 467 lexer.yylex(&tk); 468 469 switch (tk.kind) { 470 case T_LEFT_PAREN: 471 parenStack.push(static_cast<int>(_tokens.size())); 472 break; 473 case T_LEFT_BRACKET: 474 bracketStack.push(static_cast<int>(_tokens.size())); 475 break; 476 case T_LEFT_BRACE: 477 braceStack.push(static_cast<int>(_tokens.size())); 478 break; 479 480 case T_RIGHT_PAREN: 481 if (! parenStack.empty()) { 482 _tokens[parenStack.top()].matchingBrace = static_cast<int>(_tokens.size()); 483 parenStack.pop(); 484 } 485 break; 486 case T_RIGHT_BRACKET: 487 if (! bracketStack.empty()) { 488 _tokens[bracketStack.top()].matchingBrace = static_cast<int>(_tokens.size()); 489 bracketStack.pop(); 490 } 491 break; 492 case T_RIGHT_BRACE: 493 if (! braceStack.empty()) { 494 _tokens[braceStack.top()].matchingBrace = static_cast<int>(_tokens.size()); 495 braceStack.pop(); 496 } 497 break; 498 default: 499 break; 500 } 501 502 _tokens.push_back(tk); 503 } while (tk.isNot(EOF_SYMBOL)); 504 505 _index = 0; 506} 507 508Parser::~Parser() 509{ 510} 511 512AST *Parser::parse(int startToken) 513{ 514 int action = 0; 515 yytoken = -1; 516 yyloc = -1; 517 void *yyval = 0; // value of the current token. 518 519 _recovered = false; 520 _tos = -1; 521 _startToken.kind = startToken; 522 int recoveryAttempts = 0; 523 524 525 do { 526 recoveryAttempts = 0; 527 528 againAfterRecovery: 529 if (unsigned(++_tos) == _stateStack.size()) { 530 _stateStack.resize(_tos * 2); 531 _locationStack.resize(_tos * 2); 532 _symStack.resize(_tos * 2); 533 } 534 535 _stateStack[_tos] = action; 536 537 if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) { 538 yyloc = consumeToken(); 539 yytoken = tokenKind(yyloc); 540 if (yyrecovering) 541 --yyrecovering; 542 if (yytoken == T_IDENTIFIER && t_action(action, T_TYPE_NAME) != 0) { 543 const Token &la = tokenAt(_index); 544 545 if (la.is(T_IDENTIFIER)) { 546 yytoken = T_TYPE_NAME; 547 } else if (la.is(T_LEFT_BRACKET) && la.matchingBrace != 0 && 548 tokenAt(la.matchingBrace + 1).is(T_IDENTIFIER)) { 549 yytoken = T_TYPE_NAME; 550 } 551 } 552 yyval = _tokens.at(yyloc).ptr; 553 } 554 555 action = t_action(action, yytoken); 556 if (action > 0) { 557 if (action == ACCEPT_STATE) { 558 --_tos; 559 return _symStack[0].translation_unit; 560 } 561 _symStack[_tos].ptr = yyval; 562 _locationStack[_tos] = yyloc; 563 yytoken = -1; 564 } else if (action < 0) { 565 const int ruleno = -action - 1; 566 const int N = rhs[ruleno]; 567 _tos -= N; 568 reduce(ruleno); 569 action = nt_action(_stateStack[_tos], lhs[ruleno] - TERMINAL_COUNT); 570 } else if (action == 0) { 571 ++recoveryAttempts; 572 if (recoveryAttempts > 10) 573 break; 574 const int line = _tokens[yyloc].line + 1; 575 QString message = QLatin1String("Syntax error"); 576 if (yytoken != -1) { 577 const QLatin1String s(spell[yytoken]); 578 message = QString::fromLatin1("Unexpected token `%1'").arg(s); 579 if (yytoken == 0) // do not freeze on unexpected end of file 580 return nullptr; 581 } 582 583 for (; _tos; --_tos) { 584 const int state = _stateStack[_tos]; 585 586 static int tks1[] = { 587 T_RIGHT_BRACE, T_RIGHT_PAREN, T_RIGHT_BRACKET, 588 T_SEMICOLON, T_COLON, T_COMMA, 589 T_NUMBER, T_TYPE_NAME, T_IDENTIFIER, 590 T_LEFT_BRACE, T_LEFT_PAREN, T_LEFT_BRACKET, 591 T_WHILE, 592 0 593 }; 594 static int tks2[] = { 595 T_RIGHT_BRACE, T_RIGHT_PAREN, T_RIGHT_BRACKET, 596 T_SEMICOLON, T_COLON, T_COMMA, 597 0 598 }; 599 int *tks; 600 if (recoveryAttempts < 2) 601 tks = tks1; 602 else 603 tks = tks2; // Avoid running into an endless loop for e.g.: for(int x=0; x y 604 605 for (int *tptr = tks; *tptr; ++tptr) { 606 const int next = t_action(state, *tptr); 607 if (next > 0) { 608 if (! yyrecovering && ! _recovered) { 609 _recovered = true; 610 error(line, QString::fromLatin1("Expected `%1'").arg(QLatin1String(spell[*tptr]))); 611 } 612 613 yyrecovering = 3; 614 if (*tptr == T_IDENTIFIER) 615 yyval = (void *) _engine->identifier(QLatin1String("$identifier")); 616 else if (*tptr == T_NUMBER || *tptr == T_TYPE_NAME) 617 yyval = (void *) _engine->identifier(QLatin1String("$0")); 618 else 619 yyval = 0; 620 621 _symStack[_tos].ptr = yyval; 622 _locationStack[_tos] = yyloc; 623 yytoken = -1; 624 625 action = next; 626 goto againAfterRecovery; 627 } 628 } 629 } 630 631 if (! _recovered) { 632 _recovered = true; 633 error(line, message); 634 } 635 } 636 637 } while (action); 638 639 return 0; 640} 641./ 642 643 644 645/. 646void Parser::reduce(int ruleno) 647{ 648switch(ruleno) { 649./ 650 651 652 653variable_identifier ::= IDENTIFIER ; 654/. 655case $rule_number: { 656 ast(1) = makeAstNode<IdentifierExpressionAST>(string(1)); 657} break; 658./ 659 660primary_expression ::= NUMBER ; 661/. 662case $rule_number: { 663 ast(1) = makeAstNode<LiteralExpressionAST>(string(1)); 664} break; 665./ 666 667primary_expression ::= TRUE ; 668/. 669case $rule_number: { 670 ast(1) = makeAstNode<LiteralExpressionAST>(_engine->identifier("true", 4)); 671} break; 672./ 673 674primary_expression ::= FALSE ; 675/. 676case $rule_number: { 677 ast(1) = makeAstNode<LiteralExpressionAST>(_engine->identifier("false", 5)); 678} break; 679./ 680 681primary_expression ::= variable_identifier ; 682/. 683case $rule_number: { 684 // nothing to do. 685} break; 686./ 687 688primary_expression ::= LEFT_PAREN expression RIGHT_PAREN ; 689/. 690case $rule_number: { 691 ast(1) = ast(2); 692} break; 693./ 694 695postfix_expression ::= primary_expression ; 696/. 697case $rule_number: { 698 // nothing to do. 699} break; 700./ 701 702postfix_expression ::= postfix_expression LEFT_BRACKET integer_expression RIGHT_BRACKET ; 703/. 704case $rule_number: { 705 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_ArrayAccess, expression(1), expression(3)); 706} break; 707./ 708 709postfix_expression ::= function_call ; 710/. 711case $rule_number: { 712 // nothing to do. 713} break; 714./ 715 716postfix_expression ::= postfix_expression DOT IDENTIFIER ; 717/. 718case $rule_number: { 719 ast(1) = makeAstNode<MemberAccessExpressionAST>(expression(1), string(3)); 720} break; 721./ 722 723postfix_expression ::= postfix_expression INC_OP ; 724/. 725case $rule_number: { 726 ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PostIncrement, expression(1)); 727} break; 728./ 729 730postfix_expression ::= postfix_expression DEC_OP ; 731/. 732case $rule_number: { 733 ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PostDecrement, expression(1)); 734} break; 735./ 736 737integer_expression ::= expression ; 738/. 739case $rule_number: { 740 // nothing to do. 741} break; 742./ 743 744function_call ::= function_call_or_method ; 745/. 746case $rule_number: { 747 // nothing to do. 748} break; 749./ 750 751function_call_or_method ::= function_call_generic ; 752/. 753case $rule_number: { 754 ast(1) = makeAstNode<FunctionCallExpressionAST> 755 (sym(1).function.id, sym(1).function.arguments); 756} break; 757./ 758 759function_call_or_method ::= postfix_expression DOT function_call_generic ; 760/. 761case $rule_number: { 762 ast(1) = makeAstNode<FunctionCallExpressionAST> 763 (expression(1), sym(3).function.id, sym(3).function.arguments); 764} break; 765./ 766 767function_call_generic ::= function_call_header_with_parameters RIGHT_PAREN ; 768/. 769case $rule_number: { 770 // nothing to do. 771} break; 772./ 773 774function_call_generic ::= function_call_header_no_parameters RIGHT_PAREN ; 775/. 776case $rule_number: { 777 // nothing to do. 778} break; 779./ 780 781function_call_header_no_parameters ::= function_call_header VOID ; 782/. 783case $rule_number: { 784 sym(1).function.id = sym(1).function_identifier; 785 sym(1).function.arguments = 0; 786} break; 787./ 788 789function_call_header_no_parameters ::= function_call_header ; 790/. 791case $rule_number: { 792 sym(1).function.id = sym(1).function_identifier; 793 sym(1).function.arguments = 0; 794} break; 795./ 796 797function_call_header_with_parameters ::= function_call_header assignment_expression ; 798/. 799case $rule_number: { 800 sym(1).function.id = sym(1).function_identifier; 801 sym(1).function.arguments = 802 makeAstNode< List<ExpressionAST *> >(expression(2)); 803} break; 804./ 805 806function_call_header_with_parameters ::= function_call_header_with_parameters COMMA assignment_expression ; 807/. 808case $rule_number: { 809 sym(1).function.arguments = 810 makeAstNode< List<ExpressionAST *> > 811 (sym(1).function.arguments, expression(3)); 812} break; 813./ 814 815function_call_header ::= function_identifier LEFT_PAREN ; 816/. 817case $rule_number: { 818 // nothing to do. 819} break; 820./ 821 822function_identifier ::= type_specifier ; 823/. 824case $rule_number: { 825 ast(1) = makeAstNode<FunctionIdentifierAST>(type(1)); 826} break; 827./ 828 829function_identifier ::= IDENTIFIER ; 830/. 831case $rule_number: { 832 ast(1) = makeAstNode<FunctionIdentifierAST>(string(1)); 833} break; 834./ 835 836unary_expression ::= postfix_expression ; 837/. 838case $rule_number: { 839 // nothing to do. 840} break; 841./ 842 843unary_expression ::= INC_OP unary_expression ; 844/. 845case $rule_number: { 846 ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PreIncrement, expression(2)); 847} break; 848./ 849 850unary_expression ::= DEC_OP unary_expression ; 851/. 852case $rule_number: { 853 ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PreDecrement, expression(2)); 854} break; 855./ 856 857unary_expression ::= unary_operator unary_expression ; 858/. 859case $rule_number: { 860 ast(1) = makeAstNode<UnaryExpressionAST>(sym(1).kind, expression(2)); 861} break; 862./ 863 864unary_operator ::= PLUS ; 865/. 866case $rule_number: { 867 sym(1).kind = AST::Kind_UnaryPlus; 868} break; 869./ 870 871unary_operator ::= DASH ; 872/. 873case $rule_number: { 874 sym(1).kind = AST::Kind_UnaryMinus; 875} break; 876./ 877 878unary_operator ::= BANG ; 879/. 880case $rule_number: { 881 sym(1).kind = AST::Kind_LogicalNot; 882} break; 883./ 884 885unary_operator ::= TILDE ; 886/. 887case $rule_number: { 888 sym(1).kind = AST::Kind_BitwiseNot; 889} break; 890./ 891 892multiplicative_expression ::= unary_expression ; 893/. 894case $rule_number: { 895 // nothing to do. 896} break; 897./ 898 899multiplicative_expression ::= multiplicative_expression STAR unary_expression ; 900/. 901case $rule_number: { 902 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Multiply, expression(1), expression(3)); 903} break; 904./ 905 906multiplicative_expression ::= multiplicative_expression SLASH unary_expression ; 907/. 908case $rule_number: { 909 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Divide, expression(1), expression(3)); 910} break; 911./ 912 913multiplicative_expression ::= multiplicative_expression PERCENT unary_expression ; 914/. 915case $rule_number: { 916 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Modulus, expression(1), expression(3)); 917} break; 918./ 919 920additive_expression ::= multiplicative_expression ; 921/. 922case $rule_number: { 923 // nothing to do. 924} break; 925./ 926 927additive_expression ::= additive_expression PLUS multiplicative_expression ; 928/. 929case $rule_number: { 930 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Plus, expression(1), expression(3)); 931} break; 932./ 933 934additive_expression ::= additive_expression DASH multiplicative_expression ; 935/. 936case $rule_number: { 937 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Minus, expression(1), expression(3)); 938} break; 939./ 940 941shift_expression ::= additive_expression ; 942/. 943case $rule_number: { 944 // nothing to do. 945} break; 946./ 947 948shift_expression ::= shift_expression LEFT_OP additive_expression ; 949/. 950case $rule_number: { 951 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_ShiftLeft, expression(1), expression(3)); 952} break; 953./ 954 955shift_expression ::= shift_expression RIGHT_OP additive_expression ; 956/. 957case $rule_number: { 958 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_ShiftRight, expression(1), expression(3)); 959} break; 960./ 961 962relational_expression ::= shift_expression ; 963/. 964case $rule_number: { 965 // nothing to do. 966} break; 967./ 968 969relational_expression ::= relational_expression LEFT_ANGLE shift_expression ; 970/. 971case $rule_number: { 972 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LessThan, expression(1), expression(3)); 973} break; 974./ 975 976relational_expression ::= relational_expression RIGHT_ANGLE shift_expression ; 977/. 978case $rule_number: { 979 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_GreaterThan, expression(1), expression(3)); 980} break; 981./ 982 983relational_expression ::= relational_expression LE_OP shift_expression ; 984/. 985case $rule_number: { 986 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LessEqual, expression(1), expression(3)); 987} break; 988./ 989 990relational_expression ::= relational_expression GE_OP shift_expression ; 991/. 992case $rule_number: { 993 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_GreaterEqual, expression(1), expression(3)); 994} break; 995./ 996 997equality_expression ::= relational_expression ; 998/. 999case $rule_number: { 1000 // nothing to do. 1001} break; 1002./ 1003 1004equality_expression ::= equality_expression EQ_OP relational_expression ; 1005/. 1006case $rule_number: { 1007 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Equal, expression(1), expression(3)); 1008} break; 1009./ 1010 1011equality_expression ::= equality_expression NE_OP relational_expression ; 1012/. 1013case $rule_number: { 1014 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_NotEqual, expression(1), expression(3)); 1015} break; 1016./ 1017 1018and_expression ::= equality_expression ; 1019/. 1020case $rule_number: { 1021 // nothing to do. 1022} break; 1023./ 1024 1025and_expression ::= and_expression AMPERSAND equality_expression ; 1026/. 1027case $rule_number: { 1028 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_BitwiseAnd, expression(1), expression(3)); 1029} break; 1030./ 1031 1032exclusive_or_expression ::= and_expression ; 1033/. 1034case $rule_number: { 1035 // nothing to do. 1036} break; 1037./ 1038 1039exclusive_or_expression ::= exclusive_or_expression CARET and_expression ; 1040/. 1041case $rule_number: { 1042 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_BitwiseXor, expression(1), expression(3)); 1043} break; 1044./ 1045 1046inclusive_or_expression ::= exclusive_or_expression ; 1047/. 1048case $rule_number: { 1049 // nothing to do. 1050} break; 1051./ 1052 1053inclusive_or_expression ::= inclusive_or_expression VERTICAL_BAR exclusive_or_expression ; 1054/. 1055case $rule_number: { 1056 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_BitwiseOr, expression(1), expression(3)); 1057} break; 1058./ 1059 1060logical_and_expression ::= inclusive_or_expression ; 1061/. 1062case $rule_number: { 1063 // nothing to do. 1064} break; 1065./ 1066 1067logical_and_expression ::= logical_and_expression AND_OP inclusive_or_expression ; 1068/. 1069case $rule_number: { 1070 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LogicalAnd, expression(1), expression(3)); 1071} break; 1072./ 1073 1074logical_xor_expression ::= logical_and_expression ; 1075/. 1076case $rule_number: { 1077 // nothing to do. 1078} break; 1079./ 1080 1081logical_xor_expression ::= logical_xor_expression XOR_OP logical_and_expression ; 1082/. 1083case $rule_number: { 1084 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LogicalXor, expression(1), expression(3)); 1085} break; 1086./ 1087 1088logical_or_expression ::= logical_xor_expression ; 1089/. 1090case $rule_number: { 1091 // nothing to do. 1092} break; 1093./ 1094 1095logical_or_expression ::= logical_or_expression OR_OP logical_xor_expression ; 1096/. 1097case $rule_number: { 1098 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LogicalOr, expression(1), expression(3)); 1099} break; 1100./ 1101 1102conditional_expression ::= logical_or_expression ; 1103/. 1104case $rule_number: { 1105 // nothing to do. 1106} break; 1107./ 1108 1109conditional_expression ::= logical_or_expression QUESTION expression COLON assignment_expression ; 1110/. 1111case $rule_number: { 1112 ast(1) = makeAstNode<TernaryExpressionAST>(AST::Kind_Conditional, expression(1), expression(3), expression(5)); 1113} break; 1114./ 1115 1116assignment_expression ::= conditional_expression ; 1117/. 1118case $rule_number: { 1119 // nothing to do. 1120} break; 1121./ 1122 1123assignment_expression ::= unary_expression assignment_operator assignment_expression ; 1124/. 1125case $rule_number: { 1126 ast(1) = makeAstNode<AssignmentExpressionAST>(sym(2).kind, expression(1), expression(3)); 1127} break; 1128./ 1129 1130assignment_operator ::= EQUAL ; 1131/. 1132case $rule_number: { 1133 sym(1).kind = AST::Kind_Assign; 1134} break; 1135./ 1136 1137assignment_operator ::= MUL_ASSIGN ; 1138/. 1139case $rule_number: { 1140 sym(1).kind = AST::Kind_AssignMultiply; 1141} break; 1142./ 1143 1144assignment_operator ::= DIV_ASSIGN ; 1145/. 1146case $rule_number: { 1147 sym(1).kind = AST::Kind_AssignDivide; 1148} break; 1149./ 1150 1151assignment_operator ::= MOD_ASSIGN ; 1152/. 1153case $rule_number: { 1154 sym(1).kind = AST::Kind_AssignModulus; 1155} break; 1156./ 1157 1158assignment_operator ::= ADD_ASSIGN ; 1159/. 1160case $rule_number: { 1161 sym(1).kind = AST::Kind_AssignPlus; 1162} break; 1163./ 1164 1165assignment_operator ::= SUB_ASSIGN ; 1166/. 1167case $rule_number: { 1168 sym(1).kind = AST::Kind_AssignMinus; 1169} break; 1170./ 1171 1172assignment_operator ::= LEFT_ASSIGN ; 1173/. 1174case $rule_number: { 1175 sym(1).kind = AST::Kind_AssignShiftLeft; 1176} break; 1177./ 1178 1179assignment_operator ::= RIGHT_ASSIGN ; 1180/. 1181case $rule_number: { 1182 sym(1).kind = AST::Kind_AssignShiftRight; 1183} break; 1184./ 1185 1186assignment_operator ::= AND_ASSIGN ; 1187/. 1188case $rule_number: { 1189 sym(1).kind = AST::Kind_AssignAnd; 1190} break; 1191./ 1192 1193assignment_operator ::= XOR_ASSIGN ; 1194/. 1195case $rule_number: { 1196 sym(1).kind = AST::Kind_AssignXor; 1197} break; 1198./ 1199 1200assignment_operator ::= OR_ASSIGN ; 1201/. 1202case $rule_number: { 1203 sym(1).kind = AST::Kind_AssignOr; 1204} break; 1205./ 1206 1207expression ::= assignment_expression ; 1208/. 1209case $rule_number: { 1210 // nothing to do. 1211} break; 1212./ 1213 1214expression ::= expression COMMA assignment_expression ; 1215/. 1216case $rule_number: { 1217 ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Comma, expression(1), expression(3)); 1218} break; 1219./ 1220 1221constant_expression ::= conditional_expression ; 1222/. 1223case $rule_number: { 1224 // nothing to do. 1225} break; 1226./ 1227 1228declaration ::= function_prototype SEMICOLON ; 1229/. 1230case $rule_number: { 1231 // nothing to do. 1232} break; 1233./ 1234 1235declaration ::= init_declarator_list SEMICOLON ; 1236/. 1237case $rule_number: { 1238 ast(1) = makeAstNode<InitDeclarationAST>(sym(1).declaration_list); 1239} break; 1240./ 1241 1242declaration ::= PRECISION precision_qualifier type_specifier_no_prec SEMICOLON ; 1243/. 1244case $rule_number: { 1245 ast(1) = makeAstNode<PrecisionDeclarationAST>(sym(2).precision, type(3)); 1246} break; 1247./ 1248 1249declaration ::= type_qualifier IDENTIFIER LEFT_BRACE struct_declaration_list RIGHT_BRACE SEMICOLON ; 1250/. 1251case $rule_number: { 1252 if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) { 1253 // TODO: issue an error if the qualifier is not "struct". 1254 } 1255 TypeAST *type = makeAstNode<StructTypeAST>(string(2), sym(4).field_list); 1256 ast(1) = makeAstNode<TypeDeclarationAST>(type); 1257} break; 1258./ 1259 1260declaration ::= type_qualifier IDENTIFIER LEFT_BRACE struct_declaration_list RIGHT_BRACE IDENTIFIER SEMICOLON ; 1261/. 1262case $rule_number: { 1263 if ((sym(1).type_qualifier.qualifier & QualifiedTypeAST::Struct) == 0) { 1264 // TODO: issue an error if the qualifier does not contain "struct". 1265 } 1266 TypeAST *type = makeAstNode<StructTypeAST>(string(2), sym(4).field_list); 1267 TypeAST *qualtype = type; 1268 if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) { 1269 qualtype = makeAstNode<QualifiedTypeAST> 1270 (sym(1).type_qualifier.qualifier & ~QualifiedTypeAST::Struct, qualtype, 1271 sym(1).type_qualifier.layout_list); 1272 } 1273 ast(1) = makeAstNode<TypeAndVariableDeclarationAST> 1274 (makeAstNode<TypeDeclarationAST>(type), 1275 makeAstNode<VariableDeclarationAST>(qualtype, string(6))); 1276} break; 1277./ 1278 1279declaration ::= type_qualifier IDENTIFIER LEFT_BRACE struct_declaration_list RIGHT_BRACE IDENTIFIER LEFT_BRACKET RIGHT_BRACKET SEMICOLON ; 1280/. 1281case $rule_number: { 1282 if ((sym(1).type_qualifier.qualifier & QualifiedTypeAST::Struct) == 0) { 1283 // TODO: issue an error if the qualifier does not contain "struct". 1284 } 1285 TypeAST *type = makeAstNode<StructTypeAST>(string(2), sym(4).field_list); 1286 TypeAST *qualtype = type; 1287 if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) { 1288 qualtype = makeAstNode<QualifiedTypeAST> 1289 (sym(1).type_qualifier.qualifier & ~QualifiedTypeAST::Struct, qualtype, 1290 sym(1).type_qualifier.layout_list); 1291 } 1292 ast(1) = makeAstNode<TypeAndVariableDeclarationAST> 1293 (makeAstNode<TypeDeclarationAST>(type), 1294 makeAstNode<VariableDeclarationAST> 1295 (makeAstNode<ArrayTypeAST>(qualtype), string(6))); 1296} break; 1297./ 1298 1299declaration ::= type_qualifier IDENTIFIER LEFT_BRACE struct_declaration_list RIGHT_BRACE IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET SEMICOLON ; 1300/. 1301case $rule_number: { 1302 if ((sym(1).type_qualifier.qualifier & QualifiedTypeAST::Struct) == 0) { 1303 // TODO: issue an error if the qualifier does not contain "struct". 1304 } 1305 TypeAST *type = makeAstNode<StructTypeAST>(string(2), sym(4).field_list); 1306 TypeAST *qualtype = type; 1307 if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) { 1308 qualtype = makeAstNode<QualifiedTypeAST> 1309 (sym(1).type_qualifier.qualifier & ~QualifiedTypeAST::Struct, qualtype, 1310 sym(1).type_qualifier.layout_list); 1311 } 1312 ast(1) = makeAstNode<TypeAndVariableDeclarationAST> 1313 (makeAstNode<TypeDeclarationAST>(type), 1314 makeAstNode<VariableDeclarationAST> 1315 (makeAstNode<ArrayTypeAST>(qualtype, expression(8)), string(6))); 1316} break; 1317./ 1318 1319declaration ::= type_qualifier SEMICOLON ; 1320/. 1321case $rule_number: { 1322 TypeAST *type = makeAstNode<QualifiedTypeAST> 1323 (sym(1).type_qualifier.qualifier, (TypeAST *)0, 1324 sym(1).type_qualifier.layout_list); 1325 ast(1) = makeAstNode<TypeDeclarationAST>(type); 1326} break; 1327./ 1328 1329function_prototype ::= function_declarator RIGHT_PAREN ; 1330/. 1331case $rule_number: { 1332 function(1)->finishParams(); 1333} break; 1334./ 1335 1336function_declarator ::= function_header ; 1337/. 1338case $rule_number: { 1339 // nothing to do. 1340} break; 1341./ 1342 1343function_declarator ::= function_header_with_parameters ; 1344/. 1345case $rule_number: { 1346 // nothing to do. 1347} break; 1348./ 1349 1350function_header_with_parameters ::= function_header parameter_declaration ; 1351/. 1352case $rule_number: { 1353 function(1)->params = makeAstNode< List<ParameterDeclarationAST *> > 1354 (sym(2).param_declaration); 1355} break; 1356./ 1357 1358function_header_with_parameters ::= function_header_with_parameters COMMA parameter_declaration ; 1359/. 1360case $rule_number: { 1361 function(1)->params = makeAstNode< List<ParameterDeclarationAST *> > 1362 (function(1)->params, sym(3).param_declaration); 1363} break; 1364./ 1365 1366function_header ::= fully_specified_type IDENTIFIER LEFT_PAREN ; 1367/. 1368case $rule_number: { 1369 function(1) = makeAstNode<FunctionDeclarationAST>(type(1), string(2)); 1370} break; 1371./ 1372 1373parameter_declarator ::= type_specifier IDENTIFIER ; 1374/. 1375case $rule_number: { 1376 sym(1).param_declarator.type = type(1); 1377 sym(1).param_declarator.name = string(2); 1378} break; 1379./ 1380 1381parameter_declarator ::= type_specifier IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET ; 1382/. 1383case $rule_number: { 1384 sym(1).param_declarator.type = makeAstNode<ArrayTypeAST>(type(1), expression(4)); 1385 sym(1).param_declarator.name = string(2); 1386} break; 1387./ 1388 1389parameter_declaration ::= parameter_type_qualifier parameter_qualifier parameter_declarator ; 1390/. 1391case $rule_number: { 1392 ast(1) = makeAstNode<ParameterDeclarationAST> 1393 (makeAstNode<QualifiedTypeAST> 1394 (sym(1).qualifier, sym(3).param_declarator.type, 1395 (List<LayoutQualifierAST *> *)0), 1396 ParameterDeclarationAST::Qualifier(sym(2).qualifier), 1397 sym(3).param_declarator.name); 1398} break; 1399./ 1400 1401parameter_declaration ::= parameter_qualifier parameter_declarator ; 1402/. 1403case $rule_number: { 1404 ast(1) = makeAstNode<ParameterDeclarationAST> 1405 (sym(2).param_declarator.type, 1406 ParameterDeclarationAST::Qualifier(sym(1).qualifier), 1407 sym(2).param_declarator.name); 1408} break; 1409./ 1410 1411parameter_declaration ::= parameter_type_qualifier parameter_qualifier parameter_type_specifier ; 1412/. 1413case $rule_number: { 1414 ast(1) = makeAstNode<ParameterDeclarationAST> 1415 (makeAstNode<QualifiedTypeAST> 1416 (sym(1).qualifier, type(3), (List<LayoutQualifierAST *> *)0), 1417 ParameterDeclarationAST::Qualifier(sym(2).qualifier), 1418 (const QString *)0); 1419} break; 1420./ 1421 1422parameter_declaration ::= parameter_qualifier parameter_type_specifier ; 1423/. 1424case $rule_number: { 1425 ast(1) = makeAstNode<ParameterDeclarationAST> 1426 (type(2), ParameterDeclarationAST::Qualifier(sym(1).qualifier), 1427 (const QString *)0); 1428} break; 1429./ 1430 1431parameter_qualifier ::= empty ; 1432/. 1433case $rule_number: { 1434 sym(1).qualifier = ParameterDeclarationAST::In; 1435} break; 1436./ 1437 1438parameter_qualifier ::= IN ; 1439/. 1440case $rule_number: { 1441 sym(1).qualifier = ParameterDeclarationAST::In; 1442} break; 1443./ 1444 1445parameter_qualifier ::= OUT ; 1446/. 1447case $rule_number: { 1448 sym(1).qualifier = ParameterDeclarationAST::Out; 1449} break; 1450./ 1451 1452parameter_qualifier ::= INOUT ; 1453/. 1454case $rule_number: { 1455 sym(1).qualifier = ParameterDeclarationAST::InOut; 1456} break; 1457./ 1458 1459parameter_type_specifier ::= type_specifier ; 1460/. 1461case $rule_number: { 1462 // nothing to do. 1463} break; 1464./ 1465 1466init_declarator_list ::= single_declaration ; 1467/. 1468case $rule_number: { 1469 sym(1).declaration_list = makeAstNode< List<DeclarationAST *> > 1470 (sym(1).declaration); 1471} break; 1472./ 1473 1474init_declarator_list ::= init_declarator_list COMMA IDENTIFIER ; 1475/. 1476case $rule_number: { 1477 TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list); 1478 DeclarationAST *decl = makeAstNode<VariableDeclarationAST>(type, string(3)); 1479 sym(1).declaration_list = makeAstNode< List<DeclarationAST *> > 1480 (sym(1).declaration_list, decl); 1481} break; 1482./ 1483 1484init_declarator_list ::= init_declarator_list COMMA IDENTIFIER LEFT_BRACKET RIGHT_BRACKET ; 1485/. 1486case $rule_number: { 1487 TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list); 1488 type = makeAstNode<ArrayTypeAST>(type); 1489 DeclarationAST *decl = makeAstNode<VariableDeclarationAST>(type, string(3)); 1490 sym(1).declaration_list = makeAstNode< List<DeclarationAST *> > 1491 (sym(1).declaration_list, decl); 1492} break; 1493./ 1494 1495init_declarator_list ::= init_declarator_list COMMA IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET ; 1496/. 1497case $rule_number: { 1498 TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list); 1499 type = makeAstNode<ArrayTypeAST>(type, expression(5)); 1500 DeclarationAST *decl = makeAstNode<VariableDeclarationAST>(type, string(3)); 1501 sym(1).declaration_list = makeAstNode< List<DeclarationAST *> > 1502 (sym(1).declaration_list, decl); 1503} break; 1504./ 1505 1506init_declarator_list ::= init_declarator_list COMMA IDENTIFIER LEFT_BRACKET RIGHT_BRACKET EQUAL initializer ; 1507/. 1508case $rule_number: { 1509 TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list); 1510 type = makeAstNode<ArrayTypeAST>(type); 1511 DeclarationAST *decl = makeAstNode<VariableDeclarationAST> 1512 (type, string(3), expression(7)); 1513 sym(1).declaration_list = makeAstNode< List<DeclarationAST *> > 1514 (sym(1).declaration_list, decl); 1515} break; 1516./ 1517 1518init_declarator_list ::= init_declarator_list COMMA IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET EQUAL initializer ; 1519/. 1520case $rule_number: { 1521 TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list); 1522 type = makeAstNode<ArrayTypeAST>(type, expression(5)); 1523 DeclarationAST *decl = makeAstNode<VariableDeclarationAST> 1524 (type, string(3), expression(8)); 1525 sym(1).declaration_list = makeAstNode< List<DeclarationAST *> > 1526 (sym(1).declaration_list, decl); 1527} break; 1528./ 1529 1530init_declarator_list ::= init_declarator_list COMMA IDENTIFIER EQUAL initializer ; 1531/. 1532case $rule_number: { 1533 TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list); 1534 DeclarationAST *decl = makeAstNode<VariableDeclarationAST> 1535 (type, string(3), expression(5)); 1536 sym(1).declaration_list = makeAstNode< List<DeclarationAST *> > 1537 (sym(1).declaration_list, decl); 1538} break; 1539./ 1540 1541single_declaration ::= fully_specified_type ; 1542/. 1543case $rule_number: { 1544 ast(1) = makeAstNode<TypeDeclarationAST>(type(1)); 1545} break; 1546./ 1547 1548single_declaration ::= fully_specified_type IDENTIFIER ; 1549/. 1550case $rule_number: { 1551 ast(1) = makeAstNode<VariableDeclarationAST>(type(1), string(2)); 1552} break; 1553./ 1554 1555single_declaration ::= fully_specified_type IDENTIFIER LEFT_BRACKET RIGHT_BRACKET ; 1556/. 1557case $rule_number: { 1558 ast(1) = makeAstNode<VariableDeclarationAST> 1559 (makeAstNode<ArrayTypeAST>(type(1)), string(2)); 1560} break; 1561./ 1562 1563single_declaration ::= fully_specified_type IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET ; 1564/. 1565case $rule_number: { 1566 ast(1) = makeAstNode<VariableDeclarationAST> 1567 (makeAstNode<ArrayTypeAST>(type(1), expression(4)), string(2)); 1568} break; 1569./ 1570 1571single_declaration ::= fully_specified_type IDENTIFIER LEFT_BRACKET RIGHT_BRACKET EQUAL initializer ; 1572/. 1573case $rule_number: { 1574 ast(1) = makeAstNode<VariableDeclarationAST> 1575 (makeAstNode<ArrayTypeAST>(type(1)), string(2), expression(6)); 1576} break; 1577./ 1578 1579single_declaration ::= fully_specified_type IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET EQUAL initializer ; 1580/. 1581case $rule_number: { 1582 ast(1) = makeAstNode<VariableDeclarationAST> 1583 (makeAstNode<ArrayTypeAST>(type(1), expression(4)), 1584 string(2), expression(7)); 1585} break; 1586./ 1587 1588single_declaration ::= fully_specified_type IDENTIFIER EQUAL initializer ; 1589/. 1590case $rule_number: { 1591 ast(1) = makeAstNode<VariableDeclarationAST> 1592 (type(1), string(2), expression(4)); 1593} break; 1594./ 1595 1596single_declaration ::= INVARIANT IDENTIFIER ; 1597/. 1598case $rule_number: { 1599 ast(1) = makeAstNode<InvariantDeclarationAST>(string(2)); 1600} break; 1601./ 1602 1603fully_specified_type ::= type_specifier ; 1604/. 1605case $rule_number: { 1606 ast(1) = makeAstNode<QualifiedTypeAST>(0, type(1), (List<LayoutQualifierAST *> *)0); 1607} break; 1608./ 1609 1610fully_specified_type ::= type_qualifier type_specifier ; 1611/. 1612case $rule_number: { 1613 ast(1) = makeAstNode<QualifiedTypeAST> 1614 (sym(1).type_qualifier.qualifier, type(2), 1615 sym(1).type_qualifier.layout_list); 1616} break; 1617./ 1618 1619invariant_qualifier ::= INVARIANT ; 1620/. 1621case $rule_number: { 1622 sym(1).qualifier = QualifiedTypeAST::Invariant; 1623} break; 1624./ 1625 1626interpolation_qualifier ::= SMOOTH ; 1627/. 1628case $rule_number: { 1629 sym(1).qualifier = QualifiedTypeAST::Smooth; 1630} break; 1631./ 1632 1633interpolation_qualifier ::= FLAT ; 1634/. 1635case $rule_number: { 1636 sym(1).qualifier = QualifiedTypeAST::Flat; 1637} break; 1638./ 1639 1640interpolation_qualifier ::= NOPERSPECTIVE ; 1641/. 1642case $rule_number: { 1643 sym(1).qualifier = QualifiedTypeAST::NoPerspective; 1644} break; 1645./ 1646 1647layout_qualifier ::= LAYOUT LEFT_PAREN layout_qualifier_id_list RIGHT_PAREN ; 1648/. 1649case $rule_number: { 1650 sym(1) = sym(3); 1651} break; 1652./ 1653 1654layout_qualifier_id_list ::= layout_qualifier_id ; 1655/. 1656case $rule_number: { 1657 sym(1).layout_list = makeAstNode< List<LayoutQualifierAST *> >(sym(1).layout); 1658} break; 1659./ 1660 1661layout_qualifier_id_list ::= layout_qualifier_id_list COMMA layout_qualifier_id ; 1662/. 1663case $rule_number: { 1664 sym(1).layout_list = makeAstNode< List<LayoutQualifierAST *> >(sym(1).layout_list, sym(3).layout); 1665} break; 1666./ 1667 1668layout_qualifier_id ::= IDENTIFIER ; 1669/. 1670case $rule_number: { 1671 sym(1).layout = makeAstNode<LayoutQualifierAST>(string(1), (const QString *)0); 1672} break; 1673./ 1674 1675layout_qualifier_id ::= IDENTIFIER EQUAL NUMBER ; 1676/. 1677case $rule_number: { 1678 sym(1).layout = makeAstNode<LayoutQualifierAST>(string(1), string(3)); 1679} break; 1680./ 1681 1682parameter_type_qualifier ::= CONST ; 1683/. 1684case $rule_number: { 1685 sym(1).qualifier = QualifiedTypeAST::Const; 1686} break; 1687./ 1688 1689type_qualifier ::= storage_qualifier ; 1690/. 1691case $rule_number: { 1692 sym(1).type_qualifier.qualifier = sym(1).qualifier; 1693 sym(1).type_qualifier.layout_list = 0; 1694} break; 1695./ 1696 1697type_qualifier ::= layout_qualifier ; 1698/. 1699case $rule_number: { 1700 sym(1).type_qualifier.layout_list = sym(1).layout_list; 1701 sym(1).type_qualifier.qualifier = 0; 1702} break; 1703./ 1704 1705type_qualifier ::= layout_qualifier storage_qualifier ; 1706/. 1707case $rule_number: { 1708 sym(1).type_qualifier.layout_list = sym(1).layout_list; 1709 sym(1).type_qualifier.qualifier = sym(2).qualifier; 1710} break; 1711./ 1712 1713type_qualifier ::= interpolation_qualifier storage_qualifier ; 1714/. 1715case $rule_number: { 1716 sym(1).type_qualifier.qualifier = sym(1).qualifier | sym(2).qualifier; 1717 sym(1).type_qualifier.layout_list = 0; 1718} break; 1719./ 1720 1721type_qualifier ::= interpolation_qualifier ; 1722/. 1723case $rule_number: { 1724 sym(1).type_qualifier.qualifier = sym(1).qualifier; 1725 sym(1).type_qualifier.layout_list = 0; 1726} break; 1727./ 1728 1729type_qualifier ::= invariant_qualifier storage_qualifier ; 1730/. 1731case $rule_number: { 1732 sym(1).type_qualifier.qualifier = sym(1).qualifier | sym(2).qualifier; 1733 sym(1).type_qualifier.layout_list = 0; 1734} break; 1735./ 1736 1737type_qualifier ::= invariant_qualifier interpolation_qualifier storage_qualifier ; 1738/. 1739case $rule_number: { 1740 sym(1).type_qualifier.qualifier = sym(1).qualifier | sym(2).qualifier | sym(3).qualifier; 1741 sym(1).type_qualifier.layout_list = 0; 1742} break; 1743./ 1744 1745type_qualifier ::= INVARIANT ; 1746/. 1747case $rule_number: { 1748 sym(1).type_qualifier.qualifier = QualifiedTypeAST::Invariant; 1749 sym(1).type_qualifier.layout_list = 0; 1750} break; 1751./ 1752 1753storage_qualifier ::= CONST ; 1754/. 1755case $rule_number: { 1756 sym(1).qualifier = QualifiedTypeAST::Const; 1757} break; 1758./ 1759 1760storage_qualifier ::= ATTRIBUTE ; 1761/. 1762case $rule_number: { 1763 sym(1).qualifier = QualifiedTypeAST::Attribute; 1764} break; 1765./ 1766 1767storage_qualifier ::= VARYING ; 1768/. 1769case $rule_number: { 1770 sym(1).qualifier = QualifiedTypeAST::Varying; 1771} break; 1772./ 1773 1774storage_qualifier ::= CENTROID VARYING ; 1775/. 1776case $rule_number: { 1777 sym(1).qualifier = QualifiedTypeAST::CentroidVarying; 1778} break; 1779./ 1780 1781storage_qualifier ::= IN ; 1782/. 1783case $rule_number: { 1784 sym(1).qualifier = QualifiedTypeAST::In; 1785} break; 1786./ 1787 1788storage_qualifier ::= OUT ; 1789/. 1790case $rule_number: { 1791 sym(1).qualifier = QualifiedTypeAST::Out; 1792} break; 1793./ 1794 1795storage_qualifier ::= CENTROID IN ; 1796/. 1797case $rule_number: { 1798 sym(1).qualifier = QualifiedTypeAST::CentroidIn; 1799} break; 1800./ 1801 1802storage_qualifier ::= CENTROID OUT ; 1803/. 1804case $rule_number: { 1805 sym(1).qualifier = QualifiedTypeAST::CentroidOut; 1806} break; 1807./ 1808 1809storage_qualifier ::= PATCH IN ; 1810/. 1811case $rule_number: { 1812 sym(1).qualifier = QualifiedTypeAST::PatchIn; 1813} break; 1814./ 1815 1816storage_qualifier ::= PATCH OUT ; 1817/. 1818case $rule_number: { 1819 sym(1).qualifier = QualifiedTypeAST::PatchOut; 1820} break; 1821./ 1822 1823storage_qualifier ::= SAMPLE IN ; 1824/. 1825case $rule_number: { 1826 sym(1).qualifier = QualifiedTypeAST::SampleIn; 1827} break; 1828./ 1829 1830storage_qualifier ::= SAMPLE OUT ; 1831/. 1832case $rule_number: { 1833 sym(1).qualifier = QualifiedTypeAST::SampleOut; 1834} break; 1835./ 1836 1837storage_qualifier ::= UNIFORM ; 1838/. 1839case $rule_number: { 1840 sym(1).qualifier = QualifiedTypeAST::Uniform; 1841} break; 1842./ 1843 1844type_specifier ::= type_specifier_no_prec ; 1845/. 1846case $rule_number: { 1847 // nothing to do. 1848} break; 1849./ 1850 1851type_specifier ::= precision_qualifier type_specifier_no_prec ; 1852/. 1853case $rule_number: { 1854 if (!type(2)->setPrecision(sym(1).precision)) { 1855 // TODO: issue an error about precision not allowed on this type. 1856 } 1857 ast(1) = type(2); 1858} break; 1859./ 1860 1861type_specifier_no_prec ::= type_specifier_nonarray ; 1862/. 1863case $rule_number: { 1864 // nothing to do. 1865} break; 1866./ 1867 1868type_specifier_no_prec ::= type_specifier_nonarray LEFT_BRACKET RIGHT_BRACKET ; 1869/. 1870case $rule_number: { 1871 ast(1) = makeAstNode<ArrayTypeAST>(type(1)); 1872} break; 1873./ 1874 1875type_specifier_no_prec ::= type_specifier_nonarray LEFT_BRACKET constant_expression RIGHT_BRACKET ; 1876/. 1877case $rule_number: { 1878 ast(1) = makeAstNode<ArrayTypeAST>(type(1), expression(3)); 1879} break; 1880./ 1881 1882type_specifier_nonarray ::= VOID ; 1883/. 1884case $rule_number: { 1885 ast(1) = makeBasicType(T_VOID); 1886} break; 1887./ 1888 1889type_specifier_nonarray ::= FLOAT ; 1890/. 1891case $rule_number: { 1892 ast(1) = makeBasicType(T_FLOAT); 1893} break; 1894./ 1895 1896type_specifier_nonarray ::= DOUBLE ; 1897/. 1898case $rule_number: { 1899 ast(1) = makeBasicType(T_DOUBLE); 1900} break; 1901./ 1902 1903type_specifier_nonarray ::= INT ; 1904/. 1905case $rule_number: { 1906 ast(1) = makeBasicType(T_INT); 1907} break; 1908./ 1909 1910type_specifier_nonarray ::= UINT ; 1911/. 1912case $rule_number: { 1913 ast(1) = makeBasicType(T_UINT); 1914} break; 1915./ 1916 1917type_specifier_nonarray ::= BOOL ; 1918/. 1919case $rule_number: { 1920 ast(1) = makeBasicType(T_BOOL); 1921} break; 1922./ 1923 1924type_specifier_nonarray ::= VEC2 ; 1925/. 1926case $rule_number: { 1927 ast(1) = makeBasicType(T_VEC2); 1928} break; 1929./ 1930 1931type_specifier_nonarray ::= VEC3 ; 1932/. 1933case $rule_number: { 1934 ast(1) = makeBasicType(T_VEC3); 1935} break; 1936./ 1937 1938type_specifier_nonarray ::= VEC4 ; 1939/. 1940case $rule_number: { 1941 ast(1) = makeBasicType(T_VEC4); 1942} break; 1943./ 1944 1945type_specifier_nonarray ::= DVEC2 ; 1946/. 1947case $rule_number: { 1948 ast(1) = makeBasicType(T_DVEC2); 1949} break; 1950./ 1951 1952type_specifier_nonarray ::= DVEC3 ; 1953/. 1954case $rule_number: { 1955 ast(1) = makeBasicType(T_DVEC3); 1956} break; 1957./ 1958 1959type_specifier_nonarray ::= DVEC4 ; 1960/. 1961case $rule_number: { 1962 ast(1) = makeBasicType(T_DVEC4); 1963} break; 1964./ 1965 1966type_specifier_nonarray ::= BVEC2 ; 1967/. 1968case $rule_number: { 1969 ast(1) = makeBasicType(T_BVEC2); 1970} break; 1971./ 1972 1973type_specifier_nonarray ::= BVEC3 ; 1974/. 1975case $rule_number: { 1976 ast(1) = makeBasicType(T_BVEC3); 1977} break; 1978./ 1979 1980type_specifier_nonarray ::= BVEC4 ; 1981/. 1982case $rule_number: { 1983 ast(1) = makeBasicType(T_BVEC4); 1984} break; 1985./ 1986 1987type_specifier_nonarray ::= IVEC2 ; 1988/. 1989case $rule_number: { 1990 ast(1) = makeBasicType(T_IVEC2); 1991} break; 1992./ 1993 1994type_specifier_nonarray ::= IVEC3 ; 1995/. 1996case $rule_number: { 1997 ast(1) = makeBasicType(T_IVEC3); 1998} break; 1999./ 2000 2001type_specifier_nonarray ::= IVEC4 ; 2002/. 2003case $rule_number: { 2004 ast(1) = makeBasicType(T_IVEC4); 2005} break; 2006./ 2007 2008type_specifier_nonarray ::= UVEC2 ; 2009/. 2010case $rule_number: { 2011 ast(1) = makeBasicType(T_UVEC2); 2012} break; 2013./ 2014 2015type_specifier_nonarray ::= UVEC3 ; 2016/. 2017case $rule_number: { 2018 ast(1) = makeBasicType(T_UVEC3); 2019} break; 2020./ 2021 2022type_specifier_nonarray ::= UVEC4 ; 2023/. 2024case $rule_number: { 2025 ast(1) = makeBasicType(T_UVEC4); 2026} break; 2027./ 2028 2029type_specifier_nonarray ::= MAT2 ; 2030/. 2031case $rule_number: { 2032 ast(1) = makeBasicType(T_MAT2); 2033} break; 2034./ 2035 2036type_specifier_nonarray ::= MAT3 ; 2037/. 2038case $rule_number: { 2039 ast(1) = makeBasicType(T_MAT3); 2040} break; 2041./ 2042 2043type_specifier_nonarray ::= MAT4 ; 2044/. 2045case $rule_number: { 2046 ast(1) = makeBasicType(T_MAT4); 2047} break; 2048./ 2049 2050type_specifier_nonarray ::= MAT2X2 ; 2051/. 2052case $rule_number: { 2053 ast(1) = makeBasicType(T_MAT2); 2054} break; 2055./ 2056 2057type_specifier_nonarray ::= MAT2X3 ; 2058/. 2059case $rule_number: { 2060 ast(1) = makeBasicType(T_MAT2X3); 2061} break; 2062./ 2063 2064type_specifier_nonarray ::= MAT2X4 ; 2065/. 2066case $rule_number: { 2067 ast(1) = makeBasicType(T_MAT2X4); 2068} break; 2069./ 2070 2071type_specifier_nonarray ::= MAT3X2 ; 2072/. 2073case $rule_number: { 2074 ast(1) = makeBasicType(T_MAT3X2); 2075} break; 2076./ 2077 2078type_specifier_nonarray ::= MAT3X3 ; 2079/. 2080case $rule_number: { 2081 ast(1) = makeBasicType(T_MAT3); 2082} break; 2083./ 2084 2085type_specifier_nonarray ::= MAT3X4 ; 2086/. 2087case $rule_number: { 2088 ast(1) = makeBasicType(T_MAT3X4); 2089} break; 2090./ 2091 2092type_specifier_nonarray ::= MAT4X2 ; 2093/. 2094case $rule_number: { 2095 ast(1) = makeBasicType(T_MAT4X2); 2096} break; 2097./ 2098 2099type_specifier_nonarray ::= MAT4X3 ; 2100/. 2101case $rule_number: { 2102 ast(1) = makeBasicType(T_MAT4X3); 2103} break; 2104./ 2105 2106type_specifier_nonarray ::= MAT4X4 ; 2107/. 2108case $rule_number: { 2109 ast(1) = makeBasicType(T_MAT4); 2110} break; 2111./ 2112 2113type_specifier_nonarray ::= DMAT2 ; 2114/. 2115case $rule_number: { 2116 ast(1) = makeBasicType(T_DMAT2); 2117} break; 2118./ 2119 2120type_specifier_nonarray ::= DMAT3 ; 2121/. 2122case $rule_number: { 2123 ast(1) = makeBasicType(T_DMAT3); 2124} break; 2125./ 2126 2127type_specifier_nonarray ::= DMAT4 ; 2128/. 2129case $rule_number: { 2130 ast(1) = makeBasicType(T_DMAT4); 2131} break; 2132./ 2133 2134type_specifier_nonarray ::= DMAT2X2 ; 2135/. 2136case $rule_number: { 2137 ast(1) = makeBasicType(T_DMAT2); 2138} break; 2139./ 2140 2141type_specifier_nonarray ::= DMAT2X3 ; 2142/. 2143case $rule_number: { 2144 ast(1) = makeBasicType(T_DMAT2X3); 2145} break; 2146./ 2147 2148type_specifier_nonarray ::= DMAT2X4 ; 2149/. 2150case $rule_number: { 2151 ast(1) = makeBasicType(T_DMAT2X4); 2152} break; 2153./ 2154 2155type_specifier_nonarray ::= DMAT3X2 ; 2156/. 2157case $rule_number: { 2158 ast(1) = makeBasicType(T_DMAT3X2); 2159} break; 2160./ 2161 2162type_specifier_nonarray ::= DMAT3X3 ; 2163/. 2164case $rule_number: { 2165 ast(1) = makeBasicType(T_DMAT3); 2166} break; 2167./ 2168 2169type_specifier_nonarray ::= DMAT3X4 ; 2170/. 2171case $rule_number: { 2172 ast(1) = makeBasicType(T_DMAT3X4); 2173} break; 2174./ 2175 2176type_specifier_nonarray ::= DMAT4X2 ; 2177/. 2178case $rule_number: { 2179 ast(1) = makeBasicType(T_DMAT4X2); 2180} break; 2181./ 2182 2183type_specifier_nonarray ::= DMAT4X3 ; 2184/. 2185case $rule_number: { 2186 ast(1) = makeBasicType(T_DMAT4X3); 2187} break; 2188./ 2189 2190type_specifier_nonarray ::= DMAT4X4 ; 2191/. 2192case $rule_number: { 2193 ast(1) = makeBasicType(T_DMAT4); 2194} break; 2195./ 2196 2197type_specifier_nonarray ::= SAMPLER1D ; 2198/. 2199case $rule_number: { 2200 ast(1) = makeBasicType(T_SAMPLER1D); 2201} break; 2202./ 2203 2204type_specifier_nonarray ::= SAMPLER2D ; 2205/. 2206case $rule_number: { 2207 ast(1) = makeBasicType(T_SAMPLER2D); 2208} break; 2209./ 2210 2211type_specifier_nonarray ::= SAMPLER3D ; 2212/. 2213case $rule_number: { 2214 ast(1) = makeBasicType(T_SAMPLER3D); 2215} break; 2216./ 2217 2218type_specifier_nonarray ::= SAMPLERCUBE ; 2219/. 2220case $rule_number: { 2221 ast(1) = makeBasicType(T_SAMPLERCUBE); 2222} break; 2223./ 2224 2225type_specifier_nonarray ::= SAMPLER1DSHADOW ; 2226/. 2227case $rule_number: { 2228 ast(1) = makeBasicType(T_SAMPLER1DSHADOW); 2229} break; 2230./ 2231 2232type_specifier_nonarray ::= SAMPLER2DSHADOW ; 2233/. 2234case $rule_number: { 2235 ast(1) = makeBasicType(T_SAMPLER2DSHADOW); 2236} break; 2237./ 2238 2239type_specifier_nonarray ::= SAMPLERCUBESHADOW ; 2240/. 2241case $rule_number: { 2242 ast(1) = makeBasicType(T_SAMPLERCUBESHADOW); 2243} break; 2244./ 2245 2246type_specifier_nonarray ::= SAMPLER1DARRAY ; 2247/. 2248case $rule_number: { 2249 ast(1) = makeBasicType(T_SAMPLER1DARRAY); 2250} break; 2251./ 2252 2253type_specifier_nonarray ::= SAMPLER2DARRAY ; 2254/. 2255case $rule_number: { 2256 ast(1) = makeBasicType(T_SAMPLER2DARRAY); 2257} break; 2258./ 2259 2260type_specifier_nonarray ::= SAMPLER1DARRAYSHADOW ; 2261/. 2262case $rule_number: { 2263 ast(1) = makeBasicType(T_SAMPLER1DARRAYSHADOW); 2264} break; 2265./ 2266 2267type_specifier_nonarray ::= SAMPLER2DARRAYSHADOW ; 2268/. 2269case $rule_number: { 2270 ast(1) = makeBasicType(T_SAMPLER2DARRAYSHADOW); 2271} break; 2272./ 2273 2274type_specifier_nonarray ::= SAMPLERCUBEARRAY ; 2275/. 2276case $rule_number: { 2277 ast(1) = makeBasicType(T_SAMPLERCUBEARRAY); 2278} break; 2279./ 2280 2281type_specifier_nonarray ::= SAMPLERCUBEARRAYSHADOW ; 2282/. 2283case $rule_number: { 2284 ast(1) = makeBasicType(T_SAMPLERCUBEARRAYSHADOW); 2285} break; 2286./ 2287 2288type_specifier_nonarray ::= ISAMPLER1D ; 2289/. 2290case $rule_number: { 2291 ast(1) = makeBasicType(T_ISAMPLER1D); 2292} break; 2293./ 2294 2295type_specifier_nonarray ::= ISAMPLER2D ; 2296/. 2297case $rule_number: { 2298 ast(1) = makeBasicType(T_ISAMPLER2D); 2299} break; 2300./ 2301 2302type_specifier_nonarray ::= ISAMPLER3D ; 2303/. 2304case $rule_number: { 2305 ast(1) = makeBasicType(T_ISAMPLER3D); 2306} break; 2307./ 2308 2309type_specifier_nonarray ::= ISAMPLERCUBE ; 2310/. 2311case $rule_number: { 2312 ast(1) = makeBasicType(T_ISAMPLERCUBE); 2313} break; 2314./ 2315 2316type_specifier_nonarray ::= ISAMPLER1DARRAY ; 2317/. 2318case $rule_number: { 2319 ast(1) = makeBasicType(T_ISAMPLER1DARRAY); 2320} break; 2321./ 2322 2323type_specifier_nonarray ::= ISAMPLER2DARRAY ; 2324/. 2325case $rule_number: { 2326 ast(1) = makeBasicType(T_ISAMPLER2DARRAY); 2327} break; 2328./ 2329 2330type_specifier_nonarray ::= ISAMPLERCUBEARRAY ; 2331/. 2332case $rule_number: { 2333 ast(1) = makeBasicType(T_ISAMPLERCUBEARRAY); 2334} break; 2335./ 2336 2337type_specifier_nonarray ::= USAMPLER1D ; 2338/. 2339case $rule_number: { 2340 ast(1) = makeBasicType(T_USAMPLER1D); 2341} break; 2342./ 2343 2344type_specifier_nonarray ::= USAMPLER2D ; 2345/. 2346case $rule_number: { 2347 ast(1) = makeBasicType(T_USAMPLER2D); 2348} break; 2349./ 2350 2351type_specifier_nonarray ::= USAMPLER3D ; 2352/. 2353case $rule_number: { 2354 ast(1) = makeBasicType(T_USAMPLER3D); 2355} break; 2356./ 2357 2358type_specifier_nonarray ::= USAMPLERCUBE ; 2359/. 2360case $rule_number: { 2361 ast(1) = makeBasicType(T_USAMPLERCUBE); 2362} break; 2363./ 2364 2365type_specifier_nonarray ::= USAMPLER1DARRAY ; 2366/. 2367case $rule_number: { 2368 ast(1) = makeBasicType(T_USAMPLER1DARRAY); 2369} break; 2370./ 2371 2372type_specifier_nonarray ::= USAMPLER2DARRAY ; 2373/. 2374case $rule_number: { 2375 ast(1) = makeBasicType(T_USAMPLER2DARRAY); 2376} break; 2377./ 2378 2379type_specifier_nonarray ::= USAMPLERCUBEARRAY ; 2380/. 2381case $rule_number: { 2382 ast(1) = makeBasicType(T_USAMPLERCUBEARRAY); 2383} break; 2384./ 2385 2386type_specifier_nonarray ::= SAMPLER2DRECT ; 2387/. 2388case $rule_number: { 2389 ast(1) = makeBasicType(T_SAMPLER2DRECT); 2390} break; 2391./ 2392 2393type_specifier_nonarray ::= SAMPLER2DRECTSHADOW ; 2394/. 2395case $rule_number: { 2396 ast(1) = makeBasicType(T_SAMPLER2DRECTSHADOW); 2397} break; 2398./ 2399 2400type_specifier_nonarray ::= ISAMPLER2DRECT ; 2401/. 2402case $rule_number: { 2403 ast(1) = makeBasicType(T_ISAMPLER2DRECT); 2404} break; 2405./ 2406 2407type_specifier_nonarray ::= USAMPLER2DRECT ; 2408/. 2409case $rule_number: { 2410 ast(1) = makeBasicType(T_USAMPLER2DRECT); 2411} break; 2412./ 2413 2414type_specifier_nonarray ::= SAMPLERBUFFER ; 2415/. 2416case $rule_number: { 2417 ast(1) = makeBasicType(T_SAMPLERBUFFER); 2418} break; 2419./ 2420 2421type_specifier_nonarray ::= ISAMPLERBUFFER ; 2422/. 2423case $rule_number: { 2424 ast(1) = makeBasicType(T_ISAMPLERBUFFER); 2425} break; 2426./ 2427 2428type_specifier_nonarray ::= USAMPLERBUFFER ; 2429/. 2430case $rule_number: { 2431 ast(1) = makeBasicType(T_USAMPLERBUFFER); 2432} break; 2433./ 2434 2435type_specifier_nonarray ::= SAMPLER2DMS ; 2436/. 2437case $rule_number: { 2438 ast(1) = makeBasicType(T_SAMPLER2DMS); 2439} break; 2440./ 2441 2442type_specifier_nonarray ::= ISAMPLER2DMS ; 2443/. 2444case $rule_number: { 2445 ast(1) = makeBasicType(T_ISAMPLER2DMS); 2446} break; 2447./ 2448 2449type_specifier_nonarray ::= USAMPLER2DMS ; 2450/. 2451case $rule_number: { 2452 ast(1) = makeBasicType(T_USAMPLER2DMS); 2453} break; 2454./ 2455 2456type_specifier_nonarray ::= SAMPLER2DMSARRAY ; 2457/. 2458case $rule_number: { 2459 ast(1) = makeBasicType(T_SAMPLER2DMSARRAY); 2460} break; 2461./ 2462 2463type_specifier_nonarray ::= ISAMPLER2DMSARRAY ; 2464/. 2465case $rule_number: { 2466 ast(1) = makeBasicType(T_ISAMPLER2DMSARRAY); 2467} break; 2468./ 2469 2470type_specifier_nonarray ::= USAMPLER2DMSARRAY ; 2471/. 2472case $rule_number: { 2473 ast(1) = makeBasicType(T_USAMPLER2DMSARRAY); 2474} break; 2475./ 2476 2477type_specifier_nonarray ::= struct_specifier ; 2478/. 2479case $rule_number: { 2480 // nothing to do. 2481} break; 2482./ 2483 2484type_specifier_nonarray ::= TYPE_NAME ; 2485/. 2486case $rule_number: { 2487 ast(1) = makeAstNode<NamedTypeAST>(string(1)); 2488} break; 2489./ 2490 2491precision_qualifier ::= HIGHP ; 2492/. 2493case $rule_number: { 2494 sym(1).precision = TypeAST::Highp; 2495} break; 2496./ 2497 2498precision_qualifier ::= MEDIUMP ; 2499/. 2500case $rule_number: { 2501 sym(1).precision = TypeAST::Mediump; 2502} break; 2503./ 2504 2505precision_qualifier ::= LOWP ; 2506/. 2507case $rule_number: { 2508 sym(1).precision = TypeAST::Lowp; 2509} break; 2510./ 2511 2512struct_specifier ::= STRUCT IDENTIFIER LEFT_BRACE struct_declaration_list RIGHT_BRACE ; 2513/. 2514case $rule_number: { 2515 ast(1) = makeAstNode<StructTypeAST>(string(2), sym(4).field_list); 2516} break; 2517./ 2518 2519struct_specifier ::= STRUCT LEFT_BRACE struct_declaration_list RIGHT_BRACE ; 2520/. 2521case $rule_number: { 2522 ast(1) = makeAstNode<StructTypeAST>(sym(3).field_list); 2523} break; 2524./ 2525 2526struct_declaration_list ::= struct_declaration ; 2527/. 2528case $rule_number: { 2529 // nothing to do. 2530} break; 2531./ 2532 2533struct_declaration_list ::= struct_declaration_list struct_declaration ; 2534/. 2535case $rule_number: { 2536 sym(1).field_list = appendLists(sym(1).field_list, sym(2).field_list); 2537} break; 2538./ 2539 2540struct_declaration ::= type_specifier struct_declarator_list SEMICOLON ; 2541/. 2542case $rule_number: { 2543 sym(1).field_list = StructTypeAST::fixInnerTypes(type(1), sym(2).field_list); 2544} break; 2545./ 2546 2547struct_declaration ::= type_qualifier type_specifier struct_declarator_list SEMICOLON ; 2548/. 2549case $rule_number: { 2550 sym(1).field_list = StructTypeAST::fixInnerTypes 2551 (makeAstNode<QualifiedTypeAST> 2552 (sym(1).type_qualifier.qualifier, type(2), 2553 sym(1).type_qualifier.layout_list), sym(3).field_list); 2554} break; 2555./ 2556 2557struct_declarator_list ::= struct_declarator ; 2558/. 2559case $rule_number: { 2560 // nothing to do. 2561 sym(1).field_list = makeAstNode< List<StructTypeAST::Field *> >(sym(1).field); 2562} break; 2563./ 2564 2565struct_declarator_list ::= struct_declarator_list COMMA struct_declarator ; 2566/. 2567case $rule_number: { 2568 sym(1).field_list = makeAstNode< List<StructTypeAST::Field *> >(sym(1).field_list, sym(3).field); 2569} break; 2570./ 2571 2572struct_declarator ::= IDENTIFIER ; 2573/. 2574case $rule_number: { 2575 sym(1).field = makeAstNode<StructTypeAST::Field>(string(1)); 2576} break; 2577./ 2578 2579struct_declarator ::= IDENTIFIER LEFT_BRACKET RIGHT_BRACKET ; 2580/. 2581case $rule_number: { 2582 sym(1).field = makeAstNode<StructTypeAST::Field> 2583 (string(1), makeAstNode<ArrayTypeAST>((TypeAST *)0)); 2584} break; 2585./ 2586 2587struct_declarator ::= IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET ; 2588/. 2589case $rule_number: { 2590 sym(1).field = makeAstNode<StructTypeAST::Field> 2591 (string(1), makeAstNode<ArrayTypeAST>((TypeAST *)0, expression(3))); 2592} break; 2593./ 2594 2595initializer ::= assignment_expression ; 2596/. 2597case $rule_number: { 2598 // nothing to do. 2599} break; 2600./ 2601 2602declaration_statement ::= declaration ; 2603/. 2604case $rule_number: { 2605 ast(1) = makeAstNode<DeclarationStatementAST>(sym(1).declaration); 2606} break; 2607./ 2608 2609statement ::= compound_statement ; 2610/. 2611case $rule_number: { 2612 // nothing to do. 2613} break; 2614./ 2615 2616statement ::= simple_statement ; 2617/. 2618case $rule_number: { 2619 // nothing to do. 2620} break; 2621./ 2622 2623simple_statement ::= declaration_statement ; 2624/. 2625case $rule_number: { 2626 // nothing to do. 2627} break; 2628./ 2629 2630simple_statement ::= expression_statement ; 2631/. 2632case $rule_number: { 2633 // nothing to do. 2634} break; 2635./ 2636 2637simple_statement ::= selection_statement ; 2638/. 2639case $rule_number: { 2640 // nothing to do. 2641} break; 2642./ 2643 2644simple_statement ::= switch_statement ; 2645/. 2646case $rule_number: { 2647 // nothing to do. 2648} break; 2649./ 2650 2651simple_statement ::= case_label ; 2652/. 2653case $rule_number: { 2654 // nothing to do. 2655} break; 2656./ 2657 2658simple_statement ::= iteration_statement ; 2659/. 2660case $rule_number: { 2661 // nothing to do. 2662} break; 2663./ 2664 2665simple_statement ::= jump_statement ; 2666/. 2667case $rule_number: { 2668 // nothing to do. 2669} break; 2670./ 2671 2672compound_statement ::= LEFT_BRACE RIGHT_BRACE ; 2673/. 2674case $rule_number: { 2675 CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>(); 2676 stmt->start = tokenAt(location(1)).begin(); 2677 stmt->end = tokenAt(location(2)).end(); 2678 ast(1) = stmt; 2679} break; 2680./ 2681 2682compound_statement ::= LEFT_BRACE statement_list RIGHT_BRACE ; 2683/. 2684case $rule_number: { 2685 CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>(sym(2).statement_list); 2686 stmt->start = tokenAt(location(1)).begin(); 2687 stmt->end = tokenAt(location(3)).end(); 2688 ast(1) = stmt; 2689} break; 2690./ 2691 2692statement_no_new_scope ::= compound_statement_no_new_scope ; 2693/. 2694case $rule_number: { 2695 // nothing to do. 2696} break; 2697./ 2698 2699statement_no_new_scope ::= simple_statement ; 2700/. 2701case $rule_number: { 2702 // nothing to do. 2703} break; 2704./ 2705 2706compound_statement_no_new_scope ::= LEFT_BRACE RIGHT_BRACE ; 2707/. 2708case $rule_number: { 2709 CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>(); 2710 stmt->start = tokenAt(location(1)).begin(); 2711 stmt->end = tokenAt(location(2)).end(); 2712 ast(1) = stmt; 2713} break; 2714./ 2715 2716compound_statement_no_new_scope ::= LEFT_BRACE statement_list RIGHT_BRACE ; 2717/. 2718case $rule_number: { 2719 CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>(sym(2).statement_list); 2720 stmt->start = tokenAt(location(1)).begin(); 2721 stmt->end = tokenAt(location(3)).end(); 2722 ast(1) = stmt; 2723} break; 2724./ 2725 2726statement_list ::= statement ; 2727/. 2728case $rule_number: { 2729 sym(1).statement_list = makeAstNode< List<StatementAST *> >(sym(1).statement); 2730} break; 2731./ 2732 2733statement_list ::= statement_list statement ; 2734/. 2735case $rule_number: { 2736 sym(1).statement_list = makeAstNode< List<StatementAST *> >(sym(1).statement_list, sym(2).statement); 2737} break; 2738./ 2739 2740expression_statement ::= SEMICOLON ; 2741/. 2742case $rule_number: { 2743 ast(1) = makeAstNode<CompoundStatementAST>(); // Empty statement 2744} break; 2745./ 2746 2747expression_statement ::= expression SEMICOLON ; 2748/. 2749case $rule_number: { 2750 ast(1) = makeAstNode<ExpressionStatementAST>(expression(1)); 2751} break; 2752./ 2753 2754selection_statement ::= IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement ; 2755/. 2756case $rule_number: { 2757 ast(1) = makeAstNode<IfStatementAST>(expression(3), sym(5).ifstmt.thenClause, sym(5).ifstmt.elseClause); 2758} break; 2759./ 2760 2761selection_rest_statement ::= statement ELSE statement ; 2762/. 2763case $rule_number: { 2764 sym(1).ifstmt.thenClause = statement(1); 2765 sym(1).ifstmt.elseClause = statement(3); 2766} break; 2767./ 2768 2769selection_rest_statement ::= statement ; 2770/. 2771case $rule_number: { 2772 sym(1).ifstmt.thenClause = statement(1); 2773 sym(1).ifstmt.elseClause = 0; 2774} break; 2775./ 2776 2777condition ::= expression ; 2778/. 2779case $rule_number: { 2780 // nothing to do. 2781} break; 2782./ 2783 2784condition ::= fully_specified_type IDENTIFIER EQUAL initializer ; 2785/. 2786case $rule_number: { 2787 ast(1) = makeAstNode<DeclarationExpressionAST> 2788 (type(1), string(2), expression(4)); 2789} break; 2790./ 2791 2792switch_statement ::= SWITCH LEFT_PAREN expression RIGHT_PAREN LEFT_BRACE switch_statement_list RIGHT_BRACE ; 2793/. 2794case $rule_number: { 2795 ast(1) = makeAstNode<SwitchStatementAST>(expression(3), statement(6)); 2796} break; 2797./ 2798 2799switch_statement_list ::= empty ; 2800/. 2801case $rule_number: { 2802 ast(1) = makeAstNode<CompoundStatementAST>(); 2803} break; 2804./ 2805 2806switch_statement_list ::= statement_list ; 2807/. 2808case $rule_number: { 2809 ast(1) = makeAstNode<CompoundStatementAST>(sym(1).statement_list); 2810} break; 2811./ 2812 2813case_label ::= CASE expression COLON ; 2814/. 2815case $rule_number: { 2816 ast(1) = makeAstNode<CaseLabelStatementAST>(expression(2)); 2817} break; 2818./ 2819 2820case_label ::= DEFAULT COLON ; 2821/. 2822case $rule_number: { 2823 ast(1) = makeAstNode<CaseLabelStatementAST>(); 2824} break; 2825./ 2826 2827iteration_statement ::= WHILE LEFT_PAREN condition RIGHT_PAREN statement_no_new_scope ; 2828/. 2829case $rule_number: { 2830 ast(1) = makeAstNode<WhileStatementAST>(expression(3), statement(5)); 2831} break; 2832./ 2833 2834iteration_statement ::= DO statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON ; 2835/. 2836case $rule_number: { 2837 ast(1) = makeAstNode<DoStatementAST>(statement(2), expression(5)); 2838} break; 2839./ 2840 2841iteration_statement ::= FOR LEFT_PAREN for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope ; 2842/. 2843case $rule_number: { 2844 ast(1) = makeAstNode<ForStatementAST>(statement(3), sym(4).forstmt.condition, sym(4).forstmt.increment, statement(6)); 2845} break; 2846./ 2847 2848for_init_statement ::= expression_statement ; 2849/. 2850case $rule_number: { 2851 // nothing to do. 2852} break; 2853./ 2854 2855for_init_statement ::= declaration_statement ; 2856/. 2857case $rule_number: { 2858 // nothing to do. 2859} break; 2860./ 2861 2862conditionopt ::= empty ; 2863/. 2864case $rule_number: { 2865 // nothing to do. 2866} break; 2867./ 2868 2869conditionopt ::= condition ; 2870/. 2871case $rule_number: { 2872 // nothing to do. 2873} break; 2874./ 2875 2876for_rest_statement ::= conditionopt SEMICOLON ; 2877/. 2878case $rule_number: { 2879 sym(1).forstmt.condition = expression(1); 2880 sym(1).forstmt.increment = 0; 2881} break; 2882./ 2883 2884for_rest_statement ::= conditionopt SEMICOLON expression ; 2885/. 2886case $rule_number: { 2887 sym(1).forstmt.condition = expression(1); 2888 sym(1).forstmt.increment = expression(3); 2889} break; 2890./ 2891 2892jump_statement ::= CONTINUE SEMICOLON ; 2893/. 2894case $rule_number: { 2895 ast(1) = makeAstNode<JumpStatementAST>(AST::Kind_Continue); 2896} break; 2897./ 2898 2899jump_statement ::= BREAK SEMICOLON ; 2900/. 2901case $rule_number: { 2902 ast(1) = makeAstNode<JumpStatementAST>(AST::Kind_Break); 2903} break; 2904./ 2905 2906jump_statement ::= RETURN SEMICOLON ; 2907/. 2908case $rule_number: { 2909 ast(1) = makeAstNode<ReturnStatementAST>(); 2910} break; 2911./ 2912 2913jump_statement ::= RETURN expression SEMICOLON ; 2914/. 2915case $rule_number: { 2916 ast(1) = makeAstNode<ReturnStatementAST>(expression(2)); 2917} break; 2918./ 2919 2920jump_statement ::= DISCARD SEMICOLON ; 2921/. 2922case $rule_number: { 2923 ast(1) = makeAstNode<JumpStatementAST>(AST::Kind_Discard); 2924} break; 2925./ 2926 2927translation_unit ::= external_declaration_list ; 2928/. 2929case $rule_number: { 2930 ast(1) = makeAstNode<TranslationUnitAST>(sym(1).declaration_list); 2931} break; 2932./ 2933 2934external_declaration_list ::= external_declaration ; 2935/. 2936case $rule_number: { 2937 if (sym(1).declaration) { 2938 sym(1).declaration_list = makeAstNode< List<DeclarationAST *> > 2939 (sym(1).declaration); 2940 } else { 2941 sym(1).declaration_list = 0; 2942 } 2943} break; 2944./ 2945 2946external_declaration_list ::= external_declaration_list external_declaration ; 2947/. 2948case $rule_number: { 2949 if (sym(1).declaration_list && sym(2).declaration) { 2950 sym(1).declaration_list = makeAstNode< List<DeclarationAST *> > 2951 (sym(1).declaration_list, sym(2).declaration); 2952 } else if (!sym(1).declaration_list) { 2953 if (sym(2).declaration) { 2954 sym(1).declaration_list = makeAstNode< List<DeclarationAST *> > 2955 (sym(2).declaration); 2956 } else { 2957 sym(1).declaration_list = 0; 2958 } 2959 } 2960} break; 2961./ 2962 2963external_declaration ::= function_definition ; 2964/. 2965case $rule_number: { 2966 // nothing to do. 2967} break; 2968./ 2969 2970external_declaration ::= declaration ; 2971/. 2972case $rule_number: { 2973 // nothing to do. 2974} break; 2975./ 2976 2977external_declaration ::= SEMICOLON ; 2978/. 2979case $rule_number: { 2980 ast(1) = 0; 2981} break; 2982./ 2983 2984function_definition ::= function_prototype compound_statement_no_new_scope ; 2985/. 2986case $rule_number: { 2987 function(1)->body = statement(2); 2988} break; 2989./ 2990 2991empty ::= ; 2992/. 2993case $rule_number: { 2994 ast(1) = 0; 2995} break; 2996./ 2997 2998 2999toplevel ::= FEED_GLSL translation_unit ; 3000/. 3001case $rule_number: { 3002 ast(1) = ast(2); 3003} break; 3004./ 3005 3006toplevel ::= FEED_EXPRESSION expression ; 3007/. 3008case $rule_number: { 3009 ast(1) = ast(2); 3010} break; 3011./ 3012 3013/. 3014} // end switch 3015} // end Parser::reduce() 3016./ 3017