GLSL: Avoid infinite loop at error recovery

For error recovery additional tokens are tried to produce a valid
grammar rule.

For the specific case in the bug report

    for(int x=0; x y

the two consecutive identifiers in the end triggered an infinite loop
since the identifier token is also part of those additional tokens that
are tried.

Circumvent this by trying a more conservative list of tokens on the
second try.

Done-by: Erik Verbruggen
Change-Id: I271dddecf947a06ed3af5f9955ee630441533342
Task-number: QTCREATORBUG-18967
Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>

2 files changed, 353 insertions, 323 deletions

diff --git a/src/libs/glsl/glsl.g b/src/libs/glsl/glsl.g
index 91b2674831..ccd80ae8f1 100644
--- a/src/libs/glsl/glsl.g
+++ b/src/libs/glsl/glsl.g
@@ -519,9 +519,13 @@ AST *Parser::parse(int startToken)
     _recovered = false;
     _tos = -1;
     _startToken.kind = startToken;
+    int recoveryAttempts = 0;
+
 
     do {
-    again:
+        recoveryAttempts = 0;
+
+    againAfterRecovery:
         if (unsigned(++_tos) == _stateStack.size()) {
             _stateStack.resize(_tos * 2);
             _locationStack.resize(_tos * 2);
@@ -564,6 +568,7 @@ AST *Parser::parse(int startToken)
             reduce(ruleno);
             action = nt_action(_stateStack[_tos], lhs[ruleno] - TERMINAL_COUNT);
         } else if (action == 0) {
+            ++recoveryAttempts;
             const int line = _tokens[yyloc].line + 1;
             QString message = QLatin1String("Syntax error");
             if (yytoken != -1) {
@@ -574,7 +579,7 @@ AST *Parser::parse(int startToken)
             for (; _tos; --_tos) {
                 const int state = _stateStack[_tos];
 
-                static int tks[] = {
+                static int tks1[] = {
                     T_RIGHT_BRACE, T_RIGHT_PAREN, T_RIGHT_BRACKET,
                     T_SEMICOLON, T_COLON, T_COMMA,
                     T_NUMBER, T_TYPE_NAME, T_IDENTIFIER,
@@ -582,6 +587,16 @@ AST *Parser::parse(int startToken)
                     T_WHILE,
                     0
                 };
+                static int tks2[] = {
+                    T_RIGHT_BRACE, T_RIGHT_PAREN, T_RIGHT_BRACKET,
+                    T_SEMICOLON, T_COLON, T_COMMA,
+                    0
+                };
+                int *tks;
+                if (recoveryAttempts < 2)
+                    tks = tks1;
+                else
+                    tks = tks2; // Avoid running into an endless loop for e.g.: for(int x=0; x y
 
                 for (int *tptr = tks; *tptr; ++tptr) {
                     const int next = t_action(state, *tptr);
@@ -604,7 +619,7 @@ AST *Parser::parse(int startToken)
                         yytoken = -1;
 
                         action = next;
-                        goto again;
+                        goto againAfterRecovery;
                     }
                 }
             }
diff --git a/src/libs/glsl/glslparser.cpp b/src/libs/glsl/glslparser.cpp
index 1f10c464b2..a746a6050b 100644
--- a/src/libs/glsl/glslparser.cpp
+++ b/src/libs/glsl/glslparser.cpp
@@ -109,9 +109,13 @@ AST *Parser::parse(int startToken)
     _recovered = false;
     _tos = -1;
     _startToken.kind = startToken;
+    int recoveryAttempts = 0;
+
 
     do {
-    again:
+        recoveryAttempts = 0;
+
+    againAfterRecovery:
         if (unsigned(++_tos) == _stateStack.size()) {
             _stateStack.resize(_tos * 2);
             _locationStack.resize(_tos * 2);
@@ -154,6 +158,7 @@ AST *Parser::parse(int startToken)
             reduce(ruleno);
             action = nt_action(_stateStack[_tos], lhs[ruleno] - TERMINAL_COUNT);
         } else if (action == 0) {
+            ++recoveryAttempts;
             const int line = _tokens[yyloc].line + 1;
             QString message = QLatin1String("Syntax error");
             if (yytoken != -1) {
@@ -164,7 +169,7 @@ AST *Parser::parse(int startToken)
             for (; _tos; --_tos) {
                 const int state = _stateStack[_tos];
 
-                static int tks[] = {
+                static int tks1[] = {
                     T_RIGHT_BRACE, T_RIGHT_PAREN, T_RIGHT_BRACKET,
                     T_SEMICOLON, T_COLON, T_COMMA,
                     T_NUMBER, T_TYPE_NAME, T_IDENTIFIER,
@@ -172,6 +177,16 @@ AST *Parser::parse(int startToken)
                     T_WHILE,
                     0
                 };
+                static int tks2[] = {
+                    T_RIGHT_BRACE, T_RIGHT_PAREN, T_RIGHT_BRACKET,
+                    T_SEMICOLON, T_COLON, T_COMMA,
+                    0
+                };
+                int *tks;
+                if (recoveryAttempts < 2)
+                    tks = tks1;
+                else
+                    tks = tks2; // Avoid running into an endless loop for e.g.: for(int x=0; x y
 
                 for (int *tptr = tks; *tptr; ++tptr) {
                     const int next = t_action(state, *tptr);
@@ -194,7 +209,7 @@ AST *Parser::parse(int startToken)
                         yytoken = -1;
 
                         action = next;
-                        goto again;
+                        goto againAfterRecovery;
                     }
                 }
             }
@@ -210,137 +225,137 @@ AST *Parser::parse(int startToken)
     return 0;
 }
 
-#line 626 "./glsl.g"
+#line 641 "./glsl.g"
 
 void Parser::reduce(int ruleno)
 {
 switch(ruleno) {
 
-#line 635 "./glsl.g"
+#line 650 "./glsl.g"
 
 case 0: {
     ast(1) = makeAstNode<IdentifierExpressionAST>(string(1));
 }   break;
 
-#line 642 "./glsl.g"
+#line 657 "./glsl.g"
 
 case 1: {
     ast(1) = makeAstNode<LiteralExpressionAST>(string(1));
 }   break;
 
-#line 649 "./glsl.g"
+#line 664 "./glsl.g"
 
 case 2: {
     ast(1) = makeAstNode<LiteralExpressionAST>(_engine->identifier("true", 4));
 }   break;
 
-#line 656 "./glsl.g"
+#line 671 "./glsl.g"
 
 case 3: {
     ast(1) = makeAstNode<LiteralExpressionAST>(_engine->identifier("false", 5));
 }   break;
 
-#line 663 "./glsl.g"
+#line 678 "./glsl.g"
 
 case 4: {
     // nothing to do.
 }   break;
 
-#line 670 "./glsl.g"
+#line 685 "./glsl.g"
 
 case 5: {
     ast(1) = ast(2);
 }   break;
 
-#line 677 "./glsl.g"
+#line 692 "./glsl.g"
 
 case 6: {
     // nothing to do.
 }   break;
 
-#line 684 "./glsl.g"
+#line 699 "./glsl.g"
 
 case 7: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_ArrayAccess, expression(1), expression(3));
 }   break;
 
-#line 691 "./glsl.g"
+#line 706 "./glsl.g"
 
 case 8: {
     // nothing to do.
 }   break;
 
-#line 698 "./glsl.g"
+#line 713 "./glsl.g"
 
 case 9: {
     ast(1) = makeAstNode<MemberAccessExpressionAST>(expression(1), string(3));
 }   break;
 
-#line 705 "./glsl.g"
+#line 720 "./glsl.g"
 
 case 10: {
     ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PostIncrement, expression(1));
 }   break;
 
-#line 712 "./glsl.g"
+#line 727 "./glsl.g"
 
 case 11: {
     ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PostDecrement, expression(1));
 }   break;
 
-#line 719 "./glsl.g"
+#line 734 "./glsl.g"
 
 case 12: {
     // nothing to do.
 }   break;
 
-#line 726 "./glsl.g"
+#line 741 "./glsl.g"
 
 case 13: {
     // nothing to do.
 }   break;
 
-#line 733 "./glsl.g"
+#line 748 "./glsl.g"
 
 case 14: {
     ast(1) = makeAstNode<FunctionCallExpressionAST>
         (sym(1).function.id, sym(1).function.arguments);
 }   break;
 
-#line 741 "./glsl.g"
+#line 756 "./glsl.g"
 
 case 15: {
     ast(1) = makeAstNode<FunctionCallExpressionAST>
         (expression(1), sym(3).function.id, sym(3).function.arguments);
 }   break;
 
-#line 749 "./glsl.g"
+#line 764 "./glsl.g"
 
 case 16: {
     // nothing to do.
 }   break;
 
-#line 756 "./glsl.g"
+#line 771 "./glsl.g"
 
 case 17: {
     // nothing to do.
 }   break;
 
-#line 763 "./glsl.g"
+#line 778 "./glsl.g"
 
 case 18: {
     sym(1).function.id = sym(1).function_identifier;
     sym(1).function.arguments = 0;
 }   break;
 
-#line 771 "./glsl.g"
+#line 786 "./glsl.g"
 
 case 19: {
     sym(1).function.id = sym(1).function_identifier;
     sym(1).function.arguments = 0;
 }   break;
 
-#line 779 "./glsl.g"
+#line 794 "./glsl.g"
 
 case 20: {
     sym(1).function.id = sym(1).function_identifier;
@@ -348,7 +363,7 @@ case 20: {
         makeAstNode< List<ExpressionAST *> >(expression(2));
 }   break;
 
-#line 788 "./glsl.g"
+#line 803 "./glsl.g"
 
 case 21: {
     sym(1).function.arguments =
@@ -356,379 +371,379 @@ case 21: {
             (sym(1).function.arguments, expression(3));
 }   break;
 
-#line 797 "./glsl.g"
+#line 812 "./glsl.g"
 
 case 22: {
     // nothing to do.
 }   break;
 
-#line 804 "./glsl.g"
+#line 819 "./glsl.g"
 
 case 23: {
     ast(1) = makeAstNode<FunctionIdentifierAST>(type(1));
 }   break;
 
-#line 811 "./glsl.g"
+#line 826 "./glsl.g"
 
 case 24: {
     ast(1) = makeAstNode<FunctionIdentifierAST>(string(1));
 }   break;
 
-#line 818 "./glsl.g"
+#line 833 "./glsl.g"
 
 case 25: {
     // nothing to do.
 }   break;
 
-#line 825 "./glsl.g"
+#line 840 "./glsl.g"
 
 case 26: {
     ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PreIncrement, expression(2));
 }   break;
 
-#line 832 "./glsl.g"
+#line 847 "./glsl.g"
 
 case 27: {
     ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PreDecrement, expression(2));
 }   break;
 
-#line 839 "./glsl.g"
+#line 854 "./glsl.g"
 
 case 28: {
     ast(1) = makeAstNode<UnaryExpressionAST>(sym(1).kind, expression(2));
 }   break;
 
-#line 846 "./glsl.g"
+#line 861 "./glsl.g"
 
 case 29: {
     sym(1).kind = AST::Kind_UnaryPlus;
 }   break;
 
-#line 853 "./glsl.g"
+#line 868 "./glsl.g"
 
 case 30: {
     sym(1).kind = AST::Kind_UnaryMinus;
 }   break;
 
-#line 860 "./glsl.g"
+#line 875 "./glsl.g"
 
 case 31: {
     sym(1).kind = AST::Kind_LogicalNot;
 }   break;
 
-#line 867 "./glsl.g"
+#line 882 "./glsl.g"
 
 case 32: {
     sym(1).kind = AST::Kind_BitwiseNot;
 }   break;
 
-#line 874 "./glsl.g"
+#line 889 "./glsl.g"
 
 case 33: {
     // nothing to do.
 }   break;
 
-#line 881 "./glsl.g"
+#line 896 "./glsl.g"
 
 case 34: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Multiply, expression(1), expression(3));
 }   break;
 
-#line 888 "./glsl.g"
+#line 903 "./glsl.g"
 
 case 35: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Divide, expression(1), expression(3));
 }   break;
 
