src/libs/glsl/glslparser.cpp

   1
   2 #line 420 "./glsl.g"
   3
   4 /**************************************************************************
   5 **
   6 ** This file is part of Qt Creator
   7 **
   8 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
   9 **
  10 ** Contact: Nokia Corporation (qt-info@nokia.com)
  11 **
  12 ** No Commercial Usage
  13 **
  14 ** This file contains pre-release code and may not be distributed.
  15 ** You may use this file in accordance with the terms and conditions
  16 ** contained in the Technology Preview License Agreement accompanying
  17 ** this package.
  18 **
  19 ** GNU Lesser General Public License Usage
  20 **
  21 ** Alternatively, this file may be used under the terms of the GNU Lesser
  22 ** General Public License version 2.1 as published by the Free Software
  23 ** Foundation and appearing in the file LICENSE.LGPL included in the
  24 ** packaging of this file.  Please review the following information to
  25 ** ensure the GNU Lesser General Public License version 2.1 requirements
  26 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  27 **
  28 ** In addition, as a special exception, Nokia gives you certain additional
  29 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  30 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  31 **
  32 ** If you have questions regarding the use of this file, please contact
  33 ** Nokia at qt-info@nokia.com.
  34 **
  35 **************************************************************************/
  36
  37 #include "glslparser.h"
  38 #include "glslengine.h"
  39 #include <iostream>
  40 #include <cstdio>
  41 #include <cassert>
  42 #include <QtCore/QDebug>
  43
  44 using namespace GLSL;
  45
  46 Parser::Parser(Engine *engine, const char *source, unsigned size, int variant)
  47     : _engine(engine), _tos(-1), _index(0), yyloc(-1), yytoken(-1), yyrecovering(0), _recovered(false)
  48 {
  49     _tokens.reserve(1024);
  50
  51     _stateStack.resize(128);
  52     _locationStack.resize(128);
  53     _symStack.resize(128);
  54
  55     _tokens.push_back(Token()); // invalid token
  56
  57     std::stack<int> parenStack;
  58     std::stack<int> bracketStack;
  59     std::stack<int> braceStack;
  60
  61     Lexer lexer(engine, source, size);
  62     lexer.setVariant(variant);
  63     Token tk;
  64     do {
  65         lexer.yylex(&tk);
  66
  67         switch (tk.kind) {
  68         case T_LEFT_PAREN:
  69             parenStack.push(_tokens.size());
  70             break;
  71         case T_LEFT_BRACKET:
  72             bracketStack.push(_tokens.size());
  73             break;
  74         case T_LEFT_BRACE:
  75             braceStack.push(_tokens.size());
  76             break;
  77
  78         case T_RIGHT_PAREN:
  79             if (! parenStack.empty()) {
  80                 _tokens[parenStack.top()].matchingBrace = _tokens.size();
  81                 parenStack.pop();
  82             }
  83             break;
  84         case T_RIGHT_BRACKET:
  85             if (! bracketStack.empty()) {
  86                 _tokens[bracketStack.top()].matchingBrace = _tokens.size();
  87                 bracketStack.pop();
  88             }
  89             break;
  90         case T_RIGHT_BRACE:
  91             if (! braceStack.empty()) {
  92                 _tokens[braceStack.top()].matchingBrace = _tokens.size();
  93                 braceStack.pop();
  94             }
  95             break;
  96         default:
  97             break;
  98         }
  99
 100         _tokens.push_back(tk);
 101     } while (tk.isNot(EOF_SYMBOL));
 102
 103     _index = 0;
 104 }
 105
 106 Parser::~Parser()
 107 {
 108 }
 109
 110 AST *Parser::parse(int startToken)
 111 {
 112     int action = 0;
 113     yytoken = -1;
 114     yyloc = -1;
 115     void *yyval = 0; // value of the current token.
 116
 117     _recovered = false;
 118     _tos = -1;
 119     _startToken.kind = startToken;
 120
 121     do {
 122     again:
 123         if (unsigned(++_tos) == _stateStack.size()) {
 124             _stateStack.resize(_tos * 2);
 125             _locationStack.resize(_tos * 2);
 126             _symStack.resize(_tos * 2);
 127         }
 128
 129         _stateStack[_tos] = action;
 130
 131         if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) {
 132             yyloc = consumeToken();
 133             yytoken = tokenKind(yyloc);
 134             if (yyrecovering)
 135                 --yyrecovering;
 136             if (yytoken == T_IDENTIFIER && t_action(action, T_TYPE_NAME) != 0) {
 137                 const Token &la = tokenAt(_index);
 138
 139                 if (la.is(T_IDENTIFIER)) {
 140                     yytoken = T_TYPE_NAME;
 141                 } else if (la.is(T_LEFT_BRACKET) && la.matchingBrace != 0 &&
 142                            tokenAt(la.matchingBrace + 1).is(T_IDENTIFIER)) {
 143                     yytoken = T_TYPE_NAME;
 144                 }
 145             }
 146             yyval = _tokens.at(yyloc).ptr;
 147         }
 148
 149         action = t_action(action, yytoken);
 150         if (action > 0) {
 151             if (action == ACCEPT_STATE) {
 152                 --_tos;
 153                 return _symStack[0].translation_unit;
 154             }
 155             _symStack[_tos].ptr = yyval;
 156             _locationStack[_tos] = yyloc;
 157             yytoken = -1;
 158         } else if (action < 0) {
 159             const int ruleno = -action - 1;
 160             const int N = rhs[ruleno];
 161             _tos -= N;
 162             reduce(ruleno);
 163             action = nt_action(_stateStack[_tos], lhs[ruleno] - TERMINAL_COUNT);
 164         } else if (action == 0) {
 165             const int line = _tokens[yyloc].line + 1;
 166             QString message = QLatin1String("Syntax error");
 167             if (yytoken != -1) {
 168                 const QLatin1String s(spell[yytoken]);
 169                 message = QString("Unexpected token `%1'").arg(s);
 170             }
 171
 172             for (; _tos; --_tos) {
 173                 const int state = _stateStack[_tos];
 174
 175                 static int tks[] = {
 176                     T_RIGHT_BRACE, T_RIGHT_PAREN, T_RIGHT_BRACKET,
 177                     T_SEMICOLON, T_COMMA, T_COLON,
 178                     T_NUMBER, T_TYPE_NAME, T_IDENTIFIER,
 179                     T_LEFT_BRACE, T_LEFT_PAREN, T_LEFT_BRACKET,
 180                     T_WHILE,
 181                     0
 182                 };
 183
 184                 for (int *tptr = tks; *tptr; ++tptr) {
 185                     const int next = t_action(state, *tptr);
 186                     if (next > 0) {
 187                         if (! yyrecovering && ! _recovered) {
 188                             _recovered = true;
 189                             error(line, QString("Expected `%1'").arg(QLatin1String(spell[*tptr])));
 190                         }
 191
 192                         yyrecovering = 3;
 193                         if (*tptr == T_IDENTIFIER)
 194                             yyval = (void *) _engine->identifier(QLatin1String("$identifier"));
 195                         else if (*tptr == T_NUMBER || *tptr == T_TYPE_NAME)
 196                             yyval = (void *) _engine->identifier(QLatin1String("$0"));
 197                         else
 198                             yyval = 0;
 199
 200                         _symStack[_tos].ptr = yyval;
 201                         _locationStack[_tos] = yyloc;
 202                         yytoken = -1;
 203
 204                         action = next;
 205                         goto again;
 206                     }
 207                 }
 208             }
 209
 210             if (! _recovered) {
 211                 _recovered = true;
 212                 error(line, message);
 213             }
 214         }
 215
 216     } while (action);
 217
 218     return 0;
 219 }
 220
 221 #line 637 "./glsl.g"
 222
 223 void Parser::reduce(int ruleno)
 224 {
 225 switch(ruleno) {
 226
 227 #line 646 "./glsl.g"
 228
 229 case 0: {
 230     ast(1) = makeAstNode<IdentifierExpressionAST>(string(1));
 231 }   break;
 232
 233 #line 653 "./glsl.g"
 234
 235 case 1: {
 236     ast(1) = makeAstNode<LiteralExpressionAST>(string(1));
 237 }   break;
 238
 239 #line 660 "./glsl.g"
 240
 241 case 2: {
 242     ast(1) = makeAstNode<LiteralExpressionAST>(_engine->identifier("true", 4));
 243 }   break;
 244
 245 #line 667 "./glsl.g"
 246
 247 case 3: {
 248     ast(1) = makeAstNode<LiteralExpressionAST>(_engine->identifier("false", 5));
 249 }   break;
 250
 251 #line 674 "./glsl.g"
 252
 253 case 4: {
 254     // nothing to do.
 255 }   break;
 256
 257 #line 681 "./glsl.g"
 258
 259 case 5: {
 260     ast(1) = ast(2);
 261 }   break;
 262
 263 #line 688 "./glsl.g"
 264
 265 case 6: {
 266     // nothing to do.
 267 }   break;
 268
 269 #line 695 "./glsl.g"
 270
 271 case 7: {
 272     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_ArrayAccess, expression(1), expression(3));
 273 }   break;
 274
 275 #line 702 "./glsl.g"
 276
 277 case 8: {
 278     // nothing to do.
 279 }   break;
 280
 281 #line 709 "./glsl.g"
 282
 283 case 9: {
 284     ast(1) = makeAstNode<MemberAccessExpressionAST>(expression(1), string(3));
 285 }   break;
 286
 287 #line 716 "./glsl.g"
 288
 289 case 10: {
 290     ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PostIncrement, expression(1));
 291 }   break;
 292
 293 #line 723 "./glsl.g"
 294
 295 case 11: {
 296     ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PostDecrement, expression(1));
 297 }   break;
 298
 299 #line 730 "./glsl.g"
 300
 301 case 12: {
 302     // nothing to do.
 303 }   break;
 304
 305 #line 737 "./glsl.g"
 306
 307 case 13: {
 308     // nothing to do.
 309 }   break;
 310
 311 #line 744 "./glsl.g"
 312
 313 case 14: {
 314     ast(1) = makeAstNode<FunctionCallExpressionAST>
 315         (sym(1).function.id, sym(1).function.arguments);
 316 }   break;
 317
 318 #line 752 "./glsl.g"
 319
 320 case 15: {
 321     ast(1) = makeAstNode<FunctionCallExpressionAST>
 322         (expression(1), sym(3).function.id, sym(3).function.arguments);
 323 }   break;
 324
 325 #line 760 "./glsl.g"
 326
 327 case 16: {
 328     // nothing to do.
 329 }   break;
 330
 331 #line 767 "./glsl.g"
 332
 333 case 17: {
 334     // nothing to do.
 335 }   break;
 336
 337 #line 774 "./glsl.g"
 338
 339 case 18: {
 340     sym(1).function.id = sym(1).function_identifier;
 341     sym(1).function.arguments = 0;
 342 }   break;
 343
 344 #line 782 "./glsl.g"
 345
 346 case 19: {
 347     sym(1).function.id = sym(1).function_identifier;
 348     sym(1).function.arguments = 0;
 349 }   break;
 350
 351 #line 790 "./glsl.g"
 352
 353 case 20: {
 354     sym(1).function.id = sym(1).function_identifier;
 355     sym(1).function.arguments =
 356         makeAstNode< List<ExpressionAST *> >(expression(2));
 357 }   break;
 358
 359 #line 799 "./glsl.g"
 360
 361 case 21: {
 362     sym(1).function.arguments =
 363         makeAstNode< List<ExpressionAST *> >
 364             (sym(1).function.arguments, expression(3));
 365 }   break;
 366
 367 #line 808 "./glsl.g"
 368
 369 case 22: {
 370     // nothing to do.
 371 }   break;
 372
 373 #line 815 "./glsl.g"
 374
 375 case 23: {
 376     ast(1) = makeAstNode<FunctionIdentifierAST>(type(1));
 377 }   break;
 378
 379 #line 822 "./glsl.g"
 380
 381 case 24: {
 382     ast(1) = makeAstNode<FunctionIdentifierAST>(string(1));
 383 }   break;
 384
 385 #line 829 "./glsl.g"
 386
 387 case 25: {
 388     // nothing to do.
 389 }   break;
 390
 391 #line 836 "./glsl.g"
 392
 393 case 26: {
 394     ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PreIncrement, expression(2));
 395 }   break;
 396
 397 #line 843 "./glsl.g"
 398
 399 case 27: {
 400     ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PreDecrement, expression(2));
 401 }   break;
 402
 403 #line 850 "./glsl.g"
 404
 405 case 28: {
 406     ast(1) = makeAstNode<UnaryExpressionAST>(sym(1).kind, expression(2));
 407 }   break;
 408
 409 #line 857 "./glsl.g"
 410
 411 case 29: {
 412     sym(1).kind = AST::Kind_UnaryPlus;
 413 }   break;
 414
 415 #line 864 "./glsl.g"
 416
 417 case 30: {
 418     sym(1).kind = AST::Kind_UnaryMinus;
 419 }   break;
 420
 421 #line 871 "./glsl.g"
 422
 423 case 31: {
 424     sym(1).kind = AST::Kind_LogicalNot;
 425 }   break;
 426
 427 #line 878 "./glsl.g"
 428
 429 case 32: {
 430     sym(1).kind = AST::Kind_BitwiseNot;
 431 }   break;
 432
 433 #line 885 "./glsl.g"
 434
 435 case 33: {
 436     // nothing to do.
 437 }   break;
 438
 439 #line 892 "./glsl.g"
 440
 441 case 34: {
 442     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Multiply, expression(1), expression(3));
 443 }   break;
 444
 445 #line 899 "./glsl.g"
 446
 447 case 35: {
 448     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Divide, expression(1), expression(3));
 449 }   break;
 450
 451 #line 906 "./glsl.g"
 452
 453 case 36: {
 454     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Modulus, expression(1), expression(3));
 455 }   break;
 456
 457 #line 913 "./glsl.g"
 458
 459 case 37: {
 460     // nothing to do.
 461 }   break;
 462
 463 #line 920 "./glsl.g"
 464
 465 case 38: {
 466     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Plus, expression(1), expression(3));
 467 }   break;
 468
 469 #line 927 "./glsl.g"
 470
 471 case 39: {
 472     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Minus, expression(1), expression(3));
 473 }   break;
 474
 475 #line 934 "./glsl.g"
 476
 477 case 40: {
 478     // nothing to do.
 479 }   break;
 480
 481 #line 941 "./glsl.g"
 482
 483 case 41: {
 484     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_ShiftLeft, expression(1), expression(3));
 485 }   break;
 486
 487 #line 948 "./glsl.g"
 488
 489 case 42: {
 490     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_ShiftRight, expression(1), expression(3));
 491 }   break;
 492
 493 #line 955 "./glsl.g"
 494
 495 case 43: {
 496     // nothing to do.
 497 }   break;
 498
 499 #line 962 "./glsl.g"
 500
 501 case 44: {
 502     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LessThan, expression(1), expression(3));
 503 }   break;
 504
 505 #line 969 "./glsl.g"
 506
 507 case 45: {
 508     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_GreaterThan, expression(1), expression(3));
 509 }   break;
 510
 511 #line 976 "./glsl.g"
 512
 513 case 46: {
 514     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LessEqual, expression(1), expression(3));
 515 }   break;
 516
 517 #line 983 "./glsl.g"
 518
 519 case 47: {
 520     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_GreaterEqual, expression(1), expression(3));
 521 }   break;
 522
 523 #line 990 "./glsl.g"
 524
 525 case 48: {
 526     // nothing to do.
 527 }   break;
 528
 529 #line 997 "./glsl.g"
 530
 531 case 49: {
 532     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Equal, expression(1), expression(3));
 533 }   break;
 534
 535 #line 1004 "./glsl.g"
 536
 537 case 50: {
 538     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_NotEqual, expression(1), expression(3));
 539 }   break;
 540
 541 #line 1011 "./glsl.g"
 542
 543 case 51: {
 544     // nothing to do.
 545 }   break;
 546
 547 #line 1018 "./glsl.g"
 548
 549 case 52: {
 550     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_BitwiseAnd, expression(1), expression(3));
 551 }   break;
 552
 553 #line 1025 "./glsl.g"
 554
 555 case 53: {
 556     // nothing to do.
 557 }   break;
 558
 559 #line 1032 "./glsl.g"
 560
 561 case 54: {
 562     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_BitwiseXor, expression(1), expression(3));
 563 }   break;
 564
 565 #line 1039 "./glsl.g"
 566
 567 case 55: {
 568     // nothing to do.
 569 }   break;
 570
 571 #line 1046 "./glsl.g"
 572
 573 case 56: {
 574     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_BitwiseOr, expression(1), expression(3));
 575 }   break;
 576
 577 #line 1053 "./glsl.g"
 578
 579 case 57: {
 580     // nothing to do.
 581 }   break;
 582
 583 #line 1060 "./glsl.g"
 584
 585 case 58: {
 586     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LogicalAnd, expression(1), expression(3));
 587 }   break;
 588
 589 #line 1067 "./glsl.g"
 590
 591 case 59: {
 592     // nothing to do.
 593 }   break;
 594
 595 #line 1074 "./glsl.g"
 596
 597 case 60: {
 598     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LogicalXor, expression(1), expression(3));
 599 }   break;
 600
 601 #line 1081 "./glsl.g"
 602
 603 case 61: {
 604     // nothing to do.
 605 }   break;
 606
 607 #line 1088 "./glsl.g"
 608
 609 case 62: {
 610     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LogicalOr, expression(1), expression(3));
 611 }   break;
 612
 613 #line 1095 "./glsl.g"
 614
 615 case 63: {
 616     // nothing to do.
 617 }   break;
 618
 619 #line 1102 "./glsl.g"
 620
 621 case 64: {
 622     ast(1) = makeAstNode<TernaryExpressionAST>(AST::Kind_Conditional, expression(1), expression(3), expression(5));
 623 }   break;
 624
 625 #line 1109 "./glsl.g"
 626
 627 case 65: {
 628     // nothing to do.
 629 }   break;
 630
 631 #line 1116 "./glsl.g"
 632
 633 case 66: {
 634     ast(1) = makeAstNode<AssignmentExpressionAST>(sym(2).kind, expression(1), expression(3));
 635 }   break;
 636
 637 #line 1123 "./glsl.g"
 638
 639 case 67: {
 640     sym(1).kind = AST::Kind_Assign;
 641 }   break;
 642
 643 #line 1130 "./glsl.g"
 644
 645 case 68: {
 646     sym(1).kind = AST::Kind_AssignMultiply;
 647 }   break;
 648
 649 #line 1137 "./glsl.g"
 650
 651 case 69: {
 652     sym(1).kind = AST::Kind_AssignDivide;
 653 }   break;
 654
 655 #line 1144 "./glsl.g"
 656
 657 case 70: {
 658     sym(1).kind = AST::Kind_AssignModulus;
 659 }   break;
 660
 661 #line 1151 "./glsl.g"
 662
 663 case 71: {
 664     sym(1).kind = AST::Kind_AssignPlus;
 665 }   break;
 666
 667 #line 1158 "./glsl.g"
 668
 669 case 72: {
 670     sym(1).kind = AST::Kind_AssignMinus;
 671 }   break;
 672
 673 #line 1165 "./glsl.g"
 674
 675 case 73: {
 676     sym(1).kind = AST::Kind_AssignShiftLeft;
 677 }   break;
 678
 679 #line 1172 "./glsl.g"
 680
 681 case 74: {
 682     sym(1).kind = AST::Kind_AssignShiftRight;
 683 }   break;
 684
 685 #line 1179 "./glsl.g"
 686
 687 case 75: {
 688     sym(1).kind = AST::Kind_AssignAnd;
 689 }   break;
 690
 691 #line 1186 "./glsl.g"
 692
 693 case 76: {
 694     sym(1).kind = AST::Kind_AssignXor;
 695 }   break;
 696
 697 #line 1193 "./glsl.g"
 698
 699 case 77: {
 700     sym(1).kind = AST::Kind_AssignOr;
 701 }   break;
 702
 703 #line 1200 "./glsl.g"
 704
 705 case 78: {
 706     // nothing to do.
 707 }   break;
 708
 709 #line 1207 "./glsl.g"
 710
 711 case 79: {
 712     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Comma, expression(1), expression(3));
 713 }   break;
 714
 715 #line 1214 "./glsl.g"
 716
 717 case 80: {
 718     // nothing to do.
 719 }   break;
 720
 721 #line 1221 "./glsl.g"
 722
 723 case 81: {
 724     // nothing to do.
 725 }   break;
 726
 727 #line 1228 "./glsl.g"
 728
 729 case 82: {
 730     ast(1) = makeAstNode<InitDeclarationAST>(sym(1).declaration_list);
 731 }   break;
 732
 733 #line 1235 "./glsl.g"
 734
 735 case 83: {
 736     ast(1) = makeAstNode<PrecisionDeclarationAST>(sym(2).precision, type(3));
 737 }   break;
 738
 739 #line 1242 "./glsl.g"
 740
 741 case 84: {
 742     if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) {
 743         // TODO: issue an error if the qualifier is not "struct".
 744     }
 745     TypeAST *type = makeAstNode<StructTypeAST>(string(2), sym(4).field_list);
 746     ast(1) = makeAstNode<TypeDeclarationAST>(type);
 747 }   break;
 748
 749 #line 1253 "./glsl.g"
 750
 751 case 85: {
 752     if ((sym(1).type_qualifier.qualifier & QualifiedTypeAST::Struct) == 0) {
 753         // TODO: issue an error if the qualifier does not contain "struct".
 754     }
 755     TypeAST *type = makeAstNode<StructTypeAST>(string(2), sym(4).field_list);
 756     TypeAST *qualtype = type;
 757     if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) {
 758         qualtype = makeAstNode<QualifiedTypeAST>
 759             (sym(1).type_qualifier.qualifier & ~QualifiedTypeAST::Struct, qualtype,
 760              sym(1).type_qualifier.layout_list);
 761     }
 762     ast(1) = makeAstNode<TypeAndVariableDeclarationAST>
 763         (makeAstNode<TypeDeclarationAST>(type),
 764          makeAstNode<VariableDeclarationAST>(qualtype, string(6)));
 765 }   break;
 766
 767 #line 1272 "./glsl.g"
 768
 769 case 86: {
 770     if ((sym(1).type_qualifier.qualifier & QualifiedTypeAST::Struct) == 0) {
 771         // TODO: issue an error if the qualifier does not contain "struct".
 772     }
 773     TypeAST *type = makeAstNode<StructTypeAST>(string(2), sym(4).field_list);
 774     TypeAST *qualtype = type;
 775     if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) {
 776         qualtype = makeAstNode<QualifiedTypeAST>
 777             (sym(1).type_qualifier.qualifier & ~QualifiedTypeAST::Struct, qualtype,
 778              sym(1).type_qualifier.layout_list);
 779     }
 780     ast(1) = makeAstNode<TypeAndVariableDeclarationAST>
 781         (makeAstNode<TypeDeclarationAST>(type),
 782          makeAstNode<VariableDeclarationAST>
 783             (makeAstNode<ArrayTypeAST>(qualtype), string(6)));
 784 }   break;
 785
 786 #line 1292 "./glsl.g"
 787
 788 case 87: {
 789     if ((sym(1).type_qualifier.qualifier & QualifiedTypeAST::Struct) == 0) {
 790         // TODO: issue an error if the qualifier does not contain "struct".
 791     }
 792     TypeAST *type = makeAstNode<StructTypeAST>(string(2), sym(4).field_list);
 793     TypeAST *qualtype = type;
 794     if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) {
 795         qualtype = makeAstNode<QualifiedTypeAST>
 796             (sym(1).type_qualifier.qualifier & ~QualifiedTypeAST::Struct, qualtype,
 797              sym(1).type_qualifier.layout_list);
 798     }
 799     ast(1) = makeAstNode<TypeAndVariableDeclarationAST>
 800         (makeAstNode<TypeDeclarationAST>(type),
 801          makeAstNode<VariableDeclarationAST>
 802             (makeAstNode<ArrayTypeAST>(qualtype, expression(8)), string(6)));
 803 }   break;
 804
 805 #line 1312 "./glsl.g"
 806
 807 case 88: {
 808     TypeAST *type = makeAstNode<QualifiedTypeAST>
 809         (sym(1).type_qualifier.qualifier, (TypeAST *)0,
 810          sym(1).type_qualifier.layout_list);
 811     ast(1) = makeAstNode<TypeDeclarationAST>(type);
 812 }   break;
 813
 814 #line 1322 "./glsl.g"
 815
 816 case 89: {
 817     function(1)->finishParams();
 818 }   break;
 819
 820 #line 1329 "./glsl.g"
 821
 822 case 90: {
 823     // nothing to do.
 824 }   break;
 825
 826 #line 1336 "./glsl.g"
 827
 828 case 91: {
 829     // nothing to do.
 830 }   break;
 831
 832 #line 1343 "./glsl.g"
 833
 834 case 92: {
 835     function(1)->params = makeAstNode< List<ParameterDeclarationAST *> >
 836         (sym(2).param_declaration);
 837 }   break;
 838
 839 #line 1351 "./glsl.g"
 840
 841 case 93: {
 842     function(1)->params = makeAstNode< List<ParameterDeclarationAST *> >
 843         (function(1)->params, sym(3).param_declaration);
 844 }   break;
 845
 846 #line 1359 "./glsl.g"
 847
 848 case 94: {
 849     function(1) = makeAstNode<FunctionDeclarationAST>(type(1), string(2));
 850 }   break;
 851
 852 #line 1366 "./glsl.g"
 853
 854 case 95: {
 855     sym(1).param_declarator.type = type(1);
 856     sym(1).param_declarator.name = string(2);
 857 }   break;
 858
 859 #line 1374 "./glsl.g"
 860
 861 case 96: {
 862     sym(1).param_declarator.type = makeAstNode<ArrayTypeAST>(type(1), expression(4));
 863     sym(1).param_declarator.name = string(2);
 864 }   break;
 865
 866 #line 1382 "./glsl.g"
 867
 868 case 97: {
 869     ast(1) = makeAstNode<ParameterDeclarationAST>
 870         (makeAstNode<QualifiedTypeAST>
 871             (sym(1).qualifier, sym(3).param_declarator.type,
 872              (List<LayoutQualifier *> *)0),
 873          ParameterDeclarationAST::Qualifier(sym(2).qualifier),
 874          sym(3).param_declarator.name);
 875 }   break;
 876
 877 #line 1394 "./glsl.g"
 878
 879 case 98: {
 880     ast(1) = makeAstNode<ParameterDeclarationAST>
 881         (sym(2).param_declarator.type,
 882          ParameterDeclarationAST::Qualifier(sym(1).qualifier),
 883          sym(2).param_declarator.name);
 884 }   break;
 885
 886 #line 1404 "./glsl.g"
 887
 888 case 99: {
 889     ast(1) = makeAstNode<ParameterDeclarationAST>
 890         (makeAstNode<QualifiedTypeAST>
 891             (sym(1).qualifier, type(3), (List<LayoutQualifier *> *)0),
 892          ParameterDeclarationAST::Qualifier(sym(2).qualifier),
 893          (const QString *)0);
 894 }   break;
 895
 896 #line 1415 "./glsl.g"
 897
 898 case 100: {
 899     ast(1) = makeAstNode<ParameterDeclarationAST>
 900         (type(2), ParameterDeclarationAST::Qualifier(sym(1).qualifier),
 901          (const QString *)0);
 902 }   break;
 903
 904 #line 1424 "./glsl.g"
 905
 906 case 101: {
 907     sym(1).qualifier = ParameterDeclarationAST::In;
 908 }   break;
 909
 910 #line 1431 "./glsl.g"
 911
 912 case 102: {
 913     sym(1).qualifier = ParameterDeclarationAST::In;
 914 }   break;
 915
 916 #line 1438 "./glsl.g"
 917
 918 case 103: {
 919     sym(1).qualifier = ParameterDeclarationAST::Out;
 920 }   break;
 921
 922 #line 1445 "./glsl.g"
 923
 924 case 104: {
 925     sym(1).qualifier = ParameterDeclarationAST::InOut;
 926 }   break;
 927
 928 #line 1452 "./glsl.g"
 929
 930 case 105: {
 931     // nothing to do.
 932 }   break;
 933
 934 #line 1459 "./glsl.g"
 935
 936 case 106: {
 937     sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
 938         (sym(1).declaration);
 939 }   break;
 940
 941 #line 1467 "./glsl.g"
 942
 943 case 107: {
 944     TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
 945     DeclarationAST *decl = makeAstNode<VariableDeclarationAST>(type, string(3));
 946     sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
 947             (sym(1).declaration_list, decl);
 948 }   break;
 949
 950 #line 1477 "./glsl.g"
 951
 952 case 108: {
 953     TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
 954     type = makeAstNode<ArrayTypeAST>(type);
 955     DeclarationAST *decl = makeAstNode<VariableDeclarationAST>(type, string(3));
 956     sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
 957             (sym(1).declaration_list, decl);
 958 }   break;
 959
 960 #line 1488 "./glsl.g"
 961
 962 case 109: {
 963     TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
 964     type = makeAstNode<ArrayTypeAST>(type, expression(5));
 965     DeclarationAST *decl = makeAstNode<VariableDeclarationAST>(type, string(3));
 966     sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
 967             (sym(1).declaration_list, decl);
 968 }   break;
 969
 970 #line 1499 "./glsl.g"
 971
 972 case 110: {
 973     TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
 974     type = makeAstNode<ArrayTypeAST>(type);
 975     DeclarationAST *decl = makeAstNode<VariableDeclarationAST>
 976             (type, string(3), expression(7));
 977     sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
 978             (sym(1).declaration_list, decl);
 979 }   break;
 980
 981 #line 1511 "./glsl.g"
 982
 983 case 111: {
 984     TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
 985     type = makeAstNode<ArrayTypeAST>(type, expression(5));
 986     DeclarationAST *decl = makeAstNode<VariableDeclarationAST>
 987             (type, string(3), expression(8));
 988     sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
 989             (sym(1).declaration_list, decl);
 990 }   break;
 991
 992 #line 1523 "./glsl.g"
 993
 994 case 112: {
 995     TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
 996     DeclarationAST *decl = makeAstNode<VariableDeclarationAST>
 997             (type, string(3), expression(5));
 998     sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
 999             (sym(1).declaration_list, decl);
1000 }   break;
1001
1002 #line 1534 "./glsl.g"
1003
1004 case 113: {
1005     ast(1) = makeAstNode<TypeDeclarationAST>(type(1));
1006 }   break;
1007
1008 #line 1541 "./glsl.g"
1009
1010 case 114: {
1011     ast(1) = makeAstNode<VariableDeclarationAST>(type(1), string(2));
1012 }   break;
1013
1014 #line 1548 "./glsl.g"
1015
1016 case 115: {
1017     ast(1) = makeAstNode<VariableDeclarationAST>
1018         (makeAstNode<ArrayTypeAST>(type(1)), string(2));
1019 }   break;
1020
1021 #line 1556 "./glsl.g"
1022
1023 case 116: {
1024     ast(1) = makeAstNode<VariableDeclarationAST>
1025         (makeAstNode<ArrayTypeAST>(type(1), expression(4)), string(2));
1026 }   break;
1027
1028 #line 1564 "./glsl.g"
1029
1030 case 117: {
1031     ast(1) = makeAstNode<VariableDeclarationAST>
1032         (makeAstNode<ArrayTypeAST>(type(1)), string(2), expression(6));
1033 }   break;
1034
1035 #line 1572 "./glsl.g"
1036
1037 case 118: {
1038     ast(1) = makeAstNode<VariableDeclarationAST>
1039         (makeAstNode<ArrayTypeAST>(type(1), expression(4)),
1040          string(2), expression(7));
1041 }   break;
1042
1043 #line 1581 "./glsl.g"
1044
1045 case 119: {
1046     ast(1) = makeAstNode<VariableDeclarationAST>
1047         (type(1), string(2), expression(4));
1048 }   break;
1049
1050 #line 1589 "./glsl.g"
1051
1052 case 120: {
1053     ast(1) = makeAstNode<InvariantDeclarationAST>(string(2));
1054 }   break;
1055
1056 #line 1596 "./glsl.g"
1057
1058 case 121: {
1059     ast(1) = makeAstNode<QualifiedTypeAST>(0, type(1), (List<LayoutQualifier *> *)0);
1060 }   break;
1061
1062 #line 1603 "./glsl.g"
1063
1064 case 122: {
1065     ast(1) = makeAstNode<QualifiedTypeAST>
1066         (sym(1).type_qualifier.qualifier, type(2),
1067          sym(1).type_qualifier.layout_list);
1068 }   break;
1069
1070 #line 1612 "./glsl.g"
1071
1072 case 123: {
1073     sym(1).qualifier = QualifiedTypeAST::Invariant;
1074 }   break;
1075
1076 #line 1619 "./glsl.g"
1077
1078 case 124: {
1079     sym(1).qualifier = QualifiedTypeAST::Smooth;
1080 }   break;
1081
1082 #line 1626 "./glsl.g"
1083
1084 case 125: {
1085     sym(1).qualifier = QualifiedTypeAST::Flat;
1086 }   break;
1087
1088 #line 1633 "./glsl.g"
1089
1090 case 126: {
1091     sym(1).qualifier = QualifiedTypeAST::NoPerspective;
1092 }   break;
1093
1094 #line 1640 "./glsl.g"
1095
1096 case 127: {
1097     sym(1) = sym(3);
1098 }   break;
1099
1100 #line 1647 "./glsl.g"
1101
1102 case 128: {
1103     sym(1).layout_list = makeAstNode< List<LayoutQualifier *> >(sym(1).layout);
1104 }   break;
1105
1106 #line 1654 "./glsl.g"
1107
1108 case 129: {
1109     sym(1).layout_list = makeAstNode< List<LayoutQualifier *> >(sym(1).layout_list, sym(3).layout);
1110 }   break;
1111
1112 #line 1661 "./glsl.g"
1113
1114 case 130: {
1115     sym(1).layout = makeAstNode<LayoutQualifier>(string(1), (const QString *)0);
1116 }   break;
1117
1118 #line 1668 "./glsl.g"
1119
1120 case 131: {
1121     sym(1).layout = makeAstNode<LayoutQualifier>(string(1), string(3));
1122 }   break;
1123
1124 #line 1675 "./glsl.g"
1125
1126 case 132: {
1127     sym(1).qualifier = QualifiedTypeAST::Const;
1128 }   break;
1129
1130 #line 1682 "./glsl.g"
1131
1132 case 133: {
1133     sym(1).type_qualifier.qualifier = sym(1).qualifier;
1134     sym(1).type_qualifier.layout_list = 0;
1135 }   break;
1136
1137 #line 1690 "./glsl.g"
1138
1139 case 134: {
1140     sym(1).type_qualifier.layout_list = sym(1).layout_list;
1141     sym(1).type_qualifier.qualifier = 0;
1142 }   break;
1143
1144 #line 1698 "./glsl.g"
1145
1146 case 135: {
1147     sym(1).type_qualifier.layout_list = sym(1).layout_list;
1148     sym(1).type_qualifier.qualifier = sym(2).qualifier;
1149 }   break;
1150
1151 #line 1706 "./glsl.g"
1152
1153 case 136: {
1154     sym(1).type_qualifier.qualifier = sym(1).qualifier | sym(2).qualifier;
1155     sym(1).type_qualifier.layout_list = 0;
1156 }   break;
1157
1158 #line 1714 "./glsl.g"
1159
1160 case 137: {
1161     sym(1).type_qualifier.qualifier = sym(1).qualifier;
1162     sym(1).type_qualifier.layout_list = 0;
1163 }   break;
1164
1165 #line 1722 "./glsl.g"
1166
1167 case 138: {
1168     sym(1).type_qualifier.qualifier = sym(1).qualifier | sym(2).qualifier;
1169     sym(1).type_qualifier.layout_list = 0;
1170 }   break;
1171
1172 #line 1730 "./glsl.g"
1173
1174 case 139: {
1175     sym(1).type_qualifier.qualifier = sym(1).qualifier | sym(2).qualifier | sym(3).qualifier;
1176     sym(1).type_qualifier.layout_list = 0;
1177 }   break;
1178
1179 #line 1738 "./glsl.g"
1180
1181 case 140: {
1182     sym(1).type_qualifier.qualifier = QualifiedTypeAST::Invariant;
1183     sym(1).type_qualifier.layout_list = 0;
1184 }   break;
1185
1186 #line 1746 "./glsl.g"
1187
1188 case 141: {
1189     sym(1).qualifier = QualifiedTypeAST::Const;
1190 }   break;
1191
1192 #line 1753 "./glsl.g"
1193
1194 case 142: {
1195     sym(1).qualifier = QualifiedTypeAST::Attribute;
1196 }   break;
1197
1198 #line 1760 "./glsl.g"
1199
1200 case 143: {
1201     sym(1).qualifier = QualifiedTypeAST::Varying;
1202 }   break;
1203
1204 #line 1767 "./glsl.g"
1205
1206 case 144: {
1207     sym(1).qualifier = QualifiedTypeAST::CentroidVarying;
1208 }   break;
1209
1210 #line 1774 "./glsl.g"
1211
1212 case 145: {
1213     sym(1).qualifier = QualifiedTypeAST::In;
1214 }   break;
1215
1216 #line 1781 "./glsl.g"
1217
1218 case 146: {
1219     sym(1).qualifier = QualifiedTypeAST::Out;
1220 }   break;
1221
1222 #line 1788 "./glsl.g"
1223
1224 case 147: {
1225     sym(1).qualifier = QualifiedTypeAST::CentroidIn;
1226 }   break;
1227
1228 #line 1795 "./glsl.g"
1229
1230 case 148: {
1231     sym(1).qualifier = QualifiedTypeAST::CentroidOut;
1232 }   break;
1233
1234 #line 1802 "./glsl.g"
1235
1236 case 149: {
1237     sym(1).qualifier = QualifiedTypeAST::PatchIn;
1238 }   break;
1239
1240 #line 1809 "./glsl.g"
1241
1242 case 150: {
1243     sym(1).qualifier = QualifiedTypeAST::PatchOut;
1244 }   break;
1245
1246 #line 1816 "./glsl.g"
1247
1248 case 151: {
1249     sym(1).qualifier = QualifiedTypeAST::SampleIn;
1250 }   break;
1251
1252 #line 1823 "./glsl.g"
1253
1254 case 152: {
1255     sym(1).qualifier = QualifiedTypeAST::SampleOut;
1256 }   break;
1257
1258 #line 1830 "./glsl.g"
1259
1260 case 153: {
1261     sym(1).qualifier = QualifiedTypeAST::Uniform;
1262 }   break;
1263
1264 #line 1837 "./glsl.g"
1265
1266 case 154: {
1267     // nothing to do.
1268 }   break;
1269
1270 #line 1844 "./glsl.g"
1271
1272 case 155: {
1273     if (!type(2)->setPrecision(sym(1).precision)) {
1274         // TODO: issue an error about precision not allowed on this type.
1275     }
1276     ast(1) = type(2);
1277 }   break;
1278
1279 #line 1854 "./glsl.g"
1280
1281 case 156: {
1282     // nothing to do.
1283 }   break;
1284
1285 #line 1861 "./glsl.g"
1286
1287 case 157: {
1288     ast(1) = makeAstNode<ArrayTypeAST>(type(1));
1289 }   break;
1290
1291 #line 1868 "./glsl.g"
1292
1293 case 158: {
1294     ast(1) = makeAstNode<ArrayTypeAST>(type(1), expression(3));
1295 }   break;
1296
1297 #line 1875 "./glsl.g"
1298
1299 case 159: {
1300     ast(1) = makeBasicType(T_VOID);
1301 }   break;
1302
1303 #line 1882 "./glsl.g"
1304
1305 case 160: {
1306     ast(1) = makeBasicType(T_FLOAT);
1307 }   break;
1308
1309 #line 1889 "./glsl.g"
1310
1311 case 161: {
1312     ast(1) = makeBasicType(T_DOUBLE);
1313 }   break;
1314
1315 #line 1896 "./glsl.g"
1316
1317 case 162: {
1318     ast(1) = makeBasicType(T_INT);
1319 }   break;
1320
1321 #line 1903 "./glsl.g"
1322
1323 case 163: {
1324     ast(1) = makeBasicType(T_UINT);
1325 }   break;
1326
1327 #line 1910 "./glsl.g"
1328
1329 case 164: {
1330     ast(1) = makeBasicType(T_BOOL);
1331 }   break;
1332
1333 #line 1917 "./glsl.g"
1334
1335 case 165: {
1336     ast(1) = makeBasicType(T_VEC2);
1337 }   break;
1338
1339 #line 1924 "./glsl.g"
1340
1341 case 166: {
1342     ast(1) = makeBasicType(T_VEC3);
1343 }   break;
1344
1345 #line 1931 "./glsl.g"
1346
1347 case 167: {
1348     ast(1) = makeBasicType(T_VEC4);
1349 }   break;
1350
1351 #line 1938 "./glsl.g"
1352
1353 case 168: {
1354     ast(1) = makeBasicType(T_DVEC2);
1355 }   break;
1356
1357 #line 1945 "./glsl.g"
1358
1359 case 169: {
1360     ast(1) = makeBasicType(T_DVEC3);
1361 }   break;
1362
1363 #line 1952 "./glsl.g"
1364
1365 case 170: {
1366     ast(1) = makeBasicType(T_DVEC4);
1367 }   break;
1368
1369 #line 1959 "./glsl.g"
1370
1371 case 171: {
1372     ast(1) = makeBasicType(T_BVEC2);
1373 }   break;
1374
1375 #line 1966 "./glsl.g"
1376
1377 case 172: {
1378     ast(1) = makeBasicType(T_BVEC3);
1379 }   break;
1380
1381 #line 1973 "./glsl.g"
1382
1383 case 173: {
1384     ast(1) = makeBasicType(T_BVEC4);
1385 }   break;
1386
1387 #line 1980 "./glsl.g"
1388
1389 case 174: {
1390     ast(1) = makeBasicType(T_IVEC2);
1391 }   break;
1392
1393 #line 1987 "./glsl.g"
1394
1395 case 175: {
1396     ast(1) = makeBasicType(T_IVEC3);
1397 }   break;
1398
1399 #line 1994 "./glsl.g"
1400
1401 case 176: {
1402     ast(1) = makeBasicType(T_IVEC4);
1403 }   break;
1404
1405 #line 2001 "./glsl.g"
1406
1407 case 177: {
1408     ast(1) = makeBasicType(T_UVEC2);
1409 }   break;
1410
1411 #line 2008 "./glsl.g"
1412
1413 case 178: {
1414     ast(1) = makeBasicType(T_UVEC3);
1415 }   break;
1416
1417 #line 2015 "./glsl.g"
1418
1419 case 179: {
1420     ast(1) = makeBasicType(T_UVEC4);
1421 }   break;
1422
1423 #line 2022 "./glsl.g"
1424
1425 case 180: {
1426     ast(1) = makeBasicType(T_MAT2);
1427 }   break;
1428
1429 #line 2029 "./glsl.g"
1430
1431 case 181: {
1432     ast(1) = makeBasicType(T_MAT3);
1433 }   break;
1434
1435 #line 2036 "./glsl.g"
1436
1437 case 182: {
1438     ast(1) = makeBasicType(T_MAT4);
1439 }   break;
1440
1441 #line 2043 "./glsl.g"
1442
1443 case 183: {
1444     ast(1) = makeBasicType(T_MAT2);
1445 }   break;
1446
1447 #line 2050 "./glsl.g"
1448
1449 case 184: {
1450     ast(1) = makeBasicType(T_MAT2X3);
1451 }   break;
1452
1453 #line 2057 "./glsl.g"
1454
1455 case 185: {
1456     ast(1) = makeBasicType(T_MAT2X4);
1457 }   break;
1458
1459 #line 2064 "./glsl.g"
1460
1461 case 186: {
1462     ast(1) = makeBasicType(T_MAT3X2);
1463 }   break;
1464
1465 #line 2071 "./glsl.g"
1466
1467 case 187: {
1468     ast(1) = makeBasicType(T_MAT3);
1469 }   break;
1470
1471 #line 2078 "./glsl.g"
1472
1473 case 188: {
1474     ast(1) = makeBasicType(T_MAT3X4);
1475 }   break;
1476
1477 #line 2085 "./glsl.g"
1478
1479 case 189: {
1480     ast(1) = makeBasicType(T_MAT4X2);
1481 }   break;
1482
1483 #line 2092 "./glsl.g"
1484
1485 case 190: {
1486     ast(1) = makeBasicType(T_MAT4X3);
1487 }   break;
1488
1489 #line 2099 "./glsl.g"
1490
1491 case 191: {
1492     ast(1) = makeBasicType(T_MAT4);
1493 }   break;
1494
1495 #line 2106 "./glsl.g"
1496
1497 case 192: {
1498     ast(1) = makeBasicType(T_DMAT2);
1499 }   break;
1500
1501 #line 2113 "./glsl.g"
1502
1503 case 193: {
1504     ast(1) = makeBasicType(T_DMAT3);
1505 }   break;
1506
1507 #line 2120 "./glsl.g"
1508
1509 case 194: {
1510     ast(1) = makeBasicType(T_DMAT4);
1511 }   break;
1512
1513 #line 2127 "./glsl.g"
1514
1515 case 195: {
1516     ast(1) = makeBasicType(T_DMAT2);
1517 }   break;
1518
1519 #line 2134 "./glsl.g"
1520
1521 case 196: {
1522     ast(1) = makeBasicType(T_DMAT2X3);
1523 }   break;
1524
1525 #line 2141 "./glsl.g"
1526
1527 case 197: {
1528     ast(1) = makeBasicType(T_DMAT2X4);
1529 }   break;
1530
1531 #line 2148 "./glsl.g"
1532
1533 case 198: {
1534     ast(1) = makeBasicType(T_DMAT3X2);
1535 }   break;
1536
1537 #line 2155 "./glsl.g"
1538
1539 case 199: {
1540     ast(1) = makeBasicType(T_DMAT3);
1541 }   break;
1542
1543 #line 2162 "./glsl.g"
1544
1545 case 200: {
1546     ast(1) = makeBasicType(T_DMAT3X4);
1547 }   break;
1548
1549 #line 2169 "./glsl.g"
1550
1551 case 201: {
1552     ast(1) = makeBasicType(T_DMAT4X2);
1553 }   break;
1554
1555 #line 2176 "./glsl.g"
1556
1557 case 202: {
1558     ast(1) = makeBasicType(T_DMAT4X3);
1559 }   break;
1560
1561 #line 2183 "./glsl.g"
1562
1563 case 203: {
1564     ast(1) = makeBasicType(T_DMAT4);
1565 }   break;
1566
1567 #line 2190 "./glsl.g"
1568
1569 case 204: {
1570     ast(1) = makeBasicType(T_SAMPLER1D);
1571 }   break;
1572
1573 #line 2197 "./glsl.g"
1574
1575 case 205: {
1576     ast(1) = makeBasicType(T_SAMPLER2D);
1577 }   break;
1578
1579 #line 2204 "./glsl.g"
1580
1581 case 206: {
1582     ast(1) = makeBasicType(T_SAMPLER3D);
1583 }   break;
1584
1585 #line 2211 "./glsl.g"
1586
1587 case 207: {
1588     ast(1) = makeBasicType(T_SAMPLERCUBE);
1589 }   break;
1590
1591 #line 2218 "./glsl.g"
1592
1593 case 208: {
1594     ast(1) = makeBasicType(T_SAMPLER1DSHADOW);
1595 }   break;
1596
1597 #line 2225 "./glsl.g"
1598
1599 case 209: {
1600     ast(1) = makeBasicType(T_SAMPLER2DSHADOW);
1601 }   break;
1602
1603 #line 2232 "./glsl.g"
1604
1605 case 210: {
1606     ast(1) = makeBasicType(T_SAMPLERCUBESHADOW);
1607 }   break;
1608
1609 #line 2239 "./glsl.g"
1610
1611 case 211: {
1612     ast(1) = makeBasicType(T_SAMPLER1DARRAY);
1613 }   break;
1614
1615 #line 2246 "./glsl.g"
1616
1617 case 212: {
1618     ast(1) = makeBasicType(T_SAMPLER2DARRAY);
1619 }   break;
1620
1621 #line 2253 "./glsl.g"
1622
1623 case 213: {
1624     ast(1) = makeBasicType(T_SAMPLER1DARRAYSHADOW);
1625 }   break;
1626
1627 #line 2260 "./glsl.g"
1628
1629 case 214: {
1630     ast(1) = makeBasicType(T_SAMPLER2DARRAYSHADOW);
1631 }   break;
1632
1633 #line 2267 "./glsl.g"
1634
1635 case 215: {
1636     ast(1) = makeBasicType(T_SAMPLERCUBEARRAY);
1637 }   break;
1638
1639 #line 2274 "./glsl.g"
1640
1641 case 216: {
1642     ast(1) = makeBasicType(T_SAMPLERCUBEARRAYSHADOW);
1643 }   break;
1644
1645 #line 2281 "./glsl.g"
1646
1647 case 217: {
1648     ast(1) = makeBasicType(T_ISAMPLER1D);
1649 }   break;
1650
1651 #line 2288 "./glsl.g"
1652
1653 case 218: {
1654     ast(1) = makeBasicType(T_ISAMPLER2D);
1655 }   break;
1656
1657 #line 2295 "./glsl.g"
1658
1659 case 219: {
1660     ast(1) = makeBasicType(T_ISAMPLER3D);
1661 }   break;
1662
1663 #line 2302 "./glsl.g"
1664
1665 case 220: {
1666     ast(1) = makeBasicType(T_ISAMPLERCUBE);
1667 }   break;
1668
1669 #line 2309 "./glsl.g"
1670
1671 case 221: {
1672     ast(1) = makeBasicType(T_ISAMPLER1DARRAY);
1673 }   break;
1674
1675 #line 2316 "./glsl.g"
1676
1677 case 222: {
1678     ast(1) = makeBasicType(T_ISAMPLER2DARRAY);
1679 }   break;
1680
1681 #line 2323 "./glsl.g"
1682
1683 case 223: {
1684     ast(1) = makeBasicType(T_ISAMPLERCUBEARRAY);
1685 }   break;
1686
1687 #line 2330 "./glsl.g"
1688
1689 case 224: {
1690     ast(1) = makeBasicType(T_USAMPLER1D);
1691 }   break;
1692
1693 #line 2337 "./glsl.g"
1694
1695 case 225: {
1696     ast(1) = makeBasicType(T_USAMPLER2D);
1697 }   break;
1698
1699 #line 2344 "./glsl.g"
1700
1701 case 226: {
1702     ast(1) = makeBasicType(T_USAMPLER3D);
1703 }   break;
1704
1705 #line 2351 "./glsl.g"
1706
1707 case 227: {
1708     ast(1) = makeBasicType(T_USAMPLERCUBE);
1709 }   break;
1710
1711 #line 2358 "./glsl.g"
1712
1713 case 228: {
1714     ast(1) = makeBasicType(T_USAMPLER1DARRAY);
1715 }   break;
1716
1717 #line 2365 "./glsl.g"
1718
1719 case 229: {
1720     ast(1) = makeBasicType(T_USAMPLER2DARRAY);
1721 }   break;
1722
1723 #line 2372 "./glsl.g"
1724
1725 case 230: {
1726     ast(1) = makeBasicType(T_USAMPLERCUBEARRAY);
1727 }   break;
1728
1729 #line 2379 "./glsl.g"
1730
1731 case 231: {
1732     ast(1) = makeBasicType(T_SAMPLER2DRECT);
1733 }   break;
1734
1735 #line 2386 "./glsl.g"
1736
1737 case 232: {
1738     ast(1) = makeBasicType(T_SAMPLER2DRECTSHADOW);
1739 }   break;
1740
1741 #line 2393 "./glsl.g"
1742
1743 case 233: {
1744     ast(1) = makeBasicType(T_ISAMPLER2DRECT);
1745 }   break;
1746
1747 #line 2400 "./glsl.g"
1748
1749 case 234: {
1750     ast(1) = makeBasicType(T_USAMPLER2DRECT);
1751 }   break;
1752
1753 #line 2407 "./glsl.g"
1754
1755 case 235: {
1756     ast(1) = makeBasicType(T_SAMPLERBUFFER);
1757 }   break;
1758
1759 #line 2414 "./glsl.g"
1760
1761 case 236: {
1762     ast(1) = makeBasicType(T_ISAMPLERBUFFER);
1763 }   break;
1764
1765 #line 2421 "./glsl.g"
1766
1767 case 237: {
1768     ast(1) = makeBasicType(T_USAMPLERBUFFER);
1769 }   break;
1770
1771 #line 2428 "./glsl.g"
1772
1773 case 238: {
1774     ast(1) = makeBasicType(T_SAMPLER2DMS);
1775 }   break;
1776
1777 #line 2435 "./glsl.g"
1778
1779 case 239: {
1780     ast(1) = makeBasicType(T_ISAMPLER2DMS);
1781 }   break;
1782
1783 #line 2442 "./glsl.g"
1784
1785 case 240: {
1786     ast(1) = makeBasicType(T_USAMPLER2DMS);
1787 }   break;
1788
1789 #line 2449 "./glsl.g"
1790
1791 case 241: {
1792     ast(1) = makeBasicType(T_SAMPLER2DMSARRAY);
1793 }   break;
1794
1795 #line 2456 "./glsl.g"
1796
1797 case 242: {
1798     ast(1) = makeBasicType(T_ISAMPLER2DMSARRAY);
1799 }   break;
1800
1801 #line 2463 "./glsl.g"
1802
1803 case 243: {
1804     ast(1) = makeBasicType(T_USAMPLER2DMSARRAY);
1805 }   break;
1806
1807 #line 2470 "./glsl.g"
1808
1809 case 244: {
1810     // nothing to do.
1811 }   break;
1812
1813 #line 2477 "./glsl.g"
1814
1815 case 245: {
1816     ast(1) = makeAstNode<NamedTypeAST>(string(1));
1817 }   break;
1818
1819 #line 2484 "./glsl.g"
1820
1821 case 246: {
1822     sym(1).precision = TypeAST::Highp;
1823 }   break;
1824
1825 #line 2491 "./glsl.g"
1826
1827 case 247: {
1828     sym(1).precision = TypeAST::Mediump;
1829 }   break;
1830
1831 #line 2498 "./glsl.g"
1832
1833 case 248: {
1834     sym(1).precision = TypeAST::Lowp;
1835 }   break;
1836
1837 #line 2505 "./glsl.g"
1838
1839 case 249: {
1840     ast(1) = makeAstNode<StructTypeAST>(string(2), sym(4).field_list);
1841 }   break;
1842
1843 #line 2512 "./glsl.g"
1844
1845 case 250: {
1846     ast(1) = makeAstNode<StructTypeAST>(sym(3).field_list);
1847 }   break;
1848
1849 #line 2519 "./glsl.g"
1850
1851 case 251: {
1852     // nothing to do.
1853 }   break;
1854
1855 #line 2526 "./glsl.g"
1856
1857 case 252: {
1858     sym(1).field_list = appendLists(sym(1).field_list, sym(2).field_list);
1859 }   break;
1860
1861 #line 2533 "./glsl.g"
1862
1863 case 253: {
1864     sym(1).field_list = StructTypeAST::fixInnerTypes(type(1), sym(2).field_list);
1865 }   break;
1866
1867 #line 2540 "./glsl.g"
1868
1869 case 254: {
1870     sym(1).field_list = StructTypeAST::fixInnerTypes
1871         (makeAstNode<QualifiedTypeAST>
1872             (sym(1).type_qualifier.qualifier, type(2),
1873              sym(1).type_qualifier.layout_list), sym(3).field_list);
1874 }   break;
1875
1876 #line 2550 "./glsl.g"
1877
1878 case 255: {
1879     // nothing to do.
1880     sym(1).field_list = makeAstNode< List<StructTypeAST::Field *> >(sym(1).field);
1881 }   break;
1882
1883 #line 2558 "./glsl.g"
1884
1885 case 256: {
1886     sym(1).field_list = makeAstNode< List<StructTypeAST::Field *> >(sym(1).field_list, sym(3).field);
1887 }   break;
1888
1889 #line 2565 "./glsl.g"
1890
1891 case 257: {
1892     sym(1).field = makeAstNode<StructTypeAST::Field>(string(1));
1893 }   break;
1894
1895 #line 2572 "./glsl.g"
1896
1897 case 258: {
1898     sym(1).field = makeAstNode<StructTypeAST::Field>
1899         (string(1), makeAstNode<ArrayTypeAST>((TypeAST *)0));
1900 }   break;
1901
1902 #line 2580 "./glsl.g"
1903
1904 case 259: {
1905     sym(1).field = makeAstNode<StructTypeAST::Field>
1906         (string(1), makeAstNode<ArrayTypeAST>((TypeAST *)0, expression(3)));
1907 }   break;
1908
1909 #line 2588 "./glsl.g"
1910
1911 case 260: {
1912     // nothing to do.
1913 }   break;
1914
1915 #line 2595 "./glsl.g"
1916
1917 case 261: {
1918     ast(1) = makeAstNode<DeclarationStatementAST>(sym(1).declaration);
1919 }   break;
1920
1921 #line 2602 "./glsl.g"
1922
1923 case 262: {
1924     // nothing to do.
1925 }   break;
1926
1927 #line 2609 "./glsl.g"
1928
1929 case 263: {
1930     // nothing to do.
1931 }   break;
1932
1933 #line 2616 "./glsl.g"
1934
1935 case 264: {
1936     // nothing to do.
1937 }   break;
1938
1939 #line 2623 "./glsl.g"
1940
1941 case 265: {
1942     // nothing to do.
1943 }   break;
1944
1945 #line 2630 "./glsl.g"
1946
1947 case 266: {
1948     // nothing to do.
1949 }   break;
1950
1951 #line 2637 "./glsl.g"
1952
1953 case 267: {
1954     // nothing to do.
1955 }   break;
1956
1957 #line 2644 "./glsl.g"
1958
1959 case 268: {
1960     // nothing to do.
1961 }   break;
1962
1963 #line 2651 "./glsl.g"
1964
1965 case 269: {
1966     // nothing to do.
1967 }   break;
1968
1969 #line 2658 "./glsl.g"
1970
1971 case 270: {
1972     // nothing to do.
1973 }   break;
1974
1975 #line 2665 "./glsl.g"
1976
1977 case 271: {
1978     CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>();
1979     stmt->start = tokenAt(location(1)).begin();
1980     stmt->end = tokenAt(location(2)).end();
1981     ast(1) = stmt;
1982 }   break;
1983
1984 #line 2675 "./glsl.g"
1985
1986 case 272: {
1987     CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>(sym(2).statement_list);
1988     stmt->start = tokenAt(location(1)).begin();
1989     stmt->end = tokenAt(location(3)).end();
1990     ast(1) = stmt;
1991 }   break;
1992
1993 #line 2685 "./glsl.g"
1994
1995 case 273: {
1996     // nothing to do.
1997 }   break;
1998
1999 #line 2692 "./glsl.g"
2000
2001 case 274: {
2002     // nothing to do.
2003 }   break;
2004
2005 #line 2699 "./glsl.g"
2006
2007 case 275: {
2008     CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>();
2009     stmt->start = tokenAt(location(1)).begin();
2010     stmt->end = tokenAt(location(2)).end();
2011     ast(1) = stmt;
2012 }   break;
2013
2014 #line 2709 "./glsl.g"
2015
2016 case 276: {
2017     CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>(sym(2).statement_list);
2018     stmt->start = tokenAt(location(1)).begin();
2019     stmt->end = tokenAt(location(3)).end();
2020     ast(1) = stmt;
2021 }   break;
2022
2023 #line 2719 "./glsl.g"
2024
2025 case 277: {
2026     sym(1).statement_list = makeAstNode< List<StatementAST *> >(sym(1).statement);
2027 }   break;
2028
2029 #line 2726 "./glsl.g"
2030
2031 case 278: {
2032     sym(1).statement_list = makeAstNode< List<StatementAST *> >(sym(1).statement_list, sym(2).statement);
2033 }   break;
2034
2035 #line 2733 "./glsl.g"
2036
2037 case 279: {
2038     ast(1) = makeAstNode<CompoundStatementAST>();  // Empty statement
2039 }   break;
2040
2041 #line 2740 "./glsl.g"
2042
2043 case 280: {
2044     ast(1) = makeAstNode<ExpressionStatementAST>(expression(1));
2045 }   break;
2046
2047 #line 2747 "./glsl.g"
2048
2049 case 281: {
2050     ast(1) = makeAstNode<IfStatementAST>(expression(3), sym(5).ifstmt.thenClause, sym(5).ifstmt.elseClause);
2051 }   break;
2052
2053 #line 2754 "./glsl.g"
2054
2055 case 282: {
2056     sym(1).ifstmt.thenClause = statement(1);
2057     sym(1).ifstmt.elseClause = statement(3);
2058 }   break;
2059
2060 #line 2762 "./glsl.g"
2061
2062 case 283: {
2063     sym(1).ifstmt.thenClause = statement(1);
2064     sym(1).ifstmt.elseClause = 0;
2065 }   break;
2066
2067 #line 2770 "./glsl.g"
2068
2069 case 284: {
2070     // nothing to do.
2071 }   break;
2072
2073 #line 2777 "./glsl.g"
2074
2075 case 285: {
2076     ast(1) = makeAstNode<DeclarationExpressionAST>
2077         (type(1), string(2), expression(4));
2078 }   break;
2079
2080 #line 2785 "./glsl.g"
2081
2082 case 286: {
2083     ast(1) = makeAstNode<SwitchStatementAST>(expression(3), statement(6));
2084 }   break;
2085
2086 #line 2792 "./glsl.g"
2087
2088 case 287: {
2089     ast(1) = makeAstNode<CompoundStatementAST>();
2090 }   break;
2091
2092 #line 2799 "./glsl.g"
2093
2094 case 288: {
2095     ast(1) = makeAstNode<CompoundStatementAST>(sym(1).statement_list);
2096 }   break;
2097
2098 #line 2806 "./glsl.g"
2099
2100 case 289: {
2101     ast(1) = makeAstNode<CaseLabelStatementAST>(expression(2));
2102 }   break;
2103
2104 #line 2813 "./glsl.g"
2105
2106 case 290: {
2107     ast(1) = makeAstNode<CaseLabelStatementAST>();
2108 }   break;
2109
2110 #line 2820 "./glsl.g"
2111
2112 case 291: {
2113     ast(1) = makeAstNode<WhileStatementAST>(expression(3), statement(5));
2114 }   break;
2115
2116 #line 2827 "./glsl.g"
2117
2118 case 292: {
2119     ast(1) = makeAstNode<DoStatementAST>(statement(2), expression(5));
2120 }   break;
2121
2122 #line 2834 "./glsl.g"
2123
2124 case 293: {
2125     ast(1) = makeAstNode<ForStatementAST>(statement(3), sym(4).forstmt.condition, sym(4).forstmt.increment, statement(6));
2126 }   break;
2127
2128 #line 2841 "./glsl.g"
2129
2130 case 294: {
2131     // nothing to do.
2132 }   break;
2133
2134 #line 2848 "./glsl.g"
2135
2136 case 295: {
2137     // nothing to do.
2138 }   break;
2139
2140 #line 2855 "./glsl.g"
2141
2142 case 296: {
2143     // nothing to do.
2144 }   break;
2145
2146 #line 2862 "./glsl.g"
2147
2148 case 297: {
2149     // nothing to do.
2150 }   break;
2151
2152 #line 2869 "./glsl.g"
2153
2154 case 298: {
2155     sym(1).forstmt.condition = expression(1);
2156     sym(1).forstmt.increment = 0;
2157 }   break;
2158
2159 #line 2877 "./glsl.g"
2160
2161 case 299: {
2162     sym(1).forstmt.condition = expression(1);
2163     sym(1).forstmt.increment = expression(3);
2164 }   break;
2165
2166 #line 2885 "./glsl.g"
2167
2168 case 300: {
2169     ast(1) = makeAstNode<JumpStatementAST>(AST::Kind_Continue);
2170 }   break;
2171
2172 #line 2892 "./glsl.g"
2173
2174 case 301: {
2175     ast(1) = makeAstNode<JumpStatementAST>(AST::Kind_Break);
2176 }   break;
2177
2178 #line 2899 "./glsl.g"
2179
2180 case 302: {
2181     ast(1) = makeAstNode<ReturnStatementAST>();
2182 }   break;
2183
2184 #line 2906 "./glsl.g"
2185
2186 case 303: {
2187     ast(1) = makeAstNode<ReturnStatementAST>(expression(2));
2188 }   break;
2189
2190 #line 2913 "./glsl.g"
2191
2192 case 304: {
2193     ast(1) = makeAstNode<JumpStatementAST>(AST::Kind_Discard);
2194 }   break;
2195
2196 #line 2920 "./glsl.g"
2197
2198 case 305: {
2199     ast(1) = makeAstNode<TranslationUnitAST>(sym(1).declaration_list);
2200 }   break;
2201
2202 #line 2927 "./glsl.g"
2203
2204 case 306: {
2205     if (sym(1).declaration) {
2206         sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
2207             (sym(1).declaration);
2208     } else {
2209         sym(1).declaration_list = 0;
2210     }
2211 }   break;
2212
2213 #line 2939 "./glsl.g"
2214
2215 case 307: {
2216     if (sym(1).declaration_list && sym(2).declaration) {
2217         sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
2218             (sym(1).declaration_list, sym(2).declaration);
2219     } else if (!sym(1).declaration_list) {
2220         if (sym(2).declaration) {
2221             sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
2222                 (sym(2).declaration);
2223         } else {
2224             sym(1).declaration_list = 0;
2225         }
2226     }
2227 }   break;
2228
2229 #line 2956 "./glsl.g"
2230
2231 case 308: {
2232     // nothing to do.
2233 }   break;
2234
2235 #line 2963 "./glsl.g"
2236
2237 case 309: {
2238     // nothing to do.
2239 }   break;
2240
2241 #line 2970 "./glsl.g"
2242
2243 case 310: {
2244     ast(1) = 0;
2245 }   break;
2246
2247 #line 2977 "./glsl.g"
2248
2249 case 311: {
2250     function(1)->body = statement(2);
2251 }   break;
2252
2253 #line 2984 "./glsl.g"
2254
2255 case 312: {
2256     ast(1) = 0;
2257 }   break;
2258
2259 #line 2992 "./glsl.g"
2260
2261 case 313: {
2262     ast(1) = ast(2);
2263 }   break;
2264
2265 #line 2999 "./glsl.g"
2266
2267 case 314: {
2268     ast(1) = ast(2);
2269 }   break;
2270
2271 #line 3005 "./glsl.g"
2272
2273 } // end switch
2274 } // end Parser::reduce()