src/libs/glsl/glsl.g

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