-#line 895 "./glsl.g"
+#line 910 "./glsl.g"
 
 case 36: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Modulus, expression(1), expression(3));
 }   break;
 
-#line 902 "./glsl.g"
+#line 917 "./glsl.g"
 
 case 37: {
     // nothing to do.
 }   break;
 
-#line 909 "./glsl.g"
+#line 924 "./glsl.g"
 
 case 38: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Plus, expression(1), expression(3));
 }   break;
 
-#line 916 "./glsl.g"
+#line 931 "./glsl.g"
 
 case 39: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Minus, expression(1), expression(3));
 }   break;
 
-#line 923 "./glsl.g"
+#line 938 "./glsl.g"
 
 case 40: {
     // nothing to do.
 }   break;
 
-#line 930 "./glsl.g"
+#line 945 "./glsl.g"
 
 case 41: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_ShiftLeft, expression(1), expression(3));
 }   break;
 
-#line 937 "./glsl.g"
+#line 952 "./glsl.g"
 
 case 42: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_ShiftRight, expression(1), expression(3));
 }   break;
 
-#line 944 "./glsl.g"
+#line 959 "./glsl.g"
 
 case 43: {
     // nothing to do.
 }   break;
 
-#line 951 "./glsl.g"
+#line 966 "./glsl.g"
 
 case 44: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LessThan, expression(1), expression(3));
 }   break;
 
-#line 958 "./glsl.g"
+#line 973 "./glsl.g"
 
 case 45: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_GreaterThan, expression(1), expression(3));
 }   break;
 
-#line 965 "./glsl.g"
+#line 980 "./glsl.g"
 
 case 46: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LessEqual, expression(1), expression(3));
 }   break;
 
-#line 972 "./glsl.g"
+#line 987 "./glsl.g"
 
 case 47: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_GreaterEqual, expression(1), expression(3));
 }   break;
 
-#line 979 "./glsl.g"
+#line 994 "./glsl.g"
 
 case 48: {
     // nothing to do.
 }   break;
 
-#line 986 "./glsl.g"
+#line 1001 "./glsl.g"
 
 case 49: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Equal, expression(1), expression(3));
 }   break;
 
-#line 993 "./glsl.g"
+#line 1008 "./glsl.g"
 
 case 50: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_NotEqual, expression(1), expression(3));
 }   break;
 
-#line 1000 "./glsl.g"
+#line 1015 "./glsl.g"
 
 case 51: {
     // nothing to do.
 }   break;
 
-#line 1007 "./glsl.g"
+#line 1022 "./glsl.g"
 
 case 52: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_BitwiseAnd, expression(1), expression(3));
 }   break;
 
-#line 1014 "./glsl.g"
+#line 1029 "./glsl.g"
 
 case 53: {
     // nothing to do.
 }   break;
 
-#line 1021 "./glsl.g"
+#line 1036 "./glsl.g"
 
 case 54: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_BitwiseXor, expression(1), expression(3));
 }   break;
 
-#line 1028 "./glsl.g"
+#line 1043 "./glsl.g"
 
 case 55: {
     // nothing to do.
 }   break;
 
-#line 1035 "./glsl.g"
+#line 1050 "./glsl.g"
 
 case 56: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_BitwiseOr, expression(1), expression(3));
 }   break;
 
-#line 1042 "./glsl.g"
+#line 1057 "./glsl.g"
 
 case 57: {
     // nothing to do.
 }   break;
 
-#line 1049 "./glsl.g"
+#line 1064 "./glsl.g"
 
 case 58: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LogicalAnd, expression(1), expression(3));
 }   break;
 
-#line 1056 "./glsl.g"
+#line 1071 "./glsl.g"
 
 case 59: {
     // nothing to do.
 }   break;
 
-#line 1063 "./glsl.g"
+#line 1078 "./glsl.g"
 
 case 60: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LogicalXor, expression(1), expression(3));
 }   break;
 
-#line 1070 "./glsl.g"
+#line 1085 "./glsl.g"
 
 case 61: {
     // nothing to do.
 }   break;
 
-#line 1077 "./glsl.g"
+#line 1092 "./glsl.g"
 
 case 62: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LogicalOr, expression(1), expression(3));
 }   break;
 
-#line 1084 "./glsl.g"
+#line 1099 "./glsl.g"
 
 case 63: {
     // nothing to do.
 }   break;
 
-#line 1091 "./glsl.g"
+#line 1106 "./glsl.g"
 
 case 64: {
     ast(1) = makeAstNode<TernaryExpressionAST>(AST::Kind_Conditional, expression(1), expression(3), expression(5));
 }   break;
 
