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