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