-#line 1098 "./glsl.g"
+#line 1113 "./glsl.g"
 
 case 65: {
     // nothing to do.
 }   break;
 
-#line 1105 "./glsl.g"
+#line 1120 "./glsl.g"
 
 case 66: {
     ast(1) = makeAstNode<AssignmentExpressionAST>(sym(2).kind, expression(1), expression(3));
 }   break;
 
-#line 1112 "./glsl.g"
+#line 1127 "./glsl.g"
 
 case 67: {
     sym(1).kind = AST::Kind_Assign;
 }   break;
 
-#line 1119 "./glsl.g"
+#line 1134 "./glsl.g"
 
 case 68: {
     sym(1).kind = AST::Kind_AssignMultiply;
 }   break;
 
-#line 1126 "./glsl.g"
+#line 1141 "./glsl.g"
 
 case 69: {
     sym(1).kind = AST::Kind_AssignDivide;
 }   break;
 
-#line 1133 "./glsl.g"
+#line 1148 "./glsl.g"
 
 case 70: {
     sym(1).kind = AST::Kind_AssignModulus;
 }   break;
 
-#line 1140 "./glsl.g"
+#line 1155 "./glsl.g"
 
 case 71: {
     sym(1).kind = AST::Kind_AssignPlus;
 }   break;
 
-#line 1147 "./glsl.g"
+#line 1162 "./glsl.g"
 
 case 72: {
     sym(1).kind = AST::Kind_AssignMinus;
 }   break;
 
-#line 1154 "./glsl.g"
+#line 1169 "./glsl.g"
 
 case 73: {
     sym(1).kind = AST::Kind_AssignShiftLeft;
 }   break;
 
-#line 1161 "./glsl.g"
+#line 1176 "./glsl.g"
 
 case 74: {
     sym(1).kind = AST::Kind_AssignShiftRight;
 }   break;
 
-#line 1168 "./glsl.g"
+#line 1183 "./glsl.g"
 
 case 75: {
     sym(1).kind = AST::Kind_AssignAnd;
 }   break;
 
-#line 1175 "./glsl.g"
+#line 1190 "./glsl.g"
 
 case 76: {
     sym(1).kind = AST::Kind_AssignXor;
 }   break;
 
-#line 1182 "./glsl.g"
+#line 1197 "./glsl.g"
 
 case 77: {
     sym(1).kind = AST::Kind_AssignOr;
 }   break;
 
-#line 1189 "./glsl.g"
+#line 1204 "./glsl.g"
 
 case 78: {
     // nothing to do.
 }   break;
 
-#line 1196 "./glsl.g"
+#line 1211 "./glsl.g"
 
 case 79: {
     ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Comma, expression(1), expression(3));
 }   break;
 
-#line 1203 "./glsl.g"
+#line 1218 "./glsl.g"
 
 case 80: {
     // nothing to do.
 }   break;
 
-#line 1210 "./glsl.g"
+#line 1225 "./glsl.g"
 
 case 81: {
     // nothing to do.
 }   break;
 
-#line 1217 "./glsl.g"
+#line 1232 "./glsl.g"
 
 case 82: {
     ast(1) = makeAstNode<InitDeclarationAST>(sym(1).declaration_list);
 }   break;
 
-#line 1224 "./glsl.g"
+#line 1239 "./glsl.g"
 
 case 83: {
     ast(1) = makeAstNode<PrecisionDeclarationAST>(sym(2).precision, type(3));
 }   break;
 
-#line 1231 "./glsl.g"
+#line 1246 "./glsl.g"
 
 case 84: {
     if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) {
@@ -738,7 +753,7 @@ case 84: {
     ast(1) = makeAstNode<TypeDeclarationAST>(type);
 }   break;
 
-#line 1242 "./glsl.g"
+#line 1257 "./glsl.g"
 
 case 85: {
     if ((sym(1).type_qualifier.qualifier & QualifiedTypeAST::Struct) == 0) {
@@ -756,7 +771,7 @@ case 85: {
          makeAstNode<VariableDeclarationAST>(qualtype, string(6)));
 }   break;
 
-#line 1261 "./glsl.g"
+#line 1276 "./glsl.g"
 
 case 86: {
     if ((sym(1).type_qualifier.qualifier & QualifiedTypeAST::Struct) == 0) {
@@ -775,7 +790,7 @@ case 86: {
             (makeAstNode<ArrayTypeAST>(qualtype), string(6)));
 }   break;
 
-#line 1281 "./glsl.g"
+#line 1296 "./glsl.g"
 
 case 87: {
     if ((sym(1).type_qualifier.qualifier & QualifiedTypeAST::Struct) == 0) {
@@ -794,7 +809,7 @@ case 87: {
             (makeAstNode<ArrayTypeAST>(qualtype, expression(8)), string(6)));
 }   break;
 
-#line 1301 "./glsl.g"
+#line 1316 "./glsl.g"
 
 case 88: {
     TypeAST *type = makeAstNode<QualifiedTypeAST>
@@ -803,59 +818,59 @@ case 88: {
     ast(1) = makeAstNode<TypeDeclarationAST>(type);
 }   break;
 
-#line 1311 "./glsl.g"
+#line 1326 "./glsl.g"
 
 case 89: {
     function(1)->finishParams();
 }   break;
 
-#line 1318 "./glsl.g"
+#line 1333 "./glsl.g"
 
 case 90: {
     // nothing to do.
 }   break;
 
-#line 1325 "./glsl.g"
+#line 1340 "./glsl.g"
 
 case 91: {
     // nothing to do.
 }   break;
 
-#line 1332 "./glsl.g"
+#line 1347 "./glsl.g"
 
 case 92: {
     function(1)->params = makeAstNode< List<ParameterDeclarationAST *> >
         (sym(2).param_declaration);
 }   break;
 
-#line 1340 "./glsl.g"
+#line 1355 "./glsl.g"
 
 case 93: {
     function(1)->params = makeAstNode< List<ParameterDeclarationAST *> >
         (function(1)->params, sym(3).param_declaration);
 }   break;
 
-#line 1348 "./glsl.g"
+#line 1363 "./glsl.g"
 
 case 94: {
     function(1) = makeAstNode<FunctionDeclarationAST>(type(1), string(2));
 }   break;
 
-#line 1355 "./glsl.g"
+#line 1370 "./glsl.g"
 
 case 95: {
     sym(1).param_declarator.type = type(1);
     sym(1).param_declarator.name = string(2);
 }   break;
 
-#line 1363 "./glsl.g"
+#line 1378 "./glsl.g"
 
 case 96: {
     sym(1).param_declarator.type = makeAstNode<ArrayTypeAST>(type(1), expression(4));
     sym(1).param_declarator.name = string(2);
 }   break;
 
-#line 1371 "./glsl.g"
+#line 1386 "./glsl.g"
 
 case 97: {
     ast(1) = makeAstNode<ParameterDeclarationAST>
@@ -866,7 +881,7 @@ case 97: {
          sym(3).param_declarator.name);
 }   break;
 
-#line 1383 "./glsl.g"
+#line 1398 "./glsl.g"
 
 case 98: {
     ast(1) = makeAstNode<ParameterDeclarationAST>
@@ -875,7 +890,7 @@ case 98: {
          sym(2).param_declarator.name);
 }   break;
 
-#line 1393 "./glsl.g"
+#line 1408 "./glsl.g"
 
 case 99: {
     ast(1) = makeAstNode<ParameterDeclarationAST>
@@ -885,7 +900,7 @@ case 99: {
          (const QString *)0);
 }   break;
 
-#line 1404 "./glsl.g"
+#line 1419 "./glsl.g"
 
 case 100: {
     ast(1) = makeAstNode<ParameterDeclarationAST>
@@ -893,44 +908,44 @@ case 100: {
          (const QString *)0);
 }   break;
 
-#line 1413 "./glsl.g"
+#line 1428 "./glsl.g"
 
 case 101: {
     sym(1).qualifier = ParameterDeclarationAST::In;
 }   break;
 
-#line 1420 "./glsl.g"
+#line 1435 "./glsl.g"
 
 case 102: {
     sym(1).qualifier = ParameterDeclarationAST::In;
 }   break;
 
-#line 1427 "./glsl.g"
+#line 1442 "./glsl.g"
 
 case 103: {
     sym(1).qualifier = ParameterDeclarationAST::Out;
 }   break;
 
-#line 1434 "./glsl.g"
+#line 1449 "./glsl.g"
 
 case 104: {
     sym(1).qualifier = ParameterDeclarationAST::InOut;
 }   break;
 
-#line 1441 "./glsl.g"
+#line 1456 "./glsl.g"
 
 case 105: {
     // nothing to do.
 }   break;
 
-#line 1448 "./glsl.g"
+#line 1463 "./glsl.g"
 
 case 106: {
     sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
         (sym(1).declaration);
 }   break;
 
-#line 1456 "./glsl.g"
+#line 1471 "./glsl.g"
 
 case 107: {
     TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
@@ -939,7 +954,7 @@ case 107: {
             (sym(1).declaration_list, decl);
 }   break;
 
-#line 1466 "./glsl.g"
+#line 1481 "./glsl.g"
 
 case 108: {
     TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
@@ -949,7 +964,7 @@ case 108: {
             (sym(1).declaration_list, decl);
 }   break;
 
-#line 1477 "./glsl.g"
+#line 1492 "./glsl.g"
 
 case 109: {
     TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
@@ -959,7 +974,7 @@ case 109: {
             (sym(1).declaration_list, decl);
 }   break;
 
-#line 1488 "./glsl.g"
+#line 1503 "./glsl.g"
 
 case 110: {
     TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
@@ -970,7 +985,7 @@ case 110: {
             (sym(1).declaration_list, decl);
 }   break;
 
-#line 1500 "./glsl.g"
+#line 1515 "./glsl.g"
 
 case 111: {
     TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
@@ -981,7 +996,7 @@ case 111: {
             (sym(1).declaration_list, decl);
 }   break;
 
-#line 1512 "./glsl.g"
+#line 1527 "./glsl.g"
 
 case 112: {
     TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
@@ -991,40 +1006,40 @@ case 112: {
             (sym(1).declaration_list, decl);
 }   break;
 
-#line 1523 "./glsl.g"
+#line 1538 "./glsl.g"
 
 case 113: {
     ast(1) = makeAstNode<TypeDeclarationAST>(type(1));
 }   break;
 
-#line 1530 "./glsl.g"
+#line 1545 "./glsl.g"
 
 case 114: {
     ast(1) = makeAstNode<VariableDeclarationAST>(type(1), string(2));
 }   break;
 
-#line 1537 "./glsl.g"
+#line 1552 "./glsl.g"
 
 case 115: {
     ast(1) = makeAstNode<VariableDeclarationAST>
         (makeAstNode<ArrayTypeAST>(type(1)), string(2));
 }   break;
 
-#line 1545 "./glsl.g"
+#line 1560 "./glsl.g"
 
 case 116: {
     ast(1) = makeAstNode<VariableDeclarationAST>
         (makeAstNode<ArrayTypeAST>(type(1), expression(4)), string(2));
 }   break;
 
-#line 1553 "./glsl.g"
+#line 1568 "./glsl.g"
 
 case 117: {
     ast(1) = makeAstNode<VariableDeclarationAST>
         (makeAstNode<ArrayTypeAST>(type(1)), string(2), expression(6));
 }   break;
 
-#line 1561 "./glsl.g"
+#line 1576 "./glsl.g"
 
 case 118: {
     ast(1) = makeAstNode<VariableDeclarationAST>
@@ -1032,26 +1047,26 @@ case 118: {
          string(2), expression(7));
 }   break;
 
-#line 1570 "./glsl.g"
+#line 1585 "./glsl.g"
 
 case 119: {
     ast(1) = makeAstNode<VariableDeclarationAST>
         (type(1), string(2), expression(4));
 }   break;
 
-#line 1578 "./glsl.g"
+#line 1593 "./glsl.g"
 
 case 120: {
     ast(1) = makeAstNode<InvariantDeclarationAST>(string(2));
 }   break;
 
-#line 1585 "./glsl.g"
+#line 1600 "./glsl.g"
 
 case 121: {
     ast(1) = makeAstNode<QualifiedTypeAST>(0, type(1), (List<LayoutQualifierAST *> *)0);
 }   break;
 
-#line 1592 "./glsl.g"
+#line 1607 "./glsl.g"
 
 case 122: {
     ast(1) = makeAstNode<QualifiedTypeAST>
@@ -1059,207 +1074,207 @@ case 122: {
          sym(1).type_qualifier.layout_list);
 }   break;
 
-#line 1601 "./glsl.g"
+#line 1616 "./glsl.g"
 
 case 123: {
     sym(1).qualifier = QualifiedTypeAST::Invariant;
 }   break;
 
-#line 1608 "./glsl.g"
+#line 1623 "./glsl.g"
 
 case 124: {
     sym(1).qualifier = QualifiedTypeAST::Smooth;
 }   break;
 
-#line 1615 "./glsl.g"
+#line 1630 "./glsl.g"
 
 case 125: {
     sym(1).qualifier = QualifiedTypeAST::Flat;
 }   break;
 
-#line 1622 "./glsl.g"
+#line 1637 "./glsl.g"
 
 case 126: {
     sym(1).qualifier = QualifiedTypeAST::NoPerspective;
 }   break;
 
-#line 1629 "./glsl.g"
+#line 1644 "./glsl.g"
 
 case 127: {
     sym(1) = sym(3);
 }   break;
 
-#line 1636 "./glsl.g"
+#line 1651 "./glsl.g"
 
 case 128: {
     sym(1).layout_list = makeAstNode< List<LayoutQualifierAST *> >(sym(1).layout);
 }   break;
 
-#line 1643 "./glsl.g"
+#line 1658 "./glsl.g"
 
 case 129: {
     sym(1).layout_list = makeAstNode< List<LayoutQualifierAST *> >(sym(1).layout_list, sym(3).layout);
 }   break;
 
-#line 1650 "./glsl.g"
+#line 1665 "./glsl.g"
 
 case 130: {
     sym(1).layout = makeAstNode<LayoutQualifierAST>(string(1), (const QString *)0);
 }   break;
 
-#line 1657 "./glsl.g"
+#line 1672 "./glsl.g"
 
 case 131: {
     sym(1).layout = makeAstNode<LayoutQualifierAST>(string(1), string(3));
 }   break;
 
-#line 1664 "./glsl.g"
+#line 1679 "./glsl.g"
 
 case 132: {
     sym(1).qualifier = QualifiedTypeAST::Const;
 }   break;
 
-#line 1671 "./glsl.g"
+#line 1686 "./glsl.g"
 
 case 133: {
     sym(1).type_qualifier.qualifier = sym(1).qualifier;
     sym(1).type_qualifier.layout_list = 0;
 }   break;
 
-#line 1679 "./glsl.g"
+#line 1694 "./glsl.g"
 
 case 134: {
     sym(1).type_qualifier.layout_list = sym(1).layout_list;
     sym(1).type_qualifier.qualifier = 0;
 }   break;
 
-#line 1687 "./glsl.g"
+#line 1702 "./glsl.g"
 
 case 135: {
     sym(1).type_qualifier.layout_list = sym(1).layout_list;
     sym(1).type_qualifier.qualifier = sym(2).qualifier;
 }   break;
 
-#line 1695 "./glsl.g"
+#line 1710 "./glsl.g"
 
 case 136: {
     sym(1).type_qualifier.qualifier = sym(1).qualifier | sym(2).qualifier;
     sym(1).type_qualifier.layout_list = 0;
 }   break;
 
-#line 1703 "./glsl.g"
+#line 1718 "./glsl.g"
 
 case 137: {
     sym(1).type_qualifier.qualifier = sym(1).qualifier;
     sym(1).type_qualifier.layout_list = 0;
 }   break;
 
-#line 1711 "./glsl.g"
+#line 1726 "./glsl.g"
 
 case 138: {
     sym(1).type_qualifier.qualifier = sym(1).qualifier | sym(2).qualifier;
     sym(1).type_qualifier.layout_list = 0;
 }   break;
 
-#line 1719 "./glsl.g"
+#line 1734 "./glsl.g"
 
 case 139: {
     sym(1).type_qualifier.qualifier = sym(1).qualifier | sym(2).qualifier | sym(3).qualifier;
     sym(1).type_qualifier.layout_list = 0;
 }   break;
 
-#line 1727 "./glsl.g"
+#line 1742 "./glsl.g"
 
 case 140: {
     sym(1).type_qualifier.qualifier = QualifiedTypeAST::Invariant;
     sym(1).type_qualifier.layout_list = 0;
 }   break;
 
-#line 1735 "./glsl.g"
+#line 1750 "./glsl.g"
 
 case 141: {
     sym(1).qualifier = QualifiedTypeAST::Const;
 }   break;
 
-#line 1742 "./glsl.g"
+#line 1757 "./glsl.g"
 
 case 142: {
     sym(1).qualifier = QualifiedTypeAST::Attribute;
 }   break;
 
-#line 1749 "./glsl.g"
+#line 1764 "./glsl.g"
 
 case 143: {
     sym(1).qualifier = QualifiedTypeAST::Varying;
 }   break;
 
-#line 1756 "./glsl.g"
+#line 1771 "./glsl.g"
 
 case 144: {
     sym(1).qualifier = QualifiedTypeAST::CentroidVarying;
 }   break;
 
-#line 1763 "./glsl.g"
+#line 1778 "./glsl.g"
 
 case 145: {
     sym(1).qualifier = QualifiedTypeAST::In;
 }   break;
 
-#line 1770 "./glsl.g"
+#line 1785 "./glsl.g"
 
 case 146: {
     sym(1).qualifier = QualifiedTypeAST::Out;
 }   break;
 
-#line 1777 "./glsl.g"
+#line 1792 "./glsl.g"
 
 case 147: {
     sym(1).qualifier = QualifiedTypeAST::CentroidIn;
 }   break;
 
-#line 1784 "./glsl.g"
+#line 1799 "./glsl.g"
 
 case 148: {
     sym(1).qualifier = QualifiedTypeAST::CentroidOut;
 }   break;
 
-#line 1791 "./glsl.g"
+#line 1806 "./glsl.g"
 
 case 149: {
     sym(1).qualifier = QualifiedTypeAST::PatchIn;
 }   break;
 
-#line 1798 "./glsl.g"
+#line 1813 "./glsl.g"
 
 case 150: {
     sym(1).qualifier = QualifiedTypeAST::PatchOut;
 }   break;
 
-#line 1805 "./glsl.g"
+#line 1820 "./glsl.g"
 
 case 151: {
     sym(1).qualifier = QualifiedTypeAST::SampleIn;
 }   break;
 
-#line 1812 "./glsl.g"
+#line 1827 "./glsl.g"
 
 case 152: {
     sym(1).qualifier = QualifiedTypeAST::SampleOut;
 }   break;
 
-#line 1819 "./glsl.g"
+#line 1834 "./glsl.g"
 
 case 153: {
     sym(1).qualifier = QualifiedTypeAST::Uniform;
 }   break;
 
-#line 1826 "./glsl.g"
+#line 1841 "./glsl.g"
 
 case 154: {
     // nothing to do.
 }   break;
 
-#line 1833 "./glsl.g"
+#line 1848 "./glsl.g"
 
 case 155: {
     if (!type(2)->setPrecision(sym(1).precision)) {
@@ -1268,595 +1283,595 @@ case 155: {
     ast(1) = type(2);
 }   break;
 
-#line 1843 "./glsl.g"
+#line 1858 "./glsl.g"
 
 case 156: {
     // nothing to do.
 }   break;
 
-#line 1850 "./glsl.g"
+#line 1865 "./glsl.g"
 
 case 157: {
     ast(1) = makeAstNode<ArrayTypeAST>(type(1));
 }   break;
 
-#line 1857 "./glsl.g"
+#line 1872 "./glsl.g"
 
 case 158: {
     ast(1) = makeAstNode<ArrayTypeAST>(type(1), expression(3));
 }   break;
 
-#line 1864 "./glsl.g"
+#line 1879 "./glsl.g"
 
 case 159: {
     ast(1) = makeBasicType(T_VOID);
 }   break;
 
-#line 1871 "./glsl.g"
+#line 1886 "./glsl.g"
 
 case 160: {
     ast(1) = makeBasicType(T_FLOAT);
 }   break;
 
-#line 1878 "./glsl.g"
+#line 1893 "./glsl.g"
 
 case 161: {
     ast(1) = makeBasicType(T_DOUBLE);
 }   break;
 
-#line 1885 "./glsl.g"
+#line 1900 "./glsl.g"
 
 case 162: {
     ast(1) = makeBasicType(T_INT);
 }   break;
 
-#line 1892 "./glsl.g"
+#line 1907 "./glsl.g"
 
 case 163: {
     ast(1) = makeBasicType(T_UINT);
 }   break;
 
-#line 1899 "./glsl.g"
+#line 1914 "./glsl.g"
 
 case 164: {
     ast(1) = makeBasicType(T_BOOL);
 }   break;
 
-#line 1906 "./glsl.g"
+#line 1921 "./glsl.g"
 
 case 165: {
     ast(1) = makeBasicType(T_VEC2);
 }   break;
 
-#line 1913 "./glsl.g"
+#line 1928 "./glsl.g"
 
 case 166: {
     ast(1) = makeBasicType(T_VEC3);
 }   break;
 
-#line 1920 "./glsl.g"
+#line 1935 "./glsl.g"
 
 case 167: {
     ast(1) = makeBasicType(T_VEC4);
 }   break;
 
-#line 1927 "./glsl.g"
+#line 1942 "./glsl.g"
 
 case 168: {
     ast(1) = makeBasicType(T_DVEC2);
 }   break;
 
-#line 1934 "./glsl.g"
+#line 1949 "./glsl.g"
 
 case 169: {
     ast(1) = makeBasicType(T_DVEC3);
 }   break;
 
-#line 1941 "./glsl.g"
+#line 1956 "./glsl.g"
 
 case 170: {
     ast(1) = makeBasicType(T_DVEC4);
 }   break;
 
-#line 1948 "./glsl.g"
+#line 1963 "./glsl.g"
 
 case 171: {
     ast(1) = makeBasicType(T_BVEC2);
 }   break;
 
-#line 1955 "./glsl.g"
+#line 1970 "./glsl.g"
 
 case 172: {
     ast(1) = makeBasicType(T_BVEC3);
 }   break;
 
-#line 1962 "./glsl.g"
+#line 1977 "./glsl.g"
 
 case 173: {
     ast(1) = makeBasicType(T_BVEC4);
 }   break;
 
-#line 1969 "./glsl.g"
+#line 1984 "./glsl.g"
 
 case 174: {
     ast(1) = makeBasicType(T_IVEC2);
 }   break;
 
-#line 1976 "./glsl.g"
+#line 1991 "./glsl.g"
 
 case 175: {
     ast(1) = makeBasicType(T_IVEC3);
 }   break;
 
-#line 1983 "./glsl.g"
+#line 1998 "./glsl.g"
 
 case 176: {
     ast(1) = makeBasicType(T_IVEC4);
 }   break;
 
-#line 1990 "./glsl.g"
+#line 2005 "./glsl.g"
 
 case 177: {
     ast(1) = makeBasicType(T_UVEC2);
 }   break;
 
-#line 1997 "./glsl.g"
+#line 2012 "./glsl.g"
 
 case 178: {
     ast(1) = makeBasicType(T_UVEC3);
 }   break;
 
-#line 2004 "./glsl.g"
+#line 2019 "./glsl.g"
 
 case 179: {
     ast(1) = makeBasicType(T_UVEC4);
 }   break;
 
-#line 2011 "./glsl.g"
+#line 2026 "./glsl.g"
 
 case 180: {
     ast(1) = makeBasicType(T_MAT2);
 }   break;
 
-#line 2018 "./glsl.g"
+#line 2033 "./glsl.g"
 
 case 181: {
     ast(1) = makeBasicType(T_MAT3);
 }   break;
 
-#line 2025 "./glsl.g"
+#line 2040 "./glsl.g"
 
 case 182: {
     ast(1) = makeBasicType(T_MAT4);
 }   break;
 
-#line 2032 "./glsl.g"
+#line 2047 "./glsl.g"
 
 case 183: {
     ast(1) = makeBasicType(T_MAT2);
 }   break;
 
-#line 2039 "./glsl.g"
+#line 2054 "./glsl.g"
 
 case 184: {
     ast(1) = makeBasicType(T_MAT2X3);
 }   break;
 
-#line 2046 "./glsl.g"
+#line 2061 "./glsl.g"
 
 case 185: {
     ast(1) = makeBasicType(T_MAT2X4);
 }   break;
 
-#line 2053 "./glsl.g"
+#line 2068 "./glsl.g"
 
 case 186: {
     ast(1) = makeBasicType(T_MAT3X2);
 }   break;
 
-#line 2060 "./glsl.g"
+#line 2075 "./glsl.g"
 
 case 187: {
     ast(1) = makeBasicType(T_MAT3);
 }   break;
 
-#line 2067 "./glsl.g"
+#line 2082 "./glsl.g"
 
 case 188: {
     ast(1) = makeBasicType(T_MAT3X4);
 }   break;
 
-#line 2074 "./glsl.g"
+#line 2089 "./glsl.g"
 
 case 189: {
     ast(1) = makeBasicType(T_MAT4X2);
 }   break;
 
-#line 2081 "./glsl.g"
+#line 2096 "./glsl.g"
 
 case 190: {
     ast(1) = makeBasicType(T_MAT4X3);
 }   break;
 
-#line 2088 "./glsl.g"
+#line 2103 "./glsl.g"
 
 case 191: {
     ast(1) = makeBasicType(T_MAT4);
 }   break;
 
-#line 2095 "./glsl.g"
+#line 2110 "./glsl.g"
 
 case 192: {
     ast(1) = makeBasicType(T_DMAT2);
 }   break;
 
-#line 2102 "./glsl.g"
+#line 2117 "./glsl.g"
 
 case 193: {
     ast(1) = makeBasicType(T_DMAT3);
 }   break;
 
-#line 2109 "./glsl.g"
+#line 2124 "./glsl.g"
 
 case 194: {
     ast(1) = makeBasicType(T_DMAT4);
 }   break;
 
-#line 2116 "./glsl.g"
+#line 2131 "./glsl.g"
 
 case 195: {
     ast(1) = makeBasicType(T_DMAT2);
 }   break;
 
-#line 2123 "./glsl.g"
+#line 2138 "./glsl.g"
 
 case 196: {
     ast(1) = makeBasicType(T_DMAT2X3);
 }   break;
 
-#line 2130 "./glsl.g"
+#line 2145 "./glsl.g"
 
 case 197: {
     ast(1) = makeBasicType(T_DMAT2X4);
 }   break;
 
-#line 2137 "./glsl.g"
+#line 2152 "./glsl.g"
 
 case 198: {
     ast(1) = makeBasicType(T_DMAT3X2);
 }   break;
 
-#line 2144 "./glsl.g"
+#line 2159 "./glsl.g"
 
 case 199: {
     ast(1) = makeBasicType(T_DMAT3);
 }   break;
 
-#line 2151 "./glsl.g"
+#line 2166 "./glsl.g"
 
 case 200: {
     ast(1) = makeBasicType(T_DMAT3X4);
 }   break;
 
-#line 2158 "./glsl.g"
+#line 2173 "./glsl.g"
 
 case 201: {
     ast(1) = makeBasicType(T_DMAT4X2);
 }   break;
 
-#line 2165 "./glsl.g"
+#line 2180 "./glsl.g"
 
 case 202: {
     ast(1) = makeBasicType(T_DMAT4X3);
 }   break;
 
-#line 2172 "./glsl.g"
+#line 2187 "./glsl.g"
 
 case 203: {
     ast(1) = makeBasicType(T_DMAT4);
 }   break;
 
-#line 2179 "./glsl.g"
+#line 2194 "./glsl.g"
 
 case 204: {
     ast(1) = makeBasicType(T_SAMPLER1D);
 }   break;
 
-#line 2186 "./glsl.g"
+#line 2201 "./glsl.g"
 
 case 205: {
     ast(1) = makeBasicType(T_SAMPLER2D);
 }   break;
 
-#line 2193 "./glsl.g"
+#line 2208 "./glsl.g"
 
 case 206: {
     ast(1) = makeBasicType(T_SAMPLER3D);
 }   break;
 
-#line 2200 "./glsl.g"
+#line 2215 "./glsl.g"
 
 case 207: {
     ast(1) = makeBasicType(T_SAMPLERCUBE);
 }   break;
 
-#line 2207 "./glsl.g"
+#line 2222 "./glsl.g"
 
 case 208: {
     ast(1) = makeBasicType(T_SAMPLER1DSHADOW);
 }   break;
 
-#line 2214 "./glsl.g"
+#line 2229 "./glsl.g"
 
 case 209: {
     ast(1) = makeBasicType(T_SAMPLER2DSHADOW);
 }   break;
 
-#line 2221 "./glsl.g"
+#line 2236 "./glsl.g"
 
 case 210: {
     ast(1) = makeBasicType(T_SAMPLERCUBESHADOW);
 }   break;
 
-#line 2228 "./glsl.g"
+#line 2243 "./glsl.g"
 
 case 211: {
     ast(1) = makeBasicType(T_SAMPLER1DARRAY);
 }   break;
 
-#line 2235 "./glsl.g"
+#line 2250 "./glsl.g"
 
 case 212: {
     ast(1) = makeBasicType(T_SAMPLER2DARRAY);
 }   break;
 
-#line 2242 "./glsl.g"
+#line 2257 "./glsl.g"
 
 case 213: {
     ast(1) = makeBasicType(T_SAMPLER1DARRAYSHADOW);
 }   break;
 
-#line 2249 "./glsl.g"
+#line 2264 "./glsl.g"
 
 case 214: {
     ast(1) = makeBasicType(T_SAMPLER2DARRAYSHADOW);
 }   break;
 
-#line 2256 "./glsl.g"
+#line 2271 "./glsl.g"
 
 case 215: {
     ast(1) = makeBasicType(T_SAMPLERCUBEARRAY);
 }   break;
 
-#line 2263 "./glsl.g"
+#line 2278 "./glsl.g"
 
 case 216: {
     ast(1) = makeBasicType(T_SAMPLERCUBEARRAYSHADOW);
 }   break;
 
-#line 2270 "./glsl.g"
+#line 2285 "./glsl.g"
 
 case 217: {
     ast(1) = makeBasicType(T_ISAMPLER1D);
 }   break;
 
-#line 2277 "./glsl.g"
+#line 2292 "./glsl.g"
 
 case 218: {
     ast(1) = makeBasicType(T_ISAMPLER2D);
 }   break;
 
-#line 2284 "./glsl.g"
+#line 2299 "./glsl.g"
 
 case 219: {
     ast(1) = makeBasicType(T_ISAMPLER3D);
 }   break;
 
-#line 2291 "./glsl.g"
+#line 2306 "./glsl.g"
 
 case 220: {
     ast(1) = makeBasicType(T_ISAMPLERCUBE);
 }   break;
 
-#line 2298 "./glsl.g"
+#line 2313 "./glsl.g"
 
 case 221: {
     ast(1) = makeBasicType(T_ISAMPLER1DARRAY);
 }   break;
 
-#line 2305 "./glsl.g"
+#line 2320 "./glsl.g"
 
 case 222: {
     ast(1) = makeBasicType(T_ISAMPLER2DARRAY);
 }   break;
 
-#line 2312 "./glsl.g"
+#line 2327 "./glsl.g"
 
 case 223: {
     ast(1) = makeBasicType(T_ISAMPLERCUBEARRAY);
 }   break;
 
-#line 2319 "./glsl.g"
+#line 2334 "./glsl.g"
 
 case 224: {
     ast(1) = makeBasicType(T_USAMPLER1D);
 }   break;
 
-#line 2326 "./glsl.g"
+#line 2341 "./glsl.g"
 
 case 225: {
     ast(1) = makeBasicType(T_USAMPLER2D);
 }   break;
 
-#line 2333 "./glsl.g"
+#line 2348 "./glsl.g"
 
 case 226: {
     ast(1) = makeBasicType(T_USAMPLER3D);
 }   break;
 
-#line 2340 "./glsl.g"
+#line 2355 "./glsl.g"
 
 case 227: {
     ast(1) = makeBasicType(T_USAMPLERCUBE);
 }   break;
 
-#line 2347 "./glsl.g"
+#line 2362 "./glsl.g"
 
 case 228: {
     ast(1) = makeBasicType(T_USAMPLER1DARRAY);
 }   break;
 
-#line 2354 "./glsl.g"
+#line 2369 "./glsl.g"
 
 case 229: {
     ast(1) = makeBasicType(T_USAMPLER2DARRAY);
 }   break;
 
-#line 2361 "./glsl.g"
+#line 2376 "./glsl.g"
 
 case 230: {
     ast(1) = makeBasicType(T_USAMPLERCUBEARRAY);
 }   break;
 
-#line 2368 "./glsl.g"
+#line 2383 "./glsl.g"
 
 case 231: {
     ast(1) = makeBasicType(T_SAMPLER2DRECT);
 }   break;
 
-#line 2375 "./glsl.g"
+#line 2390 "./glsl.g"
 
 case 232: {
     ast(1) = makeBasicType(T_SAMPLER2DRECTSHADOW);
 }   break;
 
-#line 2382 "./glsl.g"
+#line 2397 "./glsl.g"
 
 case 233: {
     ast(1) = makeBasicType(T_ISAMPLER2DRECT);
 }   break;
 
-#line 2389 "./glsl.g"
+#line 2404 "./glsl.g"
 
 case 234: {
     ast(1) = makeBasicType(T_USAMPLER2DRECT);
 }   break;
 
-#line 2396 "./glsl.g"
+#line 2411 "./glsl.g"
 
 case 235: {
     ast(1) = makeBasicType(T_SAMPLERBUFFER);
 }   break;
 
-#line 2403 "./glsl.g"
+#line 2418 "./glsl.g"
 
 case 236: {
     ast(1) = makeBasicType(T_ISAMPLERBUFFER);
 }   break;
 
-#line 2410 "./glsl.g"
+#line 2425 "./glsl.g"
 
 case 237: {
     ast(1) = makeBasicType(T_USAMPLERBUFFER);
 }   break;
 
-#line 2417 "./glsl.g"
+#line 2432 "./glsl.g"
 
 case 238: {
     ast(1) = makeBasicType(T_SAMPLER2DMS);
 }   break;
 
-#line 2424 "./glsl.g"
+#line 2439 "./glsl.g"
 
 case 239: {
     ast(1) = makeBasicType(T_ISAMPLER2DMS);
 }   break;
 
-#line 2431 "./glsl.g"
+#line 2446 "./glsl.g"
 
 case 240: {
     ast(1) = makeBasicType(T_USAMPLER2DMS);
 }   break;
 
-#line 2438 "./glsl.g"
+#line 2453 "./glsl.g"
 
 case 241: {
     ast(1) = makeBasicType(T_SAMPLER2DMSARRAY);
 }   break;
 
-#line 2445 "./glsl.g"
+#line 2460 "./glsl.g"
 
 case 242: {
     ast(1) = makeBasicType(T_ISAMPLER2DMSARRAY);
 }   break;
 
-#line 2452 "./glsl.g"
+#line 2467 "./glsl.g"
 
 case 243: {
     ast(1) = makeBasicType(T_USAMPLER2DMSARRAY);
 }   break;
 
-#line 2459 "./glsl.g"
+#line 2474 "./glsl.g"
 
 case 244: {
     // nothing to do.
 }   break;
 
-#line 2466 "./glsl.g"
+#line 2481 "./glsl.g"
 
 case 245: {
     ast(1) = makeAstNode<NamedTypeAST>(string(1));
 }   break;
 
-#line 2473 "./glsl.g"
+#line 2488 "./glsl.g"
 
 case 246: {
     sym(1).precision = TypeAST::Highp;
 }   break;
 
-#line 2480 "./glsl.g"
+#line 2495 "./glsl.g"
 
 case 247: {
     sym(1).precision = TypeAST::Mediump;
 }   break;
 
-#line 2487 "./glsl.g"
+#line 2502 "./glsl.g"
 
 case 248: {
     sym(1).precision = TypeAST::Lowp;
 }   break;
 
-#line 2494 "./glsl.g"
+#line 2509 "./glsl.g"
 
 case 249: {
     ast(1) = makeAstNode<StructTypeAST>(string(2), sym(4).field_list);
 }   break;
 
-#line 2501 "./glsl.g"
+#line 2516 "./glsl.g"
 
 case 250: {
     ast(1) = makeAstNode<StructTypeAST>(sym(3).field_list);
 }   break;
 
-#line 2508 "./glsl.g"
+#line 2523 "./glsl.g"
 
 case 251: {
     // nothing to do.
 }   break;
 
-#line 2515 "./glsl.g"
+#line 2530 "./glsl.g"
 
 case 252: {
     sym(1).field_list = appendLists(sym(1).field_list, sym(2).field_list);
 }   break;
 
-#line 2522 "./glsl.g"
+#line 2537 "./glsl.g"
 
 case 253: {
     sym(1).field_list = StructTypeAST::fixInnerTypes(type(1), sym(2).field_list);
 }   break;
 
-#line 2529 "./glsl.g"
+#line 2544 "./glsl.g"
 
 case 254: {
     sym(1).field_list = StructTypeAST::fixInnerTypes
@@ -1865,106 +1880,106 @@ case 254: {
              sym(1).type_qualifier.layout_list), sym(3).field_list);
 }   break;
 
-#line 2539 "./glsl.g"
+#line 2554 "./glsl.g"
 
 case 255: {
     // nothing to do.
     sym(1).field_list = makeAstNode< List<StructTypeAST::Field *> >(sym(1).field);
 }   break;
 
-#line 2547 "./glsl.g"
+#line 2562 "./glsl.g"
 
 case 256: {
     sym(1).field_list = makeAstNode< List<StructTypeAST::Field *> >(sym(1).field_list, sym(3).field);
 }   break;
 
-#line 2554 "./glsl.g"
+#line 2569 "./glsl.g"
 
 case 257: {
     sym(1).field = makeAstNode<StructTypeAST::Field>(string(1));
 }   break;
 
-#line 2561 "./glsl.g"
+#line 2576 "./glsl.g"
 
 case 258: {
     sym(1).field = makeAstNode<StructTypeAST::Field>
         (string(1), makeAstNode<ArrayTypeAST>((TypeAST *)0));
 }   break;
 
-#line 2569 "./glsl.g"
+#line 2584 "./glsl.g"
 
 case 259: {
     sym(1).field = makeAstNode<StructTypeAST::Field>
         (string(1), makeAstNode<ArrayTypeAST>((TypeAST *)0, expression(3)));
 }   break;
 
-#line 2577 "./glsl.g"
+#line 2592 "./glsl.g"
 
 case 260: {
     // nothing to do.
 }   break;
 
-#line 2584 "./glsl.g"
+#line 2599 "./glsl.g"
 
 case 261: {
     ast(1) = makeAstNode<DeclarationStatementAST>(sym(1).declaration);
 }   break;
 
-#line 2591 "./glsl.g"
+#line 2606 "./glsl.g"
 
 case 262: {
     // nothing to do.
 }   break;
 
-#line 2598 "./glsl.g"
+#line 2613 "./glsl.g"
 
 case 263: {
     // nothing to do.
 }   break;
 
-#line 2605 "./glsl.g"
+#line 2620 "./glsl.g"
 
 case 264: {
     // nothing to do.
 }   break;
 
-#line 2612 "./glsl.g"
+#line 2627 "./glsl.g"
 
 case 265: {
     // nothing to do.
 }   break;
 
-#line 2619 "./glsl.g"
+#line 2634 "./glsl.g"
 
 case 266: {
     // nothing to do.
 }   break;
 
-#line 2626 "./glsl.g"
+#line 2641 "./glsl.g"
 
 case 267: {
     // nothing to do.
 }   break;
 
-#line 2633 "./glsl.g"
+#line 2648 "./glsl.g"
 
 case 268: {
     // nothing to do.
 }   break;
 
-#line 2640 "./glsl.g"
+#line 2655 "./glsl.g"
 
 case 269: {
     // nothing to do.
 }   break;
 
-#line 2647 "./glsl.g"
+#line 2662 "./glsl.g"
 
 case 270: {
     // nothing to do.
 }   break;
 
-#line 2654 "./glsl.g"
+#line 2669 "./glsl.g"
 
 case 271: {
     CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>();
@@ -1973,7 +1988,7 @@ case 271: {
     ast(1) = stmt;
 }   break;
 
-#line 2664 "./glsl.g"
+#line 2679 "./glsl.g"
 
 case 272: {
     CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>(sym(2).statement_list);
@@ -1982,19 +1997,19 @@ case 272: {
     ast(1) = stmt;
 }   break;
 
-#line 2674 "./glsl.g"
+#line 2689 "./glsl.g"
 
 case 273: {
     // nothing to do.
 }   break;
 
-#line 2681 "./glsl.g"
+#line 2696 "./glsl.g"
 
 case 274: {
     // nothing to do.
 }   break;
 
-#line 2688 "./glsl.g"
+#line 2703 "./glsl.g"
 
 case 275: {
     CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>();
@@ -2003,7 +2018,7 @@ case 275: {
     ast(1) = stmt;
 }   break;
 
-#line 2698 "./glsl.g"
+#line 2713 "./glsl.g"
 
 case 276: {
     CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>(sym(2).statement_list);
@@ -2012,186 +2027,186 @@ case 276: {
     ast(1) = stmt;
 }   break;
 
-#line 2708 "./glsl.g"
+#line 2723 "./glsl.g"
 
 case 277: {
     sym(1).statement_list = makeAstNode< List<StatementAST *> >(sym(1).statement);
 }   break;
 
-#line 2715 "./glsl.g"
+#line 2730 "./glsl.g"
 
 case 278: {
     sym(1).statement_list = makeAstNode< List<StatementAST *> >(sym(1).statement_list, sym(2).statement);
 }   break;
 
-#line 2722 "./glsl.g"
+#line 2737 "./glsl.g"
 
 case 279: {
     ast(1) = makeAstNode<CompoundStatementAST>();  // Empty statement
 }   break;
 
-#line 2729 "./glsl.g"
+#line 2744 "./glsl.g"
 
 case 280: {
     ast(1) = makeAstNode<ExpressionStatementAST>(expression(1));
 }   break;
 
-#line 2736 "./glsl.g"
+#line 2751 "./glsl.g"
 
 case 281: {
     ast(1) = makeAstNode<IfStatementAST>(expression(3), sym(5).ifstmt.thenClause, sym(5).ifstmt.elseClause);
 }   break;
 
-#line 2743 "./glsl.g"
+#line 2758 "./glsl.g"
 
 case 282: {
     sym(1).ifstmt.thenClause = statement(1);
     sym(1).ifstmt.elseClause = statement(3);
 }   break;
 
-#line 2751 "./glsl.g"
+#line 2766 "./glsl.g"
 
 case 283: {
     sym(1).ifstmt.thenClause = statement(1);
     sym(1).ifstmt.elseClause = 0;
 }   break;
 
-#line 2759 "./glsl.g"
+#line 2774 "./glsl.g"
 
 case 284: {
     // nothing to do.
 }   break;
 
-#line 2766 "./glsl.g"
+#line 2781 "./glsl.g"
 
 case 285: {
     ast(1) = makeAstNode<DeclarationExpressionAST>
         (type(1), string(2), expression(4));
 }   break;
 
-#line 2774 "./glsl.g"
+#line 2789 "./glsl.g"
 
 case 286: {
     ast(1) = makeAstNode<SwitchStatementAST>(expression(3), statement(6));
 }   break;
 
-#line 2781 "./glsl.g"
+#line 2796 "./glsl.g"
 
 case 287: {
     ast(1) = makeAstNode<CompoundStatementAST>();
 }   break;
 
-#line 2788 "./glsl.g"
+#line 2803 "./glsl.g"
 
 case 288: {
     ast(1) = makeAstNode<CompoundStatementAST>(sym(1).statement_list);
 }   break;
 
-#line 2795 "./glsl.g"
+#line 2810 "./glsl.g"
 
 case 289: {
     ast(1) = makeAstNode<CaseLabelStatementAST>(expression(2));
 }   break;
 
-#line 2802 "./glsl.g"
+#line 2817 "./glsl.g"
 
 case 290: {
     ast(1) = makeAstNode<CaseLabelStatementAST>();
 }   break;
 
-#line 2809 "./glsl.g"
+#line 2824 "./glsl.g"
 
 case 291: {
     ast(1) = makeAstNode<WhileStatementAST>(expression(3), statement(5));
 }   break;
 
-#line 2816 "./glsl.g"
+#line 2831 "./glsl.g"
 
 case 292: {
     ast(1) = makeAstNode<DoStatementAST>(statement(2), expression(5));
 }   break;
 
-#line 2823 "./glsl.g"
+#line 2838 "./glsl.g"
 
 case 293: {
     ast(1) = makeAstNode<ForStatementAST>(statement(3), sym(4).forstmt.condition, sym(4).forstmt.increment, statement(6));
 }   break;
 
-#line 2830 "./glsl.g"
+#line 2845 "./glsl.g"
 
 case 294: {
     // nothing to do.
 }   break;
 
-#line 2837 "./glsl.g"
+#line 2852 "./glsl.g"
 
 case 295: {
     // nothing to do.
 }   break;
 
-#line 2844 "./glsl.g"
+#line 2859 "./glsl.g"
 
 case 296: {
     // nothing to do.
 }   break;
 
-#line 2851 "./glsl.g"
+#line 2866 "./glsl.g"
 
 case 297: {
     // nothing to do.
 }   break;
 
-#line 2858 "./glsl.g"
+#line 2873 "./glsl.g"
 
 case 298: {
     sym(1).forstmt.condition = expression(1);
     sym(1).forstmt.increment = 0;
 }   break;
 
-#line 2866 "./glsl.g"
+#line 2881 "./glsl.g"
 
 case 299: {
     sym(1).forstmt.condition = expression(1);
     sym(1).forstmt.increment = expression(3);
 }   break;
 
-#line 2874 "./glsl.g"
+#line 2889 "./glsl.g"
 
 case 300: {
     ast(1) = makeAstNode<JumpStatementAST>(AST::Kind_Continue);
 }   break;
 
-#line 2881 "./glsl.g"
+#line 2896 "./glsl.g"
 
 case 301: {
     ast(1) = makeAstNode<JumpStatementAST>(AST::Kind_Break);
 }   break;
 
-#line 2888 "./glsl.g"
+#line 2903 "./glsl.g"
 
 case 302: {
     ast(1) = makeAstNode<ReturnStatementAST>();
 }   break;
 
-#line 2895 "./glsl.g"
+#line 2910 "./glsl.g"
 
 case 303: {
     ast(1) = makeAstNode<ReturnStatementAST>(expression(2));
 }   break;
 
-#line 2902 "./glsl.g"
+#line 2917 "./glsl.g"
 
 case 304: {
     ast(1) = makeAstNode<JumpStatementAST>(AST::Kind_Discard);
 }   break;
 
-#line 2909 "./glsl.g"
+#line 2924 "./glsl.g"
 
 case 305: {
     ast(1) = makeAstNode<TranslationUnitAST>(sym(1).declaration_list);
 }   break;
 
-#line 2916 "./glsl.g"
+#line 2931 "./glsl.g"
 
 case 306: {
     if (sym(1).declaration) {
@@ -2202,7 +2217,7 @@ case 306: {
     }
 }   break;
 
-#line 2928 "./glsl.g"
+#line 2943 "./glsl.g"
 
 case 307: {
     if (sym(1).declaration_list && sym(2).declaration) {
@@ -2218,49 +2233,49 @@ case 307: {
     }
 }   break;
 
-#line 2945 "./glsl.g"
+#line 2960 "./glsl.g"
 
 case 308: {
     // nothing to do.
 }   break;
 
-#line 2952 "./glsl.g"
+#line 2967 "./glsl.g"
 
 case 309: {
     // nothing to do.
 }   break;
 
-#line 2959 "./glsl.g"
+#line 2974 "./glsl.g"
 
 case 310: {
     ast(1) = 0;
 }   break;
 
-#line 2966 "./glsl.g"
+#line 2981 "./glsl.g"
 
 case 311: {
     function(1)->body = statement(2);
 }   break;
 
-#line 2973 "./glsl.g"
+#line 2988 "./glsl.g"
 
 case 312: {
     ast(1) = 0;
 }   break;
 
-#line 2981 "./glsl.g"
+#line 2996 "./glsl.g"
 
 case 313: {
     ast(1) = ast(2);
 }   break;
 
-#line 2988 "./glsl.g"
+#line 3003 "./glsl.g"
 
 case 314: {
     ast(1) = ast(2);
 }   break;
 
-#line 2994 "./glsl.g"
+#line 3009 "./glsl.g"
 
 } // end switch
 } // end Parser::reduce()