Line data Source code
1 : /* A Bison parser, made by GNU Bison 3.0.4. */
2 :
3 : /* Bison implementation for Yacc-like parsers in C
4 :
5 : Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
6 :
7 : This program is free software: you can redistribute it and/or modify
8 : it under the terms of the GNU General Public License as published by
9 : the Free Software Foundation, either version 3 of the License, or
10 : (at your option) any later version.
11 :
12 : This program is distributed in the hope that it will be useful,
13 : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : GNU General Public License for more details.
16 :
17 : You should have received a copy of the GNU General Public License
18 : along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 :
20 : /* As a special exception, you may create a larger work that contains
21 : part or all of the Bison parser skeleton and distribute that work
22 : under terms of your choice, so long as that work isn't itself a
23 : parser generator using the skeleton or a modified version thereof
24 : as a parser skeleton. Alternatively, if you modify or redistribute
25 : the parser skeleton itself, you may (at your option) remove this
26 : special exception, which will cause the skeleton and the resulting
27 : Bison output files to be licensed under the GNU General Public
28 : License without this special exception.
29 :
30 : This special exception was added by the Free Software Foundation in
31 : version 2.2 of Bison. */
32 :
33 : /* C LALR(1) parser skeleton written by Richard Stallman, by
34 : simplifying the original so-called "semantic" parser. */
35 :
36 : /* All symbols defined below should begin with yy or YY, to avoid
37 : infringing on user name space. This should be done even for local
38 : variables, as they might otherwise be expanded by user macros.
39 : There are some unavoidable exceptions within include files to
40 : define necessary library symbols; they are noted "INFRINGES ON
41 : USER NAME SPACE" below. */
42 :
43 : /* Identify Bison output. */
44 : #define YYBISON 1
45 :
46 : /* Bison version. */
47 : #define YYBISON_VERSION "3.0.4"
48 :
49 : /* Skeleton name. */
50 : #define YYSKELETON_NAME "yacc.c"
51 :
52 : /* Pure parsers. */
53 : #define YYPURE 2
54 :
55 : /* Push parsers. */
56 : #define YYPUSH 0
57 :
58 : /* Pull parsers. */
59 : #define YYPULL 1
60 :
61 :
62 :
63 :
64 : /* Copy the first part of user declarations. */
65 :
66 :
67 : //
68 : // Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
69 : // Use of this source code is governed by a BSD-style license that can be
70 : // found in the LICENSE file.
71 : //
72 :
73 : // This file is auto-generated by generate_parser.sh. DO NOT EDIT!
74 :
75 : // clang-format off
76 :
77 : // Ignore errors in auto-generated code.
78 : #if defined(__GNUC__)
79 : #pragma GCC diagnostic ignored "-Wunused-function"
80 : #pragma GCC diagnostic ignored "-Wunused-variable"
81 : #pragma GCC diagnostic ignored "-Wswitch-enum"
82 : #elif defined(_MSC_VER)
83 : #pragma warning(disable: 4065)
84 : #pragma warning(disable: 4189)
85 : #pragma warning(disable: 4244)
86 : #pragma warning(disable: 4505)
87 : #pragma warning(disable: 4701)
88 : #pragma warning(disable: 4702)
89 : #endif
90 :
91 : #include "angle_gl.h"
92 : #include "compiler/translator/Cache.h"
93 : #include "compiler/translator/SymbolTable.h"
94 : #include "compiler/translator/ParseContext.h"
95 : #include "GLSLANG/ShaderLang.h"
96 :
97 : #define YYENABLE_NLS 0
98 :
99 : using namespace sh;
100 :
101 :
102 :
103 :
104 : # ifndef YY_NULLPTR
105 : # if defined __cplusplus && 201103L <= __cplusplus
106 : # define YY_NULLPTR nullptr
107 : # else
108 : # define YY_NULLPTR 0
109 : # endif
110 : # endif
111 :
112 : /* Enabling verbose error messages. */
113 : #ifdef YYERROR_VERBOSE
114 : # undef YYERROR_VERBOSE
115 : # define YYERROR_VERBOSE 1
116 : #else
117 : # define YYERROR_VERBOSE 0
118 : #endif
119 :
120 : /* In a future release of Bison, this section will be replaced
121 : by #include "glslang_tab.h". */
122 : #ifndef YY_YY_GLSLANG_TAB_H_INCLUDED
123 : # define YY_YY_GLSLANG_TAB_H_INCLUDED
124 : /* Debug traces. */
125 : #ifndef YYDEBUG
126 : # define YYDEBUG 0
127 : #endif
128 : #if YYDEBUG
129 : extern int yydebug;
130 : #endif
131 : /* "%code requires" blocks. */
132 :
133 :
134 : #define YYLTYPE TSourceLoc
135 : #define YYLTYPE_IS_DECLARED 1
136 :
137 :
138 :
139 : /* Token type. */
140 : #ifndef YYTOKENTYPE
141 : # define YYTOKENTYPE
142 : enum yytokentype
143 : {
144 : INVARIANT = 258,
145 : HIGH_PRECISION = 259,
146 : MEDIUM_PRECISION = 260,
147 : LOW_PRECISION = 261,
148 : PRECISION = 262,
149 : ATTRIBUTE = 263,
150 : CONST_QUAL = 264,
151 : BOOL_TYPE = 265,
152 : FLOAT_TYPE = 266,
153 : INT_TYPE = 267,
154 : UINT_TYPE = 268,
155 : BREAK = 269,
156 : CONTINUE = 270,
157 : DO = 271,
158 : ELSE = 272,
159 : FOR = 273,
160 : IF = 274,
161 : DISCARD = 275,
162 : RETURN = 276,
163 : SWITCH = 277,
164 : CASE = 278,
165 : DEFAULT = 279,
166 : BVEC2 = 280,
167 : BVEC3 = 281,
168 : BVEC4 = 282,
169 : IVEC2 = 283,
170 : IVEC3 = 284,
171 : IVEC4 = 285,
172 : VEC2 = 286,
173 : VEC3 = 287,
174 : VEC4 = 288,
175 : UVEC2 = 289,
176 : UVEC3 = 290,
177 : UVEC4 = 291,
178 : MATRIX2 = 292,
179 : MATRIX3 = 293,
180 : MATRIX4 = 294,
181 : IN_QUAL = 295,
182 : OUT_QUAL = 296,
183 : INOUT_QUAL = 297,
184 : UNIFORM = 298,
185 : VARYING = 299,
186 : MATRIX2x3 = 300,
187 : MATRIX3x2 = 301,
188 : MATRIX2x4 = 302,
189 : MATRIX4x2 = 303,
190 : MATRIX3x4 = 304,
191 : MATRIX4x3 = 305,
192 : CENTROID = 306,
193 : FLAT = 307,
194 : SMOOTH = 308,
195 : READONLY = 309,
196 : WRITEONLY = 310,
197 : COHERENT = 311,
198 : RESTRICT = 312,
199 : VOLATILE = 313,
200 : STRUCT = 314,
201 : VOID_TYPE = 315,
202 : WHILE = 316,
203 : SAMPLER2D = 317,
204 : SAMPLERCUBE = 318,
205 : SAMPLER_EXTERNAL_OES = 319,
206 : SAMPLER2DRECT = 320,
207 : SAMPLER2DARRAY = 321,
208 : ISAMPLER2D = 322,
209 : ISAMPLER3D = 323,
210 : ISAMPLERCUBE = 324,
211 : ISAMPLER2DARRAY = 325,
212 : USAMPLER2D = 326,
213 : USAMPLER3D = 327,
214 : USAMPLERCUBE = 328,
215 : USAMPLER2DARRAY = 329,
216 : SAMPLER3D = 330,
217 : SAMPLER3DRECT = 331,
218 : SAMPLER2DSHADOW = 332,
219 : SAMPLERCUBESHADOW = 333,
220 : SAMPLER2DARRAYSHADOW = 334,
221 : IMAGE2D = 335,
222 : IIMAGE2D = 336,
223 : UIMAGE2D = 337,
224 : IMAGE3D = 338,
225 : IIMAGE3D = 339,
226 : UIMAGE3D = 340,
227 : IMAGE2DARRAY = 341,
228 : IIMAGE2DARRAY = 342,
229 : UIMAGE2DARRAY = 343,
230 : IMAGECUBE = 344,
231 : IIMAGECUBE = 345,
232 : UIMAGECUBE = 346,
233 : LAYOUT = 347,
234 : IDENTIFIER = 348,
235 : TYPE_NAME = 349,
236 : FLOATCONSTANT = 350,
237 : INTCONSTANT = 351,
238 : UINTCONSTANT = 352,
239 : BOOLCONSTANT = 353,
240 : FIELD_SELECTION = 354,
241 : LEFT_OP = 355,
242 : RIGHT_OP = 356,
243 : INC_OP = 357,
244 : DEC_OP = 358,
245 : LE_OP = 359,
246 : GE_OP = 360,
247 : EQ_OP = 361,
248 : NE_OP = 362,
249 : AND_OP = 363,
250 : OR_OP = 364,
251 : XOR_OP = 365,
252 : MUL_ASSIGN = 366,
253 : DIV_ASSIGN = 367,
254 : ADD_ASSIGN = 368,
255 : MOD_ASSIGN = 369,
256 : LEFT_ASSIGN = 370,
257 : RIGHT_ASSIGN = 371,
258 : AND_ASSIGN = 372,
259 : XOR_ASSIGN = 373,
260 : OR_ASSIGN = 374,
261 : SUB_ASSIGN = 375,
262 : LEFT_PAREN = 376,
263 : RIGHT_PAREN = 377,
264 : LEFT_BRACKET = 378,
265 : RIGHT_BRACKET = 379,
266 : LEFT_BRACE = 380,
267 : RIGHT_BRACE = 381,
268 : DOT = 382,
269 : COMMA = 383,
270 : COLON = 384,
271 : EQUAL = 385,
272 : SEMICOLON = 386,
273 : BANG = 387,
274 : DASH = 388,
275 : TILDE = 389,
276 : PLUS = 390,
277 : STAR = 391,
278 : SLASH = 392,
279 : PERCENT = 393,
280 : LEFT_ANGLE = 394,
281 : RIGHT_ANGLE = 395,
282 : VERTICAL_BAR = 396,
283 : CARET = 397,
284 : AMPERSAND = 398,
285 : QUESTION = 399
286 : };
287 : #endif
288 :
289 : /* Value type. */
290 : #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
291 :
292 : union YYSTYPE
293 : {
294 :
295 :
296 : struct {
297 : union {
298 : TString *string;
299 : float f;
300 : int i;
301 : unsigned int u;
302 : bool b;
303 : };
304 : TSymbol* symbol;
305 : } lex;
306 : struct {
307 : TOperator op;
308 : union {
309 : TIntermNode *intermNode;
310 : TIntermNodePair nodePair;
311 : TIntermTyped *intermTypedNode;
312 : TIntermAggregate *intermAggregate;
313 : TIntermBlock *intermBlock;
314 : TIntermDeclaration *intermDeclaration;
315 : TIntermSwitch *intermSwitch;
316 : TIntermCase *intermCase;
317 : };
318 : union {
319 : TTypeSpecifierNonArray typeSpecifierNonArray;
320 : TPublicType type;
321 : TPrecision precision;
322 : TLayoutQualifier layoutQualifier;
323 : TQualifier qualifier;
324 : TFunction *function;
325 : TParameter param;
326 : TField *field;
327 : TFieldList *fieldList;
328 : TQualifierWrapperBase *qualifierWrapper;
329 : TTypeQualifierBuilder *typeQualifierBuilder;
330 : };
331 : } interm;
332 :
333 :
334 : };
335 :
336 : typedef union YYSTYPE YYSTYPE;
337 : # define YYSTYPE_IS_TRIVIAL 1
338 : # define YYSTYPE_IS_DECLARED 1
339 : #endif
340 :
341 : /* Location type. */
342 : #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
343 : typedef struct YYLTYPE YYLTYPE;
344 : struct YYLTYPE
345 : {
346 : int first_line;
347 : int first_column;
348 : int last_line;
349 : int last_column;
350 : };
351 : # define YYLTYPE_IS_DECLARED 1
352 : # define YYLTYPE_IS_TRIVIAL 1
353 : #endif
354 :
355 :
356 :
357 : int yyparse (TParseContext* context, void *scanner);
358 :
359 : #endif /* !YY_YY_GLSLANG_TAB_H_INCLUDED */
360 :
361 : /* Copy the second part of user declarations. */
362 :
363 :
364 : extern int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, void* yyscanner);
365 : extern void yyerror(YYLTYPE* yylloc, TParseContext* context, void *scanner, const char* reason);
366 :
367 : #define YYLLOC_DEFAULT(Current, Rhs, N) \
368 : do { \
369 : if (N) { \
370 : (Current).first_file = YYRHSLOC(Rhs, 1).first_file; \
371 : (Current).first_line = YYRHSLOC(Rhs, 1).first_line; \
372 : (Current).last_file = YYRHSLOC(Rhs, N).last_file; \
373 : (Current).last_line = YYRHSLOC(Rhs, N).last_line; \
374 : } \
375 : else { \
376 : (Current).first_file = YYRHSLOC(Rhs, 0).last_file; \
377 : (Current).first_line = YYRHSLOC(Rhs, 0).last_line; \
378 : (Current).last_file = YYRHSLOC(Rhs, 0).last_file; \
379 : (Current).last_line = YYRHSLOC(Rhs, 0).last_line; \
380 : } \
381 : } while (0)
382 :
383 : #define VERTEX_ONLY(S, L) { \
384 : if (context->getShaderType() != GL_VERTEX_SHADER) { \
385 : context->error(L, " supported in vertex shaders only ", S); \
386 : } \
387 : }
388 :
389 : #define FRAG_ONLY(S, L) { \
390 : if (context->getShaderType() != GL_FRAGMENT_SHADER) { \
391 : context->error(L, " supported in fragment shaders only ", S); \
392 : } \
393 : }
394 :
395 : #define COMPUTE_ONLY(S, L) { \
396 : if (context->getShaderType() != GL_COMPUTE_SHADER) { \
397 : context->error(L, " supported in compute shaders only ", S); \
398 : } \
399 : }
400 :
401 : #define NON_COMPUTE_ONLY(S, L) { \
402 : if (context->getShaderType() != GL_VERTEX_SHADER && context->getShaderType() != GL_FRAGMENT_SHADER) { \
403 : context->error(L, " supported in vertex and fragment shaders only ", S); \
404 : } \
405 : }
406 :
407 : #define ES2_ONLY(S, L) { \
408 : if (context->getShaderVersion() != 100) { \
409 : context->error(L, " supported in GLSL ES 1.00 only ", S); \
410 : } \
411 : }
412 :
413 : #define ES3_OR_NEWER(TOKEN, LINE, REASON) { \
414 : if (context->getShaderVersion() < 300) { \
415 : context->error(LINE, REASON " supported in GLSL ES 3.00 and above only ", TOKEN); \
416 : } \
417 : }
418 :
419 : #define ES3_1_ONLY(TOKEN, LINE, REASON) { \
420 : if (context->getShaderVersion() != 310) { \
421 : context->error(LINE, REASON " supported in GLSL ES 3.10 only ", TOKEN); \
422 : } \
423 : }
424 :
425 :
426 :
427 : #ifdef short
428 : # undef short
429 : #endif
430 :
431 : #ifdef YYTYPE_UINT8
432 : typedef YYTYPE_UINT8 yytype_uint8;
433 : #else
434 : typedef unsigned char yytype_uint8;
435 : #endif
436 :
437 : #ifdef YYTYPE_INT8
438 : typedef YYTYPE_INT8 yytype_int8;
439 : #else
440 : typedef signed char yytype_int8;
441 : #endif
442 :
443 : #ifdef YYTYPE_UINT16
444 : typedef YYTYPE_UINT16 yytype_uint16;
445 : #else
446 : typedef unsigned short int yytype_uint16;
447 : #endif
448 :
449 : #ifdef YYTYPE_INT16
450 : typedef YYTYPE_INT16 yytype_int16;
451 : #else
452 : typedef short int yytype_int16;
453 : #endif
454 :
455 : #ifndef YYSIZE_T
456 : # ifdef __SIZE_TYPE__
457 : # define YYSIZE_T __SIZE_TYPE__
458 : # elif defined size_t
459 : # define YYSIZE_T size_t
460 : # elif ! defined YYSIZE_T
461 : # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
462 : # define YYSIZE_T size_t
463 : # else
464 : # define YYSIZE_T unsigned int
465 : # endif
466 : #endif
467 :
468 : #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
469 :
470 : #ifndef YY_
471 : # if defined YYENABLE_NLS && YYENABLE_NLS
472 : # if ENABLE_NLS
473 : # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
474 : # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
475 : # endif
476 : # endif
477 : # ifndef YY_
478 : # define YY_(Msgid) Msgid
479 : # endif
480 : #endif
481 :
482 : #ifndef YY_ATTRIBUTE
483 : # if (defined __GNUC__ \
484 : && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
485 : || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
486 : # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
487 : # else
488 : # define YY_ATTRIBUTE(Spec) /* empty */
489 : # endif
490 : #endif
491 :
492 : #ifndef YY_ATTRIBUTE_PURE
493 : # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
494 : #endif
495 :
496 : #ifndef YY_ATTRIBUTE_UNUSED
497 : # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
498 : #endif
499 :
500 : #if !defined _Noreturn \
501 : && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
502 : # if defined _MSC_VER && 1200 <= _MSC_VER
503 : # define _Noreturn __declspec (noreturn)
504 : # else
505 : # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
506 : # endif
507 : #endif
508 :
509 : /* Suppress unused-variable warnings by "using" E. */
510 : #if ! defined lint || defined __GNUC__
511 : # define YYUSE(E) ((void) (E))
512 : #else
513 : # define YYUSE(E) /* empty */
514 : #endif
515 :
516 : #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
517 : /* Suppress an incorrect diagnostic about yylval being uninitialized. */
518 : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
519 : _Pragma ("GCC diagnostic push") \
520 : _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
521 : _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
522 : # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
523 : _Pragma ("GCC diagnostic pop")
524 : #else
525 : # define YY_INITIAL_VALUE(Value) Value
526 : #endif
527 : #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
528 : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
529 : # define YY_IGNORE_MAYBE_UNINITIALIZED_END
530 : #endif
531 : #ifndef YY_INITIAL_VALUE
532 : # define YY_INITIAL_VALUE(Value) /* Nothing. */
533 : #endif
534 :
535 :
536 : #if ! defined yyoverflow || YYERROR_VERBOSE
537 :
538 : /* The parser invokes alloca or malloc; define the necessary symbols. */
539 :
540 : # ifdef YYSTACK_USE_ALLOCA
541 : # if YYSTACK_USE_ALLOCA
542 : # ifdef __GNUC__
543 : # define YYSTACK_ALLOC __builtin_alloca
544 : # elif defined __BUILTIN_VA_ARG_INCR
545 : # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
546 : # elif defined _AIX
547 : # define YYSTACK_ALLOC __alloca
548 : # elif defined _MSC_VER
549 : # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
550 : # define alloca _alloca
551 : # else
552 : # define YYSTACK_ALLOC alloca
553 : # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
554 : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
555 : /* Use EXIT_SUCCESS as a witness for stdlib.h. */
556 : # ifndef EXIT_SUCCESS
557 : # define EXIT_SUCCESS 0
558 : # endif
559 : # endif
560 : # endif
561 : # endif
562 : # endif
563 :
564 : # ifdef YYSTACK_ALLOC
565 : /* Pacify GCC's 'empty if-body' warning. */
566 : # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
567 : # ifndef YYSTACK_ALLOC_MAXIMUM
568 : /* The OS might guarantee only one guard page at the bottom of the stack,
569 : and a page size can be as small as 4096 bytes. So we cannot safely
570 : invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
571 : to allow for a few compiler-allocated temporary stack slots. */
572 : # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
573 : # endif
574 : # else
575 : # define YYSTACK_ALLOC YYMALLOC
576 : # define YYSTACK_FREE YYFREE
577 : # ifndef YYSTACK_ALLOC_MAXIMUM
578 : # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
579 : # endif
580 : # if (defined __cplusplus && ! defined EXIT_SUCCESS \
581 : && ! ((defined YYMALLOC || defined malloc) \
582 : && (defined YYFREE || defined free)))
583 : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
584 : # ifndef EXIT_SUCCESS
585 : # define EXIT_SUCCESS 0
586 : # endif
587 : # endif
588 : # ifndef YYMALLOC
589 : # define YYMALLOC malloc
590 : # if ! defined malloc && ! defined EXIT_SUCCESS
591 : void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
592 : # endif
593 : # endif
594 : # ifndef YYFREE
595 : # define YYFREE free
596 : # if ! defined free && ! defined EXIT_SUCCESS
597 : void free (void *); /* INFRINGES ON USER NAME SPACE */
598 : # endif
599 : # endif
600 : # endif
601 : #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
602 :
603 :
604 : #if (! defined yyoverflow \
605 : && (! defined __cplusplus \
606 : || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
607 : && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
608 :
609 : /* A type that is properly aligned for any stack member. */
610 : union yyalloc
611 : {
612 : yytype_int16 yyss_alloc;
613 : YYSTYPE yyvs_alloc;
614 : YYLTYPE yyls_alloc;
615 : };
616 :
617 : /* The size of the maximum gap between one aligned stack and the next. */
618 : # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
619 :
620 : /* The size of an array large to enough to hold all stacks, each with
621 : N elements. */
622 : # define YYSTACK_BYTES(N) \
623 : ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
624 : + 2 * YYSTACK_GAP_MAXIMUM)
625 :
626 : # define YYCOPY_NEEDED 1
627 :
628 : /* Relocate STACK from its old location to the new one. The
629 : local variables YYSIZE and YYSTACKSIZE give the old and new number of
630 : elements in the stack, and YYPTR gives the new location of the
631 : stack. Advance YYPTR to a properly aligned location for the next
632 : stack. */
633 : # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
634 : do \
635 : { \
636 : YYSIZE_T yynewbytes; \
637 : YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
638 : Stack = &yyptr->Stack_alloc; \
639 : yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
640 : yyptr += yynewbytes / sizeof (*yyptr); \
641 : } \
642 : while (0)
643 :
644 : #endif
645 :
646 : #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
647 : /* Copy COUNT objects from SRC to DST. The source and destination do
648 : not overlap. */
649 : # ifndef YYCOPY
650 : # if defined __GNUC__ && 1 < __GNUC__
651 : # define YYCOPY(Dst, Src, Count) \
652 : __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
653 : # else
654 : # define YYCOPY(Dst, Src, Count) \
655 : do \
656 : { \
657 : YYSIZE_T yyi; \
658 : for (yyi = 0; yyi < (Count); yyi++) \
659 : (Dst)[yyi] = (Src)[yyi]; \
660 : } \
661 : while (0)
662 : # endif
663 : # endif
664 : #endif /* !YYCOPY_NEEDED */
665 :
666 : /* YYFINAL -- State number of the termination state. */
667 : #define YYFINAL 126
668 : /* YYLAST -- Last index in YYTABLE. */
669 : #define YYLAST 2825
670 :
671 : /* YYNTOKENS -- Number of terminals. */
672 : #define YYNTOKENS 145
673 : /* YYNNTS -- Number of nonterminals. */
674 : #define YYNNTS 94
675 : /* YYNRULES -- Number of rules. */
676 : #define YYNRULES 286
677 : /* YYNSTATES -- Number of states. */
678 : #define YYNSTATES 422
679 :
680 : /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
681 : by yylex, with out-of-bounds checking. */
682 : #define YYUNDEFTOK 2
683 : #define YYMAXUTOK 399
684 :
685 : #define YYTRANSLATE(YYX) \
686 : ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
687 :
688 : /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
689 : as returned by yylex, without out-of-bounds checking. */
690 : static const yytype_uint8 yytranslate[] =
691 : {
692 : 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
693 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
694 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
695 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
696 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
697 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
698 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
699 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
700 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
701 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
702 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
703 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
704 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
705 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
706 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
707 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
708 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
709 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
710 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
711 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
712 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
713 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
714 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
715 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
716 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
717 : 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
718 : 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
719 : 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
720 : 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
721 : 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
722 : 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
723 : 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
724 : 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
725 : 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
726 : 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
727 : 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
728 : 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
729 : 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
730 : 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
731 : 135, 136, 137, 138, 139, 140, 141, 142, 143, 144
732 : };
733 :
734 : #if YYDEBUG
735 : /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
736 : static const yytype_uint16 yyrline[] =
737 : {
738 : 0, 243, 243, 244, 247, 257, 260, 265, 270, 275,
739 : 280, 286, 289, 292, 295, 298, 301, 307, 314, 325,
740 : 329, 337, 340, 346, 350, 357, 363, 372, 380, 386,
741 : 392, 401, 404, 407, 410, 420, 421, 422, 423, 431,
742 : 432, 435, 438, 445, 446, 449, 455, 456, 460, 467,
743 : 468, 471, 474, 477, 483, 484, 487, 493, 494, 501,
744 : 502, 509, 510, 517, 518, 524, 525, 531, 532, 538,
745 : 539, 545, 546, 553, 554, 555, 556, 560, 561, 562,
746 : 566, 570, 574, 578, 585, 588, 594, 601, 608, 611,
747 : 614, 623, 627, 631, 635, 639, 646, 653, 656, 663,
748 : 671, 691, 701, 709, 734, 738, 742, 746, 753, 760,
749 : 763, 767, 771, 776, 781, 788, 792, 796, 800, 805,
750 : 810, 817, 821, 827, 830, 836, 840, 847, 853, 857,
751 : 861, 864, 867, 876, 882, 890, 893, 913, 932, 939,
752 : 943, 947, 950, 953, 956, 959, 965, 972, 975, 978,
753 : 984, 991, 994, 1000, 1003, 1006, 1012, 1015, 1020, 1031,
754 : 1034, 1037, 1040, 1043, 1046, 1050, 1054, 1058, 1062, 1066,
755 : 1070, 1074, 1078, 1082, 1086, 1090, 1094, 1098, 1102, 1106,
756 : 1110, 1114, 1118, 1122, 1126, 1130, 1133, 1136, 1139, 1142,
757 : 1145, 1148, 1151, 1154, 1157, 1160, 1163, 1166, 1169, 1172,
758 : 1175, 1182, 1188, 1191, 1194, 1197, 1200, 1203, 1206, 1209,
759 : 1212, 1215, 1218, 1221, 1224, 1227, 1239, 1239, 1242, 1242,
760 : 1248, 1251, 1266, 1269, 1276, 1280, 1286, 1292, 1304, 1308,
761 : 1312, 1313, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1329,
762 : 1330, 1330, 1330, 1339, 1340, 1344, 1344, 1345, 1345, 1350,
763 : 1353, 1362, 1367, 1374, 1375, 1379, 1386, 1390, 1397, 1397,
764 : 1404, 1407, 1414, 1418, 1431, 1431, 1436, 1436, 1442, 1442,
765 : 1450, 1453, 1459, 1462, 1468, 1472, 1479, 1482, 1485, 1488,
766 : 1491, 1500, 1506, 1512, 1515, 1521, 1521
767 : };
768 : #endif
769 :
770 : #if YYDEBUG || YYERROR_VERBOSE || 0
771 : /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
772 : First, the terminals, then, starting at YYNTOKENS, nonterminals. */
773 : static const char *const yytname[] =
774 : {
775 : "$end", "error", "$undefined", "INVARIANT", "HIGH_PRECISION",
776 : "MEDIUM_PRECISION", "LOW_PRECISION", "PRECISION", "ATTRIBUTE",
777 : "CONST_QUAL", "BOOL_TYPE", "FLOAT_TYPE", "INT_TYPE", "UINT_TYPE",
778 : "BREAK", "CONTINUE", "DO", "ELSE", "FOR", "IF", "DISCARD", "RETURN",
779 : "SWITCH", "CASE", "DEFAULT", "BVEC2", "BVEC3", "BVEC4", "IVEC2", "IVEC3",
780 : "IVEC4", "VEC2", "VEC3", "VEC4", "UVEC2", "UVEC3", "UVEC4", "MATRIX2",
781 : "MATRIX3", "MATRIX4", "IN_QUAL", "OUT_QUAL", "INOUT_QUAL", "UNIFORM",
782 : "VARYING", "MATRIX2x3", "MATRIX3x2", "MATRIX2x4", "MATRIX4x2",
783 : "MATRIX3x4", "MATRIX4x3", "CENTROID", "FLAT", "SMOOTH", "READONLY",
784 : "WRITEONLY", "COHERENT", "RESTRICT", "VOLATILE", "STRUCT", "VOID_TYPE",
785 : "WHILE", "SAMPLER2D", "SAMPLERCUBE", "SAMPLER_EXTERNAL_OES",
786 : "SAMPLER2DRECT", "SAMPLER2DARRAY", "ISAMPLER2D", "ISAMPLER3D",
787 : "ISAMPLERCUBE", "ISAMPLER2DARRAY", "USAMPLER2D", "USAMPLER3D",
788 : "USAMPLERCUBE", "USAMPLER2DARRAY", "SAMPLER3D", "SAMPLER3DRECT",
789 : "SAMPLER2DSHADOW", "SAMPLERCUBESHADOW", "SAMPLER2DARRAYSHADOW",
790 : "IMAGE2D", "IIMAGE2D", "UIMAGE2D", "IMAGE3D", "IIMAGE3D", "UIMAGE3D",
791 : "IMAGE2DARRAY", "IIMAGE2DARRAY", "UIMAGE2DARRAY", "IMAGECUBE",
792 : "IIMAGECUBE", "UIMAGECUBE", "LAYOUT", "IDENTIFIER", "TYPE_NAME",
793 : "FLOATCONSTANT", "INTCONSTANT", "UINTCONSTANT", "BOOLCONSTANT",
794 : "FIELD_SELECTION", "LEFT_OP", "RIGHT_OP", "INC_OP", "DEC_OP", "LE_OP",
795 : "GE_OP", "EQ_OP", "NE_OP", "AND_OP", "OR_OP", "XOR_OP", "MUL_ASSIGN",
796 : "DIV_ASSIGN", "ADD_ASSIGN", "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN",
797 : "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "SUB_ASSIGN", "LEFT_PAREN",
798 : "RIGHT_PAREN", "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE",
799 : "RIGHT_BRACE", "DOT", "COMMA", "COLON", "EQUAL", "SEMICOLON", "BANG",
800 : "DASH", "TILDE", "PLUS", "STAR", "SLASH", "PERCENT", "LEFT_ANGLE",
801 : "RIGHT_ANGLE", "VERTICAL_BAR", "CARET", "AMPERSAND", "QUESTION",
802 : "$accept", "identifier", "variable_identifier", "primary_expression",
803 : "postfix_expression", "integer_expression", "function_call",
804 : "function_call_or_method", "function_call_generic",
805 : "function_call_header_no_parameters",
806 : "function_call_header_with_parameters", "function_call_header",
807 : "function_identifier", "unary_expression", "unary_operator",
808 : "multiplicative_expression", "additive_expression", "shift_expression",
809 : "relational_expression", "equality_expression", "and_expression",
810 : "exclusive_or_expression", "inclusive_or_expression",
811 : "logical_and_expression", "logical_xor_expression",
812 : "logical_or_expression", "conditional_expression",
813 : "assignment_expression", "assignment_operator", "expression",
814 : "constant_expression", "enter_struct", "declaration",
815 : "function_prototype", "function_declarator",
816 : "function_header_with_parameters", "function_header",
817 : "parameter_declarator", "parameter_declaration",
818 : "parameter_type_specifier", "init_declarator_list", "single_declaration",
819 : "fully_specified_type", "interpolation_qualifier", "type_qualifier",
820 : "invariant_qualifier", "single_type_qualifier", "storage_qualifier",
821 : "type_specifier", "precision_qualifier", "layout_qualifier",
822 : "layout_qualifier_id_list", "layout_qualifier_id",
823 : "type_specifier_no_prec", "type_specifier_nonarray", "struct_specifier",
824 : "$@1", "$@2", "struct_declaration_list", "struct_declaration",
825 : "struct_declarator_list", "struct_declarator", "initializer",
826 : "declaration_statement", "statement", "simple_statement",
827 : "compound_statement", "$@3", "$@4", "statement_no_new_scope",
828 : "statement_with_scope", "$@5", "$@6", "compound_statement_no_new_scope",
829 : "statement_list", "expression_statement", "selection_statement",
830 : "selection_rest_statement", "switch_statement", "$@7", "case_label",
831 : "condition", "iteration_statement", "$@8", "$@9", "$@10",
832 : "for_init_statement", "conditionopt", "for_rest_statement",
833 : "jump_statement", "translation_unit", "external_declaration",
834 : "function_definition", "$@11", YY_NULLPTR
835 : };
836 : #endif
837 :
838 : # ifdef YYPRINT
839 : /* YYTOKNUM[NUM] -- (External) token number corresponding to the
840 : (internal) symbol number NUM (which must be that of a token). */
841 : static const yytype_uint16 yytoknum[] =
842 : {
843 : 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
844 : 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
845 : 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
846 : 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
847 : 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
848 : 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
849 : 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
850 : 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
851 : 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
852 : 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
853 : 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
854 : 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
855 : 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
856 : 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
857 : 395, 396, 397, 398, 399
858 : };
859 : # endif
860 :
861 : #define YYPACT_NINF -363
862 :
863 : #define yypact_value_is_default(Yystate) \
864 : (!!((Yystate) == (-363)))
865 :
866 : #define YYTABLE_NINF -246
867 :
868 : #define yytable_value_is_error(Yytable_value) \
869 : 0
870 :
871 : /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
872 : STATE-NUM. */
873 : static const yytype_int16 yypact[] =
874 : {
875 : 2469, -363, -363, -363, -363, 101, -363, -363, -363, -363,
876 : -363, -363, -363, -363, -363, -363, -363, -363, -363, -363,
877 : -363, -363, -363, -363, -363, -363, -363, -363, -363, -363,
878 : -363, -363, -363, -363, -363, -363, -363, -363, -363, -363,
879 : -363, -363, -363, -363, -363, -363, -68, -363, -363, -363,
880 : -363, -363, -363, -363, -363, -363, -363, -363, -363, -363,
881 : -363, -363, -363, -363, -363, -363, -363, -363, -363, -363,
882 : -363, -363, -363, -363, -363, -363, -363, -88, -363, -363,
883 : -77, -35, -13, 2561, -51, -363, 27, -363, 1301, -363,
884 : -363, -363, -363, -363, -363, -363, 12, -363, 2377, -363,
885 : -363, 2731, -363, -363, -363, 15, 49, -363, 22, -363,
886 : 2561, -363, -363, -363, 2561, 51, 51, -363, 16, -103,
887 : -87, -363, 2561, -363, -363, 1388, -363, -363, 20, 2561,
888 : -363, 19, -82, -363, 408, -363, -363, -363, -363, 39,
889 : -91, -363, 1503, 1845, -363, -363, 2561, 51, 2071, -363,
890 : 47, -363, -363, -363, -363, -363, 1845, 1845, 1845, -363,
891 : -363, -363, -363, -363, -363, -363, -41, -363, -363, -363,
892 : 55, -55, 1957, 59, -363, 1845, -5, -90, 64, -81,
893 : -42, 33, 45, 48, 78, 80, -93, -363, 71, -363,
894 : -363, 2173, 2561, 70, -363, 49, 57, 63, -363, 79,
895 : 81, 68, 1618, 83, 1845, 72, 84, 82, -363, -363,
896 : 41, -363, -363, -36, -363, -77, 85, -363, -363, -363,
897 : -363, 541, -363, -363, -363, -363, -363, -363, 1845, 1730,
898 : 1845, 77, 88, -363, -363, 51, 86, -34, -363, -78,
899 : -363, -363, -363, -50, -363, -363, 1845, 2646, -363, -363,
900 : 1845, 92, -363, -363, -363, 1845, 1845, 1845, 1845, 1845,
901 : 1845, 1845, 1845, 1845, 1845, 1845, 1845, 1845, 1845, 1845,
902 : 1845, 1845, 1845, 1845, 1845, -363, -363, 2275, -363, -363,
903 : -363, -363, -363, 90, -363, 1845, -363, -363, -29, 1845,
904 : 87, -363, -363, -363, 674, -363, -363, -363, -363, -363,
905 : -363, -363, -363, -363, -363, -363, 1845, 1845, -363, -363,
906 : -363, 93, 89, 94, -363, 1845, 95, -1, 1845, 51,
907 : -363, -94, -363, -363, 96, 98, -363, 102, -363, -363,
908 : -363, -363, -363, -5, -5, -90, -90, 64, 64, 64,
909 : 64, -81, -81, -42, 33, 45, 48, 78, 80, 44,
910 : -363, 161, 22, 940, 1073, -47, -363, -37, -363, 1187,
911 : 674, -363, -363, -363, 1845, 103, -363, 1845, -363, 100,
912 : -363, 1845, -363, -363, 1845, 107, -363, -363, -363, -363,
913 : 1187, 90, -363, 98, 51, 2561, 109, 106, -363, 1845,
914 : -363, -363, 111, -363, 1845, -363, 105, 116, 222, -363,
915 : 115, 112, 807, -363, -363, 110, -32, 1845, 807, 90,
916 : -363, 1845, -363, -363, -363, -363, 113, 98, -363, -363,
917 : -363, -363
918 : };
919 :
920 : /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
921 : Performed when YYTABLE does not specify something else to do. Zero
922 : means the default is an error. */
923 : static const yytype_uint16 yydefact[] =
924 : {
925 : 0, 127, 147, 148, 149, 0, 133, 135, 163, 160,
926 : 161, 162, 167, 168, 169, 170, 171, 172, 164, 165,
927 : 166, 173, 174, 175, 176, 177, 178, 136, 137, 138,
928 : 140, 134, 179, 180, 181, 182, 183, 184, 139, 124,
929 : 123, 141, 142, 143, 144, 145, 0, 159, 185, 187,
930 : 200, 201, 188, 189, 190, 191, 192, 193, 194, 195,
931 : 196, 186, 197, 198, 199, 203, 204, 205, 206, 207,
932 : 208, 209, 210, 211, 212, 213, 214, 0, 215, 284,
933 : 285, 0, 98, 97, 0, 109, 115, 131, 0, 132,
934 : 125, 128, 121, 130, 129, 146, 156, 202, 0, 281,
935 : 283, 0, 2, 3, 218, 0, 0, 88, 0, 96,
936 : 0, 105, 99, 107, 0, 108, 0, 89, 2, 116,
937 : 0, 94, 0, 126, 122, 0, 1, 282, 0, 0,
938 : 216, 153, 0, 151, 0, 286, 100, 104, 106, 102,
939 : 110, 101, 0, 0, 87, 95, 0, 0, 0, 220,
940 : 4, 8, 6, 7, 9, 30, 0, 0, 0, 157,
941 : 37, 36, 38, 35, 5, 11, 31, 13, 18, 19,
942 : 0, 0, 24, 0, 39, 0, 43, 46, 49, 54,
943 : 57, 59, 61, 63, 65, 67, 69, 86, 0, 28,
944 : 90, 0, 0, 0, 150, 0, 0, 0, 266, 0,
945 : 0, 0, 0, 0, 0, 0, 0, 240, 249, 253,
946 : 39, 71, 84, 0, 229, 0, 146, 232, 251, 231,
947 : 230, 0, 233, 234, 235, 236, 237, 238, 0, 0,
948 : 0, 0, 0, 228, 120, 0, 226, 0, 224, 0,
949 : 221, 32, 33, 0, 15, 16, 0, 0, 22, 21,
950 : 0, 159, 25, 27, 34, 0, 0, 0, 0, 0,
951 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
952 : 0, 0, 0, 0, 0, 158, 219, 0, 154, 155,
953 : 152, 277, 276, 247, 268, 0, 280, 278, 0, 0,
954 : 0, 261, 264, 239, 0, 74, 75, 77, 76, 79,
955 : 80, 81, 82, 83, 78, 73, 0, 0, 254, 250,
956 : 252, 0, 0, 0, 114, 0, 117, 0, 0, 0,
957 : 222, 0, 91, 10, 0, 17, 29, 14, 20, 26,
958 : 40, 41, 42, 45, 44, 47, 48, 52, 53, 50,
959 : 51, 55, 56, 58, 60, 62, 64, 66, 68, 0,
960 : 217, 0, 0, 0, 0, 0, 279, 0, 260, 0,
961 : 241, 72, 85, 103, 0, 111, 118, 0, 223, 0,
962 : 225, 0, 92, 12, 0, 0, 246, 248, 271, 270,
963 : 273, 247, 258, 262, 0, 0, 0, 0, 112, 0,
964 : 119, 227, 0, 70, 0, 272, 0, 0, 257, 255,
965 : 0, 0, 0, 242, 113, 0, 0, 274, 0, 247,
966 : 259, 0, 244, 265, 243, 93, 0, 275, 269, 256,
967 : 263, 267
968 : };
969 :
970 : /* YYPGOTO[NTERM-NUM]. */
971 : static const yytype_int16 yypgoto[] =
972 : {
973 : -363, -45, -363, -363, -363, -363, -363, -363, -4, -363,
974 : -363, -363, -363, 54, -363, -84, -79, -139, -83, -23,
975 : -22, -21, -18, -17, -16, -363, -120, -137, -363, -146,
976 : -125, -363, 18, 21, -363, -363, -363, 136, 146, 145,
977 : -363, -363, -328, -363, -74, -363, -86, -363, -80, 255,
978 : -363, -363, 67, 0, -363, -363, -363, -363, -116, -141,
979 : 28, -54, -226, -85, -210, -339, -136, -363, -363, -142,
980 : -362, -363, -363, -98, -27, -76, -363, -363, -363, -363,
981 : -363, -112, -363, -363, -363, -363, -363, -363, -363, -363,
982 : -363, 172, -363, -363
983 : };
984 :
985 : /* YYDEFGOTO[NTERM-NUM]. */
986 : static const yytype_int16 yydefgoto[] =
987 : {
988 : -1, 236, 164, 165, 166, 324, 167, 168, 169, 170,
989 : 171, 172, 173, 210, 175, 176, 177, 178, 179, 180,
990 : 181, 182, 183, 184, 185, 186, 211, 212, 306, 213,
991 : 188, 122, 214, 215, 81, 82, 83, 111, 112, 113,
992 : 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
993 : 94, 132, 133, 189, 96, 97, 192, 129, 148, 149,
994 : 237, 238, 234, 217, 218, 219, 220, 294, 387, 413,
995 : 351, 352, 353, 414, 221, 222, 223, 399, 224, 400,
996 : 225, 386, 226, 359, 283, 354, 380, 396, 397, 227,
997 : 98, 99, 100, 108
998 : };
999 :
1000 : /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1001 : positive, shift that token. If negative, reduce the rule whose
1002 : number is the opposite. If YYTABLE_NINF, syntax error. */
1003 : static const yytype_int16 yytable[] =
1004 : {
1005 : 95, 105, 123, 115, 314, 187, 233, 240, 124, 114,
1006 : 135, 310, 243, 191, 377, 321, 273, 232, 79, 398,
1007 : 142, 80, 187, 262, 263, 102, 103, 143, 123, 371,
1008 : 115, 384, 229, 106, 115, 252, 114, 372, 144, 230,
1009 : 194, 119, 147, 258, 145, 259, 195, 419, 146, 147,
1010 : 240, 274, 384, 322, 107, 146, 288, 104, 264, 265,
1011 : 123, 244, 245, 412, 266, 267, 235, 249, 147, 412,
1012 : 139, 140, 323, 250, 146, 381, 277, 116, 307, 290,
1013 : 117, 307, 246, 95, 187, 382, 247, 109, 95, 366,
1014 : 416, 307, 307, 233, 319, 308, 307, 320, 95, 307,
1015 : 325, 128, 356, 311, 313, 2, 3, 4, 187, 187,
1016 : 95, 147, 147, 329, 95, 110, 79, 146, 146, 80,
1017 : 118, 103, 95, 337, 338, 339, 340, 319, 349, 95,
1018 : 368, 255, 256, 257, 216, 125, 240, 141, 388, 355,
1019 : 130, 390, 131, 357, 102, 103, 95, 134, 95, 193,
1020 : 310, 190, 295, 296, 297, 298, 299, 300, 301, 302,
1021 : 303, 304, 228, 404, 260, 261, 278, 279, -29, 361,
1022 : 362, 305, 307, 374, 333, 334, 268, 248, 233, 174,
1023 : 253, 335, 336, 341, 342, 420, 271, 269, 281, 270,
1024 : 272, 95, 95, 369, 282, 275, 174, 147, 187, 286,
1025 : 284, 291, 285, 146, 289, 292, -28, 315, 293, 318,
1026 : 241, 242, 316, 383, -23, -245, 358, 363, 365, 364,
1027 : 373, 216, 375, -30, 391, 367, 307, 233, 394, 254,
1028 : 233, 402, 403, 389, 383, 405, 407, 393, 408, 409,
1029 : 207, 415, 411, 328, 421, 343, 392, 344, 406, 345,
1030 : 137, 187, 233, 346, 376, 347, 136, 348, 174, 138,
1031 : 101, 417, 280, 317, 410, 370, 418, 360, 395, 378,
1032 : 127, 0, 0, 0, 233, 0, 0, 95, 379, 0,
1033 : 0, 0, 174, 174, 0, 385, 0, 0, 0, 0,
1034 : 0, 0, 0, 0, 216, 0, 0, 0, 0, 123,
1035 : 0, 0, 0, 0, 0, 124, 385, 0, 0, 330,
1036 : 331, 332, 174, 174, 174, 174, 174, 174, 174, 174,
1037 : 174, 174, 174, 174, 174, 174, 174, 174, 0, 0,
1038 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 401,
1039 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1040 : 0, 0, 0, 216, 216, 0, 0, 0, 0, 216,
1041 : 216, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1042 : 0, 0, 174, 0, 0, 0, 0, 0, 0, 0,
1043 : 216, 0, 0, 0, 0, 95, 0, 0, 0, 0,
1044 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1045 : 0, 0, 216, 0, 0, 0, 0, 0, 216, 0,
1046 : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
1047 : 10, 11, 196, 197, 198, 174, 199, 200, 201, 202,
1048 : 203, 204, 205, 12, 13, 14, 15, 16, 17, 18,
1049 : 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1050 : 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1051 : 39, 40, 41, 42, 43, 44, 45, 46, 47, 206,
1052 : 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
1053 : 58, 59, 60, 61, 0, 62, 63, 64, 65, 66,
1054 : 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
1055 : 77, 150, 78, 151, 152, 153, 154, 155, 0, 0,
1056 : 156, 157, 0, 0, 0, 0, 0, 0, 0, 0,
1057 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 158,
1058 : 0, 0, 0, 207, 208, 0, 0, 0, 0, 209,
1059 : 160, 161, 162, 163, 1, 2, 3, 4, 5, 6,
1060 : 7, 8, 9, 10, 11, 196, 197, 198, 0, 199,
1061 : 200, 201, 202, 203, 204, 205, 12, 13, 14, 15,
1062 : 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1063 : 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1064 : 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1065 : 46, 47, 206, 48, 49, 50, 51, 52, 53, 54,
1066 : 55, 56, 57, 58, 59, 60, 61, 0, 62, 63,
1067 : 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1068 : 74, 75, 76, 77, 150, 78, 151, 152, 153, 154,
1069 : 155, 0, 0, 156, 157, 0, 0, 0, 0, 0,
1070 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1071 : 0, 0, 158, 0, 0, 0, 207, 309, 0, 0,
1072 : 0, 0, 209, 160, 161, 162, 163, 1, 2, 3,
1073 : 4, 5, 6, 7, 8, 9, 10, 11, 196, 197,
1074 : 198, 0, 199, 200, 201, 202, 203, 204, 205, 12,
1075 : 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
1076 : 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
1077 : 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
1078 : 43, 44, 45, 46, 47, 206, 48, 49, 50, 51,
1079 : 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
1080 : 0, 62, 63, 64, 65, 66, 67, 68, 69, 70,
1081 : 71, 72, 73, 74, 75, 76, 77, 150, 78, 151,
1082 : 152, 153, 154, 155, 0, 0, 156, 157, 0, 0,
1083 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1084 : 0, 0, 0, 0, 0, 158, 0, 0, 0, 207,
1085 : 0, 0, 0, 0, 0, 209, 160, 161, 162, 163,
1086 : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1087 : 11, 196, 197, 198, 0, 199, 200, 201, 202, 203,
1088 : 204, 205, 12, 13, 14, 15, 16, 17, 18, 19,
1089 : 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1090 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1091 : 40, 41, 42, 43, 44, 45, 46, 47, 206, 48,
1092 : 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1093 : 59, 60, 61, 0, 62, 63, 64, 65, 66, 67,
1094 : 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
1095 : 150, 78, 151, 152, 153, 154, 155, 0, 0, 156,
1096 : 157, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1097 : 0, 0, 0, 0, 0, 0, 0, 0, 158, 0,
1098 : 0, 0, 134, 0, 0, 0, 0, 0, 209, 160,
1099 : 161, 162, 163, 1, 2, 3, 4, 5, 6, 7,
1100 : 8, 9, 10, 11, 196, 197, 198, 0, 199, 200,
1101 : 201, 202, 203, 204, 205, 12, 13, 14, 15, 16,
1102 : 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
1103 : 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1104 : 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
1105 : 47, 206, 48, 49, 50, 51, 52, 53, 54, 55,
1106 : 56, 57, 58, 59, 60, 61, 0, 62, 63, 64,
1107 : 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1108 : 75, 76, 77, 150, 78, 151, 152, 153, 154, 155,
1109 : 0, 0, 156, 157, 0, 0, 0, 0, 0, 0,
1110 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1111 : 0, 158, 0, 0, 0, 0, 0, 0, 0, 0,
1112 : 0, 209, 160, 161, 162, 163, 1, 2, 3, 4,
1113 : 5, 6, 7, 8, 9, 10, 11, 0, 0, 0,
1114 : 0, 0, 0, 0, 0, 0, 0, 0, 12, 13,
1115 : 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1116 : 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
1117 : 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
1118 : 44, 45, 46, 47, 0, 48, 49, 50, 51, 52,
1119 : 53, 54, 55, 56, 57, 58, 59, 60, 61, 0,
1120 : 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
1121 : 72, 73, 74, 75, 76, 77, 150, 78, 151, 152,
1122 : 153, 154, 155, 0, 0, 156, 157, 0, 0, 0,
1123 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1124 : 1, 2, 3, 4, 158, 6, 7, 8, 9, 10,
1125 : 11, 0, 0, 0, 209, 160, 161, 162, 163, 0,
1126 : 0, 0, 12, 13, 14, 15, 16, 17, 18, 19,
1127 : 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1128 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1129 : 40, 41, 42, 43, 44, 45, 46, 47, 0, 48,
1130 : 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1131 : 59, 60, 61, 0, 62, 63, 64, 65, 66, 67,
1132 : 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
1133 : 150, 78, 151, 152, 153, 154, 155, 0, 0, 156,
1134 : 157, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1135 : 0, 0, 0, 0, 1, 2, 3, 4, 158, 6,
1136 : 7, 8, 9, 10, 11, 0, 0, 0, 0, 160,
1137 : 161, 162, 163, 0, 0, 0, 12, 13, 14, 15,
1138 : 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1139 : 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1140 : 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1141 : 46, 47, 0, 48, 49, 50, 51, 52, 53, 54,
1142 : 55, 56, 57, 58, 59, 60, 61, 0, 62, 63,
1143 : 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1144 : 74, 75, 76, 77, 120, 78, 0, 0, 8, 9,
1145 : 10, 11, 0, 0, 0, 0, 0, 0, 0, 0,
1146 : 0, 0, 0, 12, 13, 14, 15, 16, 17, 18,
1147 : 19, 20, 21, 22, 23, 24, 25, 26, 0, 0,
1148 : 0, 0, 121, 32, 33, 34, 35, 36, 37, 0,
1149 : 0, 0, 0, 0, 0, 0, 0, 46, 47, 0,
1150 : 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
1151 : 58, 59, 60, 61, 0, 62, 63, 64, 65, 66,
1152 : 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
1153 : 0, 150, 78, 151, 152, 153, 154, 155, 0, 0,
1154 : 156, 157, 0, 0, 0, 0, 0, 0, 0, 0,
1155 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 158,
1156 : 0, 0, 159, 8, 9, 10, 11, 0, 0, 0,
1157 : 160, 161, 162, 163, 0, 0, 0, 0, 12, 13,
1158 : 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1159 : 24, 25, 26, 0, 0, 0, 0, 0, 32, 33,
1160 : 34, 35, 36, 37, 0, 0, 0, 0, 0, 0,
1161 : 0, 0, 46, 47, 0, 48, 49, 50, 51, 52,
1162 : 53, 54, 55, 56, 57, 58, 59, 60, 61, 0,
1163 : 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
1164 : 72, 73, 74, 75, 76, 0, 150, 78, 151, 152,
1165 : 153, 154, 155, 0, 0, 156, 157, 0, 0, 0,
1166 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1167 : 0, 0, 0, 0, 158, 0, 0, 231, 8, 9,
1168 : 10, 11, 0, 0, 0, 160, 161, 162, 163, 0,
1169 : 0, 0, 0, 12, 13, 14, 15, 16, 17, 18,
1170 : 19, 20, 21, 22, 23, 24, 25, 26, 0, 0,
1171 : 0, 0, 0, 32, 33, 34, 35, 36, 37, 0,
1172 : 0, 0, 0, 0, 0, 0, 0, 46, 47, 0,
1173 : 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
1174 : 58, 59, 60, 61, 0, 62, 63, 64, 65, 66,
1175 : 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
1176 : 0, 150, 78, 151, 152, 153, 154, 155, 0, 0,
1177 : 156, 157, 0, 0, 0, 0, 0, 0, 0, 0,
1178 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 158,
1179 : 8, 9, 10, 11, 0, 0, 0, 0, 0, 287,
1180 : 160, 161, 162, 163, 0, 12, 13, 14, 15, 16,
1181 : 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
1182 : 0, 0, 0, 0, 0, 32, 33, 34, 35, 36,
1183 : 37, 0, 0, 0, 0, 0, 0, 0, 0, 46,
1184 : 47, 0, 48, 49, 50, 51, 52, 53, 54, 55,
1185 : 56, 57, 58, 59, 60, 61, 0, 62, 63, 64,
1186 : 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1187 : 75, 76, 0, 150, 78, 151, 152, 153, 154, 155,
1188 : 0, 0, 156, 157, 0, 0, 0, 0, 0, 0,
1189 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1190 : 0, 158, 0, 0, 312, 8, 9, 10, 11, 0,
1191 : 0, 0, 160, 161, 162, 163, 0, 0, 0, 0,
1192 : 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1193 : 22, 23, 24, 25, 26, 0, 0, 0, 0, 0,
1194 : 32, 33, 34, 35, 36, 37, 0, 0, 0, 0,
1195 : 0, 0, 0, 0, 46, 47, 0, 48, 49, 50,
1196 : 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
1197 : 61, 0, 62, 63, 64, 65, 66, 67, 68, 69,
1198 : 70, 71, 72, 73, 74, 75, 76, 0, 150, 78,
1199 : 151, 152, 153, 154, 155, 0, 0, 156, 157, 0,
1200 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1201 : 0, 0, 0, 0, 0, 0, 158, 8, 9, 10,
1202 : 11, 0, 0, 0, 0, 0, 0, 160, 161, 162,
1203 : 163, 0, 12, 13, 14, 15, 16, 17, 18, 19,
1204 : 20, 21, 22, 23, 24, 25, 26, 0, 0, 0,
1205 : 0, 0, 32, 33, 34, 35, 36, 37, 0, 0,
1206 : 0, 0, 0, 0, 0, 0, 46, 251, 0, 48,
1207 : 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1208 : 59, 60, 61, 0, 62, 63, 64, 65, 66, 67,
1209 : 68, 69, 70, 71, 72, 73, 74, 75, 76, 0,
1210 : 150, 78, 151, 152, 153, 154, 155, 0, 0, 156,
1211 : 157, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1212 : 0, 0, 0, 0, 1, 2, 3, 4, 158, 6,
1213 : 7, 8, 9, 10, 11, 0, 0, 0, 0, 160,
1214 : 161, 162, 163, 0, 0, 0, 12, 13, 14, 15,
1215 : 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1216 : 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1217 : 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1218 : 46, 47, 0, 48, 49, 50, 51, 52, 53, 54,
1219 : 55, 56, 57, 58, 59, 60, 61, 0, 62, 63,
1220 : 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1221 : 74, 75, 76, 77, 0, 78, 0, 0, 0, 0,
1222 : 0, 0, 0, 0, 0, 0, 1, 2, 3, 4,
1223 : 0, 6, 7, 8, 9, 10, 11, 0, 0, 0,
1224 : 0, 0, 0, 0, 0, 0, 0, 239, 12, 13,
1225 : 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1226 : 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
1227 : 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
1228 : 44, 45, 46, 47, 0, 48, 49, 50, 51, 52,
1229 : 53, 54, 55, 56, 57, 58, 59, 60, 61, 0,
1230 : 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
1231 : 72, 73, 74, 75, 76, 77, 0, 78, 0, 0,
1232 : 0, 0, 0, 0, 0, 0, 0, 0, 1, 2,
1233 : 3, 4, 0, 6, 7, 8, 9, 10, 11, 0,
1234 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 276,
1235 : 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1236 : 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1237 : 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
1238 : 42, 43, 44, 45, 46, 47, 0, 48, 49, 50,
1239 : 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
1240 : 61, 0, 62, 63, 64, 65, 66, 67, 68, 69,
1241 : 70, 71, 72, 73, 74, 75, 76, 77, 0, 78,
1242 : 0, 0, 0, 0, 0, 0, 0, 126, 0, 0,
1243 : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1244 : 11, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1245 : 0, 350, 12, 13, 14, 15, 16, 17, 18, 19,
1246 : 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1247 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1248 : 40, 41, 42, 43, 44, 45, 46, 47, 0, 48,
1249 : 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1250 : 59, 60, 61, 0, 62, 63, 64, 65, 66, 67,
1251 : 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
1252 : 0, 78, 1, 2, 3, 4, 5, 6, 7, 8,
1253 : 9, 10, 11, 0, 0, 0, 0, 0, 0, 0,
1254 : 0, 0, 0, 0, 12, 13, 14, 15, 16, 17,
1255 : 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
1256 : 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
1257 : 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1258 : 0, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1259 : 57, 58, 59, 60, 61, 0, 62, 63, 64, 65,
1260 : 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1261 : 76, 77, 0, 78, 1, 2, 3, 4, 0, 6,
1262 : 7, 8, 9, 10, 11, 0, 0, 0, 0, 0,
1263 : 0, 0, 0, 0, 0, 0, 12, 13, 14, 15,
1264 : 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1265 : 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1266 : 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1267 : 46, 47, 0, 48, 49, 50, 51, 52, 53, 54,
1268 : 55, 56, 57, 58, 59, 60, 61, 0, 62, 63,
1269 : 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1270 : 74, 75, 76, 77, 0, 78, 8, 9, 10, 11,
1271 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1272 : 0, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1273 : 21, 22, 23, 24, 25, 26, 0, 0, 0, 0,
1274 : 0, 32, 33, 34, 35, 36, 37, 0, 0, 0,
1275 : 0, 0, 0, 0, 0, 46, 47, 0, 48, 49,
1276 : 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1277 : 60, 61, 0, 62, 63, 64, 65, 66, 67, 68,
1278 : 69, 70, 71, 72, 73, 74, 75, 76, 0, 326,
1279 : 78, 8, 9, 10, 11, 327, 0, 0, 0, 0,
1280 : 0, 0, 0, 0, 0, 0, 12, 13, 14, 15,
1281 : 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1282 : 26, 0, 0, 0, 0, 0, 32, 33, 34, 35,
1283 : 36, 37, 0, 0, 0, 0, 0, 0, 0, 0,
1284 : 46, 47, 0, 48, 49, 50, 51, 52, 53, 54,
1285 : 55, 56, 57, 58, 59, 60, 61, 0, 62, 63,
1286 : 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1287 : 74, 75, 76, 0, 0, 78
1288 : };
1289 :
1290 : static const yytype_int16 yycheck[] =
1291 : {
1292 : 0, 46, 88, 83, 230, 125, 143, 148, 88, 83,
1293 : 108, 221, 158, 129, 353, 93, 109, 142, 0, 381,
1294 : 123, 0, 142, 104, 105, 93, 94, 130, 114, 123,
1295 : 110, 359, 123, 121, 114, 172, 110, 131, 125, 130,
1296 : 122, 86, 122, 133, 131, 135, 128, 409, 122, 129,
1297 : 191, 144, 380, 131, 131, 129, 202, 125, 139, 140,
1298 : 146, 102, 103, 402, 106, 107, 146, 122, 148, 408,
1299 : 115, 116, 122, 128, 148, 122, 192, 128, 128, 204,
1300 : 131, 128, 123, 83, 204, 122, 127, 122, 88, 315,
1301 : 122, 128, 128, 230, 128, 131, 128, 131, 98, 128,
1302 : 246, 101, 131, 228, 229, 4, 5, 6, 228, 229,
1303 : 110, 191, 192, 250, 114, 128, 98, 191, 192, 98,
1304 : 93, 94, 122, 262, 263, 264, 265, 128, 274, 129,
1305 : 131, 136, 137, 138, 134, 123, 277, 121, 364, 285,
1306 : 125, 367, 93, 289, 93, 94, 146, 125, 148, 130,
1307 : 360, 131, 111, 112, 113, 114, 115, 116, 117, 118,
1308 : 119, 120, 123, 389, 100, 101, 96, 97, 121, 306,
1309 : 307, 130, 128, 129, 258, 259, 143, 122, 315, 125,
1310 : 121, 260, 261, 266, 267, 411, 108, 142, 131, 141,
1311 : 110, 191, 192, 318, 131, 124, 142, 277, 318, 131,
1312 : 121, 129, 121, 277, 121, 121, 121, 130, 126, 123,
1313 : 156, 157, 124, 359, 122, 125, 129, 124, 124, 130,
1314 : 124, 221, 61, 121, 124, 130, 128, 364, 121, 175,
1315 : 367, 122, 126, 130, 380, 124, 131, 374, 122, 17,
1316 : 125, 131, 130, 247, 131, 268, 371, 269, 394, 270,
1317 : 114, 371, 389, 271, 352, 272, 110, 273, 204, 114,
1318 : 5, 407, 195, 235, 400, 319, 408, 294, 380, 354,
1319 : 98, -1, -1, -1, 411, -1, -1, 277, 354, -1,
1320 : -1, -1, 228, 229, -1, 359, -1, -1, -1, -1,
1321 : -1, -1, -1, -1, 294, -1, -1, -1, -1, 385,
1322 : -1, -1, -1, -1, -1, 385, 380, -1, -1, 255,
1323 : 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
1324 : 266, 267, 268, 269, 270, 271, 272, 273, -1, -1,
1325 : -1, -1, -1, -1, -1, -1, -1, -1, -1, 384,
1326 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1327 : -1, -1, -1, 353, 354, -1, -1, -1, -1, 359,
1328 : 360, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1329 : -1, -1, 318, -1, -1, -1, -1, -1, -1, -1,
1330 : 380, -1, -1, -1, -1, 385, -1, -1, -1, -1,
1331 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1332 : -1, -1, 402, -1, -1, -1, -1, -1, 408, -1,
1333 : -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
1334 : 12, 13, 14, 15, 16, 371, 18, 19, 20, 21,
1335 : 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1336 : 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
1337 : 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
1338 : 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
1339 : 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
1340 : 72, 73, 74, 75, -1, 77, 78, 79, 80, 81,
1341 : 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
1342 : 92, 93, 94, 95, 96, 97, 98, 99, -1, -1,
1343 : 102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
1344 : -1, -1, -1, -1, -1, -1, -1, -1, -1, 121,
1345 : -1, -1, -1, 125, 126, -1, -1, -1, -1, 131,
1346 : 132, 133, 134, 135, 3, 4, 5, 6, 7, 8,
1347 : 9, 10, 11, 12, 13, 14, 15, 16, -1, 18,
1348 : 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1349 : 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1350 : 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
1351 : 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1352 : 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
1353 : 69, 70, 71, 72, 73, 74, 75, -1, 77, 78,
1354 : 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
1355 : 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
1356 : 99, -1, -1, 102, 103, -1, -1, -1, -1, -1,
1357 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1358 : -1, -1, 121, -1, -1, -1, 125, 126, -1, -1,
1359 : -1, -1, 131, 132, 133, 134, 135, 3, 4, 5,
1360 : 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1361 : 16, -1, 18, 19, 20, 21, 22, 23, 24, 25,
1362 : 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1363 : 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1364 : 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1365 : 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1366 : 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1367 : -1, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1368 : 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1369 : 96, 97, 98, 99, -1, -1, 102, 103, -1, -1,
1370 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1371 : -1, -1, -1, -1, -1, 121, -1, -1, -1, 125,
1372 : -1, -1, -1, -1, -1, 131, 132, 133, 134, 135,
1373 : 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1374 : 13, 14, 15, 16, -1, 18, 19, 20, 21, 22,
1375 : 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
1376 : 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
1377 : 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
1378 : 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
1379 : 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
1380 : 73, 74, 75, -1, 77, 78, 79, 80, 81, 82,
1381 : 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
1382 : 93, 94, 95, 96, 97, 98, 99, -1, -1, 102,
1383 : 103, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1384 : -1, -1, -1, -1, -1, -1, -1, -1, 121, -1,
1385 : -1, -1, 125, -1, -1, -1, -1, -1, 131, 132,
1386 : 133, 134, 135, 3, 4, 5, 6, 7, 8, 9,
1387 : 10, 11, 12, 13, 14, 15, 16, -1, 18, 19,
1388 : 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1389 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1390 : 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1391 : 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1392 : 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
1393 : 70, 71, 72, 73, 74, 75, -1, 77, 78, 79,
1394 : 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
1395 : 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
1396 : -1, -1, 102, 103, -1, -1, -1, -1, -1, -1,
1397 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1398 : -1, 121, -1, -1, -1, -1, -1, -1, -1, -1,
1399 : -1, 131, 132, 133, 134, 135, 3, 4, 5, 6,
1400 : 7, 8, 9, 10, 11, 12, 13, -1, -1, -1,
1401 : -1, -1, -1, -1, -1, -1, -1, -1, 25, 26,
1402 : 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1403 : 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
1404 : 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1405 : 57, 58, 59, 60, -1, 62, 63, 64, 65, 66,
1406 : 67, 68, 69, 70, 71, 72, 73, 74, 75, -1,
1407 : 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
1408 : 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
1409 : 97, 98, 99, -1, -1, 102, 103, -1, -1, -1,
1410 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1411 : 3, 4, 5, 6, 121, 8, 9, 10, 11, 12,
1412 : 13, -1, -1, -1, 131, 132, 133, 134, 135, -1,
1413 : -1, -1, 25, 26, 27, 28, 29, 30, 31, 32,
1414 : 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
1415 : 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
1416 : 53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
1417 : 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
1418 : 73, 74, 75, -1, 77, 78, 79, 80, 81, 82,
1419 : 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
1420 : 93, 94, 95, 96, 97, 98, 99, -1, -1, 102,
1421 : 103, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1422 : -1, -1, -1, -1, 3, 4, 5, 6, 121, 8,
1423 : 9, 10, 11, 12, 13, -1, -1, -1, -1, 132,
1424 : 133, 134, 135, -1, -1, -1, 25, 26, 27, 28,
1425 : 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1426 : 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
1427 : 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1428 : 59, 60, -1, 62, 63, 64, 65, 66, 67, 68,
1429 : 69, 70, 71, 72, 73, 74, 75, -1, 77, 78,
1430 : 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
1431 : 89, 90, 91, 92, 93, 94, -1, -1, 10, 11,
1432 : 12, 13, -1, -1, -1, -1, -1, -1, -1, -1,
1433 : -1, -1, -1, 25, 26, 27, 28, 29, 30, 31,
1434 : 32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
1435 : -1, -1, 131, 45, 46, 47, 48, 49, 50, -1,
1436 : -1, -1, -1, -1, -1, -1, -1, 59, 60, -1,
1437 : 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
1438 : 72, 73, 74, 75, -1, 77, 78, 79, 80, 81,
1439 : 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
1440 : -1, 93, 94, 95, 96, 97, 98, 99, -1, -1,
1441 : 102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
1442 : -1, -1, -1, -1, -1, -1, -1, -1, -1, 121,
1443 : -1, -1, 124, 10, 11, 12, 13, -1, -1, -1,
1444 : 132, 133, 134, 135, -1, -1, -1, -1, 25, 26,
1445 : 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1446 : 37, 38, 39, -1, -1, -1, -1, -1, 45, 46,
1447 : 47, 48, 49, 50, -1, -1, -1, -1, -1, -1,
1448 : -1, -1, 59, 60, -1, 62, 63, 64, 65, 66,
1449 : 67, 68, 69, 70, 71, 72, 73, 74, 75, -1,
1450 : 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
1451 : 87, 88, 89, 90, 91, -1, 93, 94, 95, 96,
1452 : 97, 98, 99, -1, -1, 102, 103, -1, -1, -1,
1453 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1454 : -1, -1, -1, -1, 121, -1, -1, 124, 10, 11,
1455 : 12, 13, -1, -1, -1, 132, 133, 134, 135, -1,
1456 : -1, -1, -1, 25, 26, 27, 28, 29, 30, 31,
1457 : 32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
1458 : -1, -1, -1, 45, 46, 47, 48, 49, 50, -1,
1459 : -1, -1, -1, -1, -1, -1, -1, 59, 60, -1,
1460 : 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
1461 : 72, 73, 74, 75, -1, 77, 78, 79, 80, 81,
1462 : 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
1463 : -1, 93, 94, 95, 96, 97, 98, 99, -1, -1,
1464 : 102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
1465 : -1, -1, -1, -1, -1, -1, -1, -1, -1, 121,
1466 : 10, 11, 12, 13, -1, -1, -1, -1, -1, 131,
1467 : 132, 133, 134, 135, -1, 25, 26, 27, 28, 29,
1468 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1469 : -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
1470 : 50, -1, -1, -1, -1, -1, -1, -1, -1, 59,
1471 : 60, -1, 62, 63, 64, 65, 66, 67, 68, 69,
1472 : 70, 71, 72, 73, 74, 75, -1, 77, 78, 79,
1473 : 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
1474 : 90, 91, -1, 93, 94, 95, 96, 97, 98, 99,
1475 : -1, -1, 102, 103, -1, -1, -1, -1, -1, -1,
1476 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1477 : -1, 121, -1, -1, 124, 10, 11, 12, 13, -1,
1478 : -1, -1, 132, 133, 134, 135, -1, -1, -1, -1,
1479 : 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1480 : 35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
1481 : 45, 46, 47, 48, 49, 50, -1, -1, -1, -1,
1482 : -1, -1, -1, -1, 59, 60, -1, 62, 63, 64,
1483 : 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1484 : 75, -1, 77, 78, 79, 80, 81, 82, 83, 84,
1485 : 85, 86, 87, 88, 89, 90, 91, -1, 93, 94,
1486 : 95, 96, 97, 98, 99, -1, -1, 102, 103, -1,
1487 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1488 : -1, -1, -1, -1, -1, -1, 121, 10, 11, 12,
1489 : 13, -1, -1, -1, -1, -1, -1, 132, 133, 134,
1490 : 135, -1, 25, 26, 27, 28, 29, 30, 31, 32,
1491 : 33, 34, 35, 36, 37, 38, 39, -1, -1, -1,
1492 : -1, -1, 45, 46, 47, 48, 49, 50, -1, -1,
1493 : -1, -1, -1, -1, -1, -1, 59, 60, -1, 62,
1494 : 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
1495 : 73, 74, 75, -1, 77, 78, 79, 80, 81, 82,
1496 : 83, 84, 85, 86, 87, 88, 89, 90, 91, -1,
1497 : 93, 94, 95, 96, 97, 98, 99, -1, -1, 102,
1498 : 103, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1499 : -1, -1, -1, -1, 3, 4, 5, 6, 121, 8,
1500 : 9, 10, 11, 12, 13, -1, -1, -1, -1, 132,
1501 : 133, 134, 135, -1, -1, -1, 25, 26, 27, 28,
1502 : 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1503 : 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
1504 : 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1505 : 59, 60, -1, 62, 63, 64, 65, 66, 67, 68,
1506 : 69, 70, 71, 72, 73, 74, 75, -1, 77, 78,
1507 : 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
1508 : 89, 90, 91, 92, -1, 94, -1, -1, -1, -1,
1509 : -1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
1510 : -1, 8, 9, 10, 11, 12, 13, -1, -1, -1,
1511 : -1, -1, -1, -1, -1, -1, -1, 126, 25, 26,
1512 : 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1513 : 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
1514 : 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1515 : 57, 58, 59, 60, -1, 62, 63, 64, 65, 66,
1516 : 67, 68, 69, 70, 71, 72, 73, 74, 75, -1,
1517 : 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
1518 : 87, 88, 89, 90, 91, 92, -1, 94, -1, -1,
1519 : -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
1520 : 5, 6, -1, 8, 9, 10, 11, 12, 13, -1,
1521 : -1, -1, -1, -1, -1, -1, -1, -1, -1, 126,
1522 : 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1523 : 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1524 : 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1525 : 55, 56, 57, 58, 59, 60, -1, 62, 63, 64,
1526 : 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1527 : 75, -1, 77, 78, 79, 80, 81, 82, 83, 84,
1528 : 85, 86, 87, 88, 89, 90, 91, 92, -1, 94,
1529 : -1, -1, -1, -1, -1, -1, -1, 0, -1, -1,
1530 : 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1531 : 13, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1532 : -1, 126, 25, 26, 27, 28, 29, 30, 31, 32,
1533 : 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
1534 : 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
1535 : 53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
1536 : 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
1537 : 73, 74, 75, -1, 77, 78, 79, 80, 81, 82,
1538 : 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
1539 : -1, 94, 3, 4, 5, 6, 7, 8, 9, 10,
1540 : 11, 12, 13, -1, -1, -1, -1, -1, -1, -1,
1541 : -1, -1, -1, -1, 25, 26, 27, 28, 29, 30,
1542 : 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1543 : 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
1544 : 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
1545 : -1, 62, 63, 64, 65, 66, 67, 68, 69, 70,
1546 : 71, 72, 73, 74, 75, -1, 77, 78, 79, 80,
1547 : 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
1548 : 91, 92, -1, 94, 3, 4, 5, 6, -1, 8,
1549 : 9, 10, 11, 12, 13, -1, -1, -1, -1, -1,
1550 : -1, -1, -1, -1, -1, -1, 25, 26, 27, 28,
1551 : 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1552 : 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
1553 : 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1554 : 59, 60, -1, 62, 63, 64, 65, 66, 67, 68,
1555 : 69, 70, 71, 72, 73, 74, 75, -1, 77, 78,
1556 : 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
1557 : 89, 90, 91, 92, -1, 94, 10, 11, 12, 13,
1558 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1559 : -1, 25, 26, 27, 28, 29, 30, 31, 32, 33,
1560 : 34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
1561 : -1, 45, 46, 47, 48, 49, 50, -1, -1, -1,
1562 : -1, -1, -1, -1, -1, 59, 60, -1, 62, 63,
1563 : 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1564 : 74, 75, -1, 77, 78, 79, 80, 81, 82, 83,
1565 : 84, 85, 86, 87, 88, 89, 90, 91, -1, 93,
1566 : 94, 10, 11, 12, 13, 99, -1, -1, -1, -1,
1567 : -1, -1, -1, -1, -1, -1, 25, 26, 27, 28,
1568 : 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1569 : 39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
1570 : 49, 50, -1, -1, -1, -1, -1, -1, -1, -1,
1571 : 59, 60, -1, 62, 63, 64, 65, 66, 67, 68,
1572 : 69, 70, 71, 72, 73, 74, 75, -1, 77, 78,
1573 : 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
1574 : 89, 90, 91, -1, -1, 94
1575 : };
1576 :
1577 : /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1578 : symbol of state STATE-NUM. */
1579 : static const yytype_uint8 yystos[] =
1580 : {
1581 : 0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
1582 : 12, 13, 25, 26, 27, 28, 29, 30, 31, 32,
1583 : 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
1584 : 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
1585 : 53, 54, 55, 56, 57, 58, 59, 60, 62, 63,
1586 : 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1587 : 74, 75, 77, 78, 79, 80, 81, 82, 83, 84,
1588 : 85, 86, 87, 88, 89, 90, 91, 92, 94, 177,
1589 : 178, 179, 180, 181, 185, 186, 187, 188, 189, 190,
1590 : 191, 192, 193, 194, 195, 198, 199, 200, 235, 236,
1591 : 237, 194, 93, 94, 125, 146, 121, 131, 238, 122,
1592 : 128, 182, 183, 184, 189, 193, 128, 131, 93, 146,
1593 : 93, 131, 176, 191, 193, 123, 0, 236, 198, 202,
1594 : 125, 93, 196, 197, 125, 218, 183, 182, 184, 146,
1595 : 146, 121, 123, 130, 125, 131, 189, 193, 203, 204,
1596 : 93, 95, 96, 97, 98, 99, 102, 103, 121, 124,
1597 : 132, 133, 134, 135, 147, 148, 149, 151, 152, 153,
1598 : 154, 155, 156, 157, 158, 159, 160, 161, 162, 163,
1599 : 164, 165, 166, 167, 168, 169, 170, 171, 175, 198,
1600 : 131, 203, 201, 130, 122, 128, 14, 15, 16, 18,
1601 : 19, 20, 21, 22, 23, 24, 61, 125, 126, 131,
1602 : 158, 171, 172, 174, 177, 178, 198, 208, 209, 210,
1603 : 211, 219, 220, 221, 223, 225, 227, 234, 123, 123,
1604 : 130, 124, 175, 172, 207, 193, 146, 205, 206, 126,
1605 : 204, 158, 158, 174, 102, 103, 123, 127, 122, 122,
1606 : 128, 60, 172, 121, 158, 136, 137, 138, 133, 135,
1607 : 100, 101, 104, 105, 139, 140, 106, 107, 143, 142,
1608 : 141, 108, 110, 109, 144, 124, 126, 203, 96, 97,
1609 : 197, 131, 131, 229, 121, 121, 131, 131, 174, 121,
1610 : 175, 129, 121, 126, 212, 111, 112, 113, 114, 115,
1611 : 116, 117, 118, 119, 120, 130, 173, 128, 131, 126,
1612 : 209, 175, 124, 175, 207, 130, 124, 205, 123, 128,
1613 : 131, 93, 131, 122, 150, 174, 93, 99, 153, 172,
1614 : 158, 158, 158, 160, 160, 161, 161, 162, 162, 162,
1615 : 162, 163, 163, 164, 165, 166, 167, 168, 169, 174,
1616 : 126, 215, 216, 217, 230, 174, 131, 174, 129, 228,
1617 : 219, 172, 172, 124, 130, 124, 207, 130, 131, 175,
1618 : 206, 123, 131, 124, 129, 61, 218, 210, 208, 220,
1619 : 231, 122, 122, 174, 187, 189, 226, 213, 207, 130,
1620 : 207, 124, 175, 172, 121, 226, 232, 233, 215, 222,
1621 : 224, 146, 122, 126, 207, 124, 174, 131, 122, 17,
1622 : 211, 130, 210, 214, 218, 131, 122, 174, 214, 215,
1623 : 207, 131
1624 : };
1625 :
1626 : /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1627 : static const yytype_uint8 yyr1[] =
1628 : {
1629 : 0, 145, 146, 146, 147, 148, 148, 148, 148, 148,
1630 : 148, 149, 149, 149, 149, 149, 149, 150, 151, 152,
1631 : 152, 153, 153, 154, 154, 155, 155, 156, 157, 157,
1632 : 157, 158, 158, 158, 158, 159, 159, 159, 159, 160,
1633 : 160, 160, 160, 161, 161, 161, 162, 162, 162, 163,
1634 : 163, 163, 163, 163, 164, 164, 164, 165, 165, 166,
1635 : 166, 167, 167, 168, 168, 169, 169, 170, 170, 171,
1636 : 171, 172, 172, 173, 173, 173, 173, 173, 173, 173,
1637 : 173, 173, 173, 173, 174, 174, 175, 176, 177, 177,
1638 : 177, 177, 177, 177, 177, 177, 178, 179, 179, 180,
1639 : 180, 181, 182, 182, 183, 183, 183, 183, 184, 185,
1640 : 185, 185, 185, 185, 185, 186, 186, 186, 186, 186,
1641 : 186, 187, 187, 188, 188, 189, 189, 190, 191, 191,
1642 : 191, 191, 191, 192, 192, 192, 192, 192, 192, 192,
1643 : 192, 192, 192, 192, 192, 192, 193, 194, 194, 194,
1644 : 195, 196, 196, 197, 197, 197, 198, 198, 198, 199,
1645 : 199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
1646 : 199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
1647 : 199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
1648 : 199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
1649 : 199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
1650 : 199, 199, 199, 199, 199, 199, 201, 200, 202, 200,
1651 : 203, 203, 204, 204, 205, 205, 206, 206, 207, 208,
1652 : 209, 209, 210, 210, 210, 210, 210, 210, 210, 211,
1653 : 212, 213, 211, 214, 214, 216, 215, 217, 215, 218,
1654 : 218, 219, 219, 220, 220, 221, 222, 222, 224, 223,
1655 : 225, 225, 226, 226, 228, 227, 229, 227, 230, 227,
1656 : 231, 231, 232, 232, 233, 233, 234, 234, 234, 234,
1657 : 234, 235, 235, 236, 236, 238, 237
1658 : };
1659 :
1660 : /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1661 : static const yytype_uint8 yyr2[] =
1662 : {
1663 : 0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
1664 : 3, 1, 4, 1, 3, 2, 2, 1, 1, 1,
1665 : 3, 2, 2, 2, 1, 2, 3, 2, 1, 1,
1666 : 1, 1, 2, 2, 2, 1, 1, 1, 1, 1,
1667 : 3, 3, 3, 1, 3, 3, 1, 3, 3, 1,
1668 : 3, 3, 3, 3, 1, 3, 3, 1, 3, 1,
1669 : 3, 1, 3, 1, 3, 1, 3, 1, 3, 1,
1670 : 5, 1, 3, 1, 1, 1, 1, 1, 1, 1,
1671 : 1, 1, 1, 1, 1, 3, 1, 2, 2, 2,
1672 : 4, 5, 6, 9, 2, 3, 2, 1, 1, 2,
1673 : 3, 3, 2, 5, 2, 1, 2, 1, 1, 1,
1674 : 3, 6, 7, 8, 5, 1, 2, 5, 6, 7,
1675 : 4, 1, 2, 1, 1, 1, 2, 1, 1, 1,
1676 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1677 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1678 : 4, 1, 3, 1, 3, 3, 1, 3, 4, 1,
1679 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1680 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1681 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1682 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1683 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1684 : 1, 1, 1, 1, 1, 1, 0, 6, 0, 5,
1685 : 1, 2, 3, 4, 1, 3, 1, 4, 1, 1,
1686 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
1687 : 0, 0, 5, 1, 1, 0, 2, 0, 2, 2,
1688 : 3, 1, 2, 1, 2, 5, 3, 1, 0, 6,
1689 : 3, 2, 1, 4, 0, 6, 0, 8, 0, 7,
1690 : 1, 1, 1, 0, 2, 3, 2, 2, 2, 3,
1691 : 2, 1, 2, 1, 1, 0, 3
1692 : };
1693 :
1694 :
1695 : #define yyerrok (yyerrstatus = 0)
1696 : #define yyclearin (yychar = YYEMPTY)
1697 : #define YYEMPTY (-2)
1698 : #define YYEOF 0
1699 :
1700 : #define YYACCEPT goto yyacceptlab
1701 : #define YYABORT goto yyabortlab
1702 : #define YYERROR goto yyerrorlab
1703 :
1704 :
1705 : #define YYRECOVERING() (!!yyerrstatus)
1706 :
1707 : #define YYBACKUP(Token, Value) \
1708 : do \
1709 : if (yychar == YYEMPTY) \
1710 : { \
1711 : yychar = (Token); \
1712 : yylval = (Value); \
1713 : YYPOPSTACK (yylen); \
1714 : yystate = *yyssp; \
1715 : goto yybackup; \
1716 : } \
1717 : else \
1718 : { \
1719 : yyerror (&yylloc, context, scanner, YY_("syntax error: cannot back up")); \
1720 : YYERROR; \
1721 : } \
1722 : while (0)
1723 :
1724 : /* Error token number */
1725 : #define YYTERROR 1
1726 : #define YYERRCODE 256
1727 :
1728 :
1729 : /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1730 : If N is 0, then set CURRENT to the empty location which ends
1731 : the previous symbol: RHS[0] (always defined). */
1732 :
1733 : #ifndef YYLLOC_DEFAULT
1734 : # define YYLLOC_DEFAULT(Current, Rhs, N) \
1735 : do \
1736 : if (N) \
1737 : { \
1738 : (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1739 : (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1740 : (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1741 : (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1742 : } \
1743 : else \
1744 : { \
1745 : (Current).first_line = (Current).last_line = \
1746 : YYRHSLOC (Rhs, 0).last_line; \
1747 : (Current).first_column = (Current).last_column = \
1748 : YYRHSLOC (Rhs, 0).last_column; \
1749 : } \
1750 : while (0)
1751 : #endif
1752 :
1753 : #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1754 :
1755 :
1756 : /* Enable debugging if requested. */
1757 : #if YYDEBUG
1758 :
1759 : # ifndef YYFPRINTF
1760 : # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1761 : # define YYFPRINTF fprintf
1762 : # endif
1763 :
1764 : # define YYDPRINTF(Args) \
1765 : do { \
1766 : if (yydebug) \
1767 : YYFPRINTF Args; \
1768 : } while (0)
1769 :
1770 :
1771 : /* YY_LOCATION_PRINT -- Print the location on the stream.
1772 : This macro was not mandated originally: define only if we know
1773 : we won't break user code: when these are the locations we know. */
1774 :
1775 : #ifndef YY_LOCATION_PRINT
1776 : # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1777 :
1778 : /* Print *YYLOCP on YYO. Private, do not rely on its existence. */
1779 :
1780 : YY_ATTRIBUTE_UNUSED
1781 : static unsigned
1782 : yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
1783 : {
1784 : unsigned res = 0;
1785 : int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
1786 : if (0 <= yylocp->first_line)
1787 : {
1788 : res += YYFPRINTF (yyo, "%d", yylocp->first_line);
1789 : if (0 <= yylocp->first_column)
1790 : res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
1791 : }
1792 : if (0 <= yylocp->last_line)
1793 : {
1794 : if (yylocp->first_line < yylocp->last_line)
1795 : {
1796 : res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
1797 : if (0 <= end_col)
1798 : res += YYFPRINTF (yyo, ".%d", end_col);
1799 : }
1800 : else if (0 <= end_col && yylocp->first_column < end_col)
1801 : res += YYFPRINTF (yyo, "-%d", end_col);
1802 : }
1803 : return res;
1804 : }
1805 :
1806 : # define YY_LOCATION_PRINT(File, Loc) \
1807 : yy_location_print_ (File, &(Loc))
1808 :
1809 : # else
1810 : # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1811 : # endif
1812 : #endif
1813 :
1814 :
1815 : # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1816 : do { \
1817 : if (yydebug) \
1818 : { \
1819 : YYFPRINTF (stderr, "%s ", Title); \
1820 : yy_symbol_print (stderr, \
1821 : Type, Value, Location, context, scanner); \
1822 : YYFPRINTF (stderr, "\n"); \
1823 : } \
1824 : } while (0)
1825 :
1826 :
1827 : /*----------------------------------------.
1828 : | Print this symbol's value on YYOUTPUT. |
1829 : `----------------------------------------*/
1830 :
1831 : static void
1832 : yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, TParseContext* context, void *scanner)
1833 : {
1834 : FILE *yyo = yyoutput;
1835 : YYUSE (yyo);
1836 : YYUSE (yylocationp);
1837 : YYUSE (context);
1838 : YYUSE (scanner);
1839 : if (!yyvaluep)
1840 : return;
1841 : # ifdef YYPRINT
1842 : if (yytype < YYNTOKENS)
1843 : YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1844 : # endif
1845 : YYUSE (yytype);
1846 : }
1847 :
1848 :
1849 : /*--------------------------------.
1850 : | Print this symbol on YYOUTPUT. |
1851 : `--------------------------------*/
1852 :
1853 : static void
1854 : yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, TParseContext* context, void *scanner)
1855 : {
1856 : YYFPRINTF (yyoutput, "%s %s (",
1857 : yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1858 :
1859 : YY_LOCATION_PRINT (yyoutput, *yylocationp);
1860 : YYFPRINTF (yyoutput, ": ");
1861 : yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, context, scanner);
1862 : YYFPRINTF (yyoutput, ")");
1863 : }
1864 :
1865 : /*------------------------------------------------------------------.
1866 : | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1867 : | TOP (included). |
1868 : `------------------------------------------------------------------*/
1869 :
1870 : static void
1871 : yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1872 : {
1873 : YYFPRINTF (stderr, "Stack now");
1874 : for (; yybottom <= yytop; yybottom++)
1875 : {
1876 : int yybot = *yybottom;
1877 : YYFPRINTF (stderr, " %d", yybot);
1878 : }
1879 : YYFPRINTF (stderr, "\n");
1880 : }
1881 :
1882 : # define YY_STACK_PRINT(Bottom, Top) \
1883 : do { \
1884 : if (yydebug) \
1885 : yy_stack_print ((Bottom), (Top)); \
1886 : } while (0)
1887 :
1888 :
1889 : /*------------------------------------------------.
1890 : | Report that the YYRULE is going to be reduced. |
1891 : `------------------------------------------------*/
1892 :
1893 : static void
1894 : yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, TParseContext* context, void *scanner)
1895 : {
1896 : unsigned long int yylno = yyrline[yyrule];
1897 : int yynrhs = yyr2[yyrule];
1898 : int yyi;
1899 : YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1900 : yyrule - 1, yylno);
1901 : /* The symbols being reduced. */
1902 : for (yyi = 0; yyi < yynrhs; yyi++)
1903 : {
1904 : YYFPRINTF (stderr, " $%d = ", yyi + 1);
1905 : yy_symbol_print (stderr,
1906 : yystos[yyssp[yyi + 1 - yynrhs]],
1907 : &(yyvsp[(yyi + 1) - (yynrhs)])
1908 : , &(yylsp[(yyi + 1) - (yynrhs)]) , context, scanner);
1909 : YYFPRINTF (stderr, "\n");
1910 : }
1911 : }
1912 :
1913 : # define YY_REDUCE_PRINT(Rule) \
1914 : do { \
1915 : if (yydebug) \
1916 : yy_reduce_print (yyssp, yyvsp, yylsp, Rule, context, scanner); \
1917 : } while (0)
1918 :
1919 : /* Nonzero means print parse trace. It is left uninitialized so that
1920 : multiple parsers can coexist. */
1921 : int yydebug;
1922 : #else /* !YYDEBUG */
1923 : # define YYDPRINTF(Args)
1924 : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1925 : # define YY_STACK_PRINT(Bottom, Top)
1926 : # define YY_REDUCE_PRINT(Rule)
1927 : #endif /* !YYDEBUG */
1928 :
1929 :
1930 : /* YYINITDEPTH -- initial size of the parser's stacks. */
1931 : #ifndef YYINITDEPTH
1932 : # define YYINITDEPTH 200
1933 : #endif
1934 :
1935 : /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1936 : if the built-in stack extension method is used).
1937 :
1938 : Do not make this value too large; the results are undefined if
1939 : YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1940 : evaluated with infinite-precision integer arithmetic. */
1941 :
1942 : #ifndef YYMAXDEPTH
1943 : # define YYMAXDEPTH 10000
1944 : #endif
1945 :
1946 :
1947 : #if YYERROR_VERBOSE
1948 :
1949 : # ifndef yystrlen
1950 : # if defined __GLIBC__ && defined _STRING_H
1951 : # define yystrlen strlen
1952 : # else
1953 : /* Return the length of YYSTR. */
1954 : static YYSIZE_T
1955 : yystrlen (const char *yystr)
1956 : {
1957 : YYSIZE_T yylen;
1958 : for (yylen = 0; yystr[yylen]; yylen++)
1959 : continue;
1960 : return yylen;
1961 : }
1962 : # endif
1963 : # endif
1964 :
1965 : # ifndef yystpcpy
1966 : # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1967 : # define yystpcpy stpcpy
1968 : # else
1969 : /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1970 : YYDEST. */
1971 : static char *
1972 : yystpcpy (char *yydest, const char *yysrc)
1973 : {
1974 : char *yyd = yydest;
1975 : const char *yys = yysrc;
1976 :
1977 : while ((*yyd++ = *yys++) != '\0')
1978 : continue;
1979 :
1980 : return yyd - 1;
1981 : }
1982 : # endif
1983 : # endif
1984 :
1985 : # ifndef yytnamerr
1986 : /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1987 : quotes and backslashes, so that it's suitable for yyerror. The
1988 : heuristic is that double-quoting is unnecessary unless the string
1989 : contains an apostrophe, a comma, or backslash (other than
1990 : backslash-backslash). YYSTR is taken from yytname. If YYRES is
1991 : null, do not copy; instead, return the length of what the result
1992 : would have been. */
1993 : static YYSIZE_T
1994 : yytnamerr (char *yyres, const char *yystr)
1995 : {
1996 : if (*yystr == '"')
1997 : {
1998 : YYSIZE_T yyn = 0;
1999 : char const *yyp = yystr;
2000 :
2001 : for (;;)
2002 : switch (*++yyp)
2003 : {
2004 : case '\'':
2005 : case ',':
2006 : goto do_not_strip_quotes;
2007 :
2008 : case '\\':
2009 : if (*++yyp != '\\')
2010 : goto do_not_strip_quotes;
2011 : /* Fall through. */
2012 : default:
2013 : if (yyres)
2014 : yyres[yyn] = *yyp;
2015 : yyn++;
2016 : break;
2017 :
2018 : case '"':
2019 : if (yyres)
2020 : yyres[yyn] = '\0';
2021 : return yyn;
2022 : }
2023 : do_not_strip_quotes: ;
2024 : }
2025 :
2026 : if (! yyres)
2027 : return yystrlen (yystr);
2028 :
2029 : return yystpcpy (yyres, yystr) - yyres;
2030 : }
2031 : # endif
2032 :
2033 : /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
2034 : about the unexpected token YYTOKEN for the state stack whose top is
2035 : YYSSP.
2036 :
2037 : Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
2038 : not large enough to hold the message. In that case, also set
2039 : *YYMSG_ALLOC to the required number of bytes. Return 2 if the
2040 : required number of bytes is too large to store. */
2041 : static int
2042 : yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
2043 : yytype_int16 *yyssp, int yytoken)
2044 : {
2045 : YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
2046 : YYSIZE_T yysize = yysize0;
2047 : enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2048 : /* Internationalized format string. */
2049 : const char *yyformat = YY_NULLPTR;
2050 : /* Arguments of yyformat. */
2051 : char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2052 : /* Number of reported tokens (one for the "unexpected", one per
2053 : "expected"). */
2054 : int yycount = 0;
2055 :
2056 : /* There are many possibilities here to consider:
2057 : - If this state is a consistent state with a default action, then
2058 : the only way this function was invoked is if the default action
2059 : is an error action. In that case, don't check for expected
2060 : tokens because there are none.
2061 : - The only way there can be no lookahead present (in yychar) is if
2062 : this state is a consistent state with a default action. Thus,
2063 : detecting the absence of a lookahead is sufficient to determine
2064 : that there is no unexpected or expected token to report. In that
2065 : case, just report a simple "syntax error".
2066 : - Don't assume there isn't a lookahead just because this state is a
2067 : consistent state with a default action. There might have been a
2068 : previous inconsistent state, consistent state with a non-default
2069 : action, or user semantic action that manipulated yychar.
2070 : - Of course, the expected token list depends on states to have
2071 : correct lookahead information, and it depends on the parser not
2072 : to perform extra reductions after fetching a lookahead from the
2073 : scanner and before detecting a syntax error. Thus, state merging
2074 : (from LALR or IELR) and default reductions corrupt the expected
2075 : token list. However, the list is correct for canonical LR with
2076 : one exception: it will still contain any token that will not be
2077 : accepted due to an error action in a later state.
2078 : */
2079 : if (yytoken != YYEMPTY)
2080 : {
2081 : int yyn = yypact[*yyssp];
2082 : yyarg[yycount++] = yytname[yytoken];
2083 : if (!yypact_value_is_default (yyn))
2084 : {
2085 : /* Start YYX at -YYN if negative to avoid negative indexes in
2086 : YYCHECK. In other words, skip the first -YYN actions for
2087 : this state because they are default actions. */
2088 : int yyxbegin = yyn < 0 ? -yyn : 0;
2089 : /* Stay within bounds of both yycheck and yytname. */
2090 : int yychecklim = YYLAST - yyn + 1;
2091 : int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2092 : int yyx;
2093 :
2094 : for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2095 : if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
2096 : && !yytable_value_is_error (yytable[yyx + yyn]))
2097 : {
2098 : if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2099 : {
2100 : yycount = 1;
2101 : yysize = yysize0;
2102 : break;
2103 : }
2104 : yyarg[yycount++] = yytname[yyx];
2105 : {
2106 : YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
2107 : if (! (yysize <= yysize1
2108 : && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
2109 : return 2;
2110 : yysize = yysize1;
2111 : }
2112 : }
2113 : }
2114 : }
2115 :
2116 : switch (yycount)
2117 : {
2118 : # define YYCASE_(N, S) \
2119 : case N: \
2120 : yyformat = S; \
2121 : break
2122 : YYCASE_(0, YY_("syntax error"));
2123 : YYCASE_(1, YY_("syntax error, unexpected %s"));
2124 : YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
2125 : YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2126 : YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2127 : YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2128 : # undef YYCASE_
2129 : }
2130 :
2131 : {
2132 : YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
2133 : if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
2134 : return 2;
2135 : yysize = yysize1;
2136 : }
2137 :
2138 : if (*yymsg_alloc < yysize)
2139 : {
2140 : *yymsg_alloc = 2 * yysize;
2141 : if (! (yysize <= *yymsg_alloc
2142 : && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
2143 : *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
2144 : return 1;
2145 : }
2146 :
2147 : /* Avoid sprintf, as that infringes on the user's name space.
2148 : Don't have undefined behavior even if the translation
2149 : produced a string with the wrong number of "%s"s. */
2150 : {
2151 : char *yyp = *yymsg;
2152 : int yyi = 0;
2153 : while ((*yyp = *yyformat) != '\0')
2154 : if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
2155 : {
2156 : yyp += yytnamerr (yyp, yyarg[yyi++]);
2157 : yyformat += 2;
2158 : }
2159 : else
2160 : {
2161 : yyp++;
2162 : yyformat++;
2163 : }
2164 : }
2165 : return 0;
2166 : }
2167 : #endif /* YYERROR_VERBOSE */
2168 :
2169 : /*-----------------------------------------------.
2170 : | Release the memory associated to this symbol. |
2171 : `-----------------------------------------------*/
2172 :
2173 : static void
2174 0 : yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, TParseContext* context, void *scanner)
2175 : {
2176 : YYUSE (yyvaluep);
2177 : YYUSE (yylocationp);
2178 : YYUSE (context);
2179 : YYUSE (scanner);
2180 0 : if (!yymsg)
2181 0 : yymsg = "Deleting";
2182 : YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2183 :
2184 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2185 : YYUSE (yytype);
2186 : YY_IGNORE_MAYBE_UNINITIALIZED_END
2187 0 : }
2188 :
2189 :
2190 :
2191 :
2192 : /*----------.
2193 : | yyparse. |
2194 : `----------*/
2195 :
2196 : int
2197 0 : yyparse (TParseContext* context, void *scanner)
2198 : {
2199 : /* The lookahead symbol. */
2200 : int yychar;
2201 :
2202 :
2203 : /* The semantic value of the lookahead symbol. */
2204 : /* Default value used for initialization, for pacifying older GCCs
2205 : or non-GCC compilers. */
2206 : YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
2207 : YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
2208 :
2209 : /* Location data for the lookahead symbol. */
2210 : static YYLTYPE yyloc_default
2211 : # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
2212 : = { 1, 1, 1, 1 }
2213 : # endif
2214 : ;
2215 0 : YYLTYPE yylloc = yyloc_default;
2216 :
2217 : /* Number of syntax errors so far. */
2218 : int yynerrs;
2219 :
2220 : int yystate;
2221 : /* Number of tokens to shift before error messages enabled. */
2222 : int yyerrstatus;
2223 :
2224 : /* The stacks and their tools:
2225 : 'yyss': related to states.
2226 : 'yyvs': related to semantic values.
2227 : 'yyls': related to locations.
2228 :
2229 : Refer to the stacks through separate pointers, to allow yyoverflow
2230 : to reallocate them elsewhere. */
2231 :
2232 : /* The state stack. */
2233 : yytype_int16 yyssa[YYINITDEPTH];
2234 : yytype_int16 *yyss;
2235 : yytype_int16 *yyssp;
2236 :
2237 : /* The semantic value stack. */
2238 : YYSTYPE yyvsa[YYINITDEPTH];
2239 : YYSTYPE *yyvs;
2240 : YYSTYPE *yyvsp;
2241 :
2242 : /* The location stack. */
2243 : YYLTYPE yylsa[YYINITDEPTH];
2244 : YYLTYPE *yyls;
2245 : YYLTYPE *yylsp;
2246 :
2247 : /* The locations where the error started and ended. */
2248 : YYLTYPE yyerror_range[3];
2249 :
2250 : YYSIZE_T yystacksize;
2251 :
2252 : int yyn;
2253 : int yyresult;
2254 : /* Lookahead token as an internal (translated) token number. */
2255 0 : int yytoken = 0;
2256 : /* The variables used to return semantic value and location from the
2257 : action routines. */
2258 : YYSTYPE yyval;
2259 : YYLTYPE yyloc;
2260 :
2261 : #if YYERROR_VERBOSE
2262 : /* Buffer for error messages, and its allocated size. */
2263 : char yymsgbuf[128];
2264 : char *yymsg = yymsgbuf;
2265 : YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2266 : #endif
2267 :
2268 : #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
2269 :
2270 : /* The number of symbols on the RHS of the reduced rule.
2271 : Keep to zero when no symbol should be popped. */
2272 0 : int yylen = 0;
2273 :
2274 0 : yyssp = yyss = yyssa;
2275 0 : yyvsp = yyvs = yyvsa;
2276 0 : yylsp = yyls = yylsa;
2277 0 : yystacksize = YYINITDEPTH;
2278 :
2279 : YYDPRINTF ((stderr, "Starting parse\n"));
2280 :
2281 0 : yystate = 0;
2282 0 : yyerrstatus = 0;
2283 0 : yynerrs = 0;
2284 0 : yychar = YYEMPTY; /* Cause a token to be read. */
2285 0 : yylsp[0] = yylloc;
2286 0 : goto yysetstate;
2287 :
2288 : /*------------------------------------------------------------.
2289 : | yynewstate -- Push a new state, which is found in yystate. |
2290 : `------------------------------------------------------------*/
2291 : yynewstate:
2292 : /* In all cases, when you get here, the value and location stacks
2293 : have just been pushed. So pushing a state here evens the stacks. */
2294 0 : yyssp++;
2295 :
2296 : yysetstate:
2297 0 : *yyssp = yystate;
2298 :
2299 0 : if (yyss + yystacksize - 1 <= yyssp)
2300 : {
2301 : /* Get the current used size of the three stacks, in elements. */
2302 0 : YYSIZE_T yysize = yyssp - yyss + 1;
2303 :
2304 : #ifdef yyoverflow
2305 : {
2306 : /* Give user a chance to reallocate the stack. Use copies of
2307 : these so that the &'s don't force the real ones into
2308 : memory. */
2309 : YYSTYPE *yyvs1 = yyvs;
2310 : yytype_int16 *yyss1 = yyss;
2311 : YYLTYPE *yyls1 = yyls;
2312 :
2313 : /* Each stack pointer address is followed by the size of the
2314 : data in use in that stack, in bytes. This used to be a
2315 : conditional around just the two extra args, but that might
2316 : be undefined if yyoverflow is a macro. */
2317 : yyoverflow (YY_("memory exhausted"),
2318 : &yyss1, yysize * sizeof (*yyssp),
2319 : &yyvs1, yysize * sizeof (*yyvsp),
2320 : &yyls1, yysize * sizeof (*yylsp),
2321 : &yystacksize);
2322 :
2323 : yyls = yyls1;
2324 : yyss = yyss1;
2325 : yyvs = yyvs1;
2326 : }
2327 : #else /* no yyoverflow */
2328 : # ifndef YYSTACK_RELOCATE
2329 0 : goto yyexhaustedlab;
2330 : # else
2331 : /* Extend the stack our own way. */
2332 : if (YYMAXDEPTH <= yystacksize)
2333 : goto yyexhaustedlab;
2334 : yystacksize *= 2;
2335 : if (YYMAXDEPTH < yystacksize)
2336 : yystacksize = YYMAXDEPTH;
2337 :
2338 : {
2339 : yytype_int16 *yyss1 = yyss;
2340 : union yyalloc *yyptr =
2341 : (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2342 : if (! yyptr)
2343 : goto yyexhaustedlab;
2344 : YYSTACK_RELOCATE (yyss_alloc, yyss);
2345 : YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2346 : YYSTACK_RELOCATE (yyls_alloc, yyls);
2347 : # undef YYSTACK_RELOCATE
2348 : if (yyss1 != yyssa)
2349 : YYSTACK_FREE (yyss1);
2350 : }
2351 : # endif
2352 : #endif /* no yyoverflow */
2353 :
2354 : yyssp = yyss + yysize - 1;
2355 : yyvsp = yyvs + yysize - 1;
2356 : yylsp = yyls + yysize - 1;
2357 :
2358 : YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2359 : (unsigned long int) yystacksize));
2360 :
2361 : if (yyss + yystacksize - 1 <= yyssp)
2362 : YYABORT;
2363 : }
2364 :
2365 : YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2366 :
2367 0 : if (yystate == YYFINAL)
2368 0 : YYACCEPT;
2369 :
2370 0 : goto yybackup;
2371 :
2372 : /*-----------.
2373 : | yybackup. |
2374 : `-----------*/
2375 : yybackup:
2376 :
2377 : /* Do appropriate processing given the current state. Read a
2378 : lookahead token if we need one and don't already have one. */
2379 :
2380 : /* First try to decide what to do without reference to lookahead token. */
2381 0 : yyn = yypact[yystate];
2382 0 : if (yypact_value_is_default (yyn))
2383 0 : goto yydefault;
2384 :
2385 : /* Not known => get a lookahead token if don't already have one. */
2386 :
2387 : /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2388 0 : if (yychar == YYEMPTY)
2389 : {
2390 : YYDPRINTF ((stderr, "Reading a token: "));
2391 0 : yychar = yylex (&yylval, &yylloc, scanner);
2392 : }
2393 :
2394 0 : if (yychar <= YYEOF)
2395 : {
2396 0 : yychar = yytoken = YYEOF;
2397 : YYDPRINTF ((stderr, "Now at end of input.\n"));
2398 : }
2399 : else
2400 : {
2401 0 : yytoken = YYTRANSLATE (yychar);
2402 : YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2403 : }
2404 :
2405 : /* If the proper action on seeing token YYTOKEN is to reduce or to
2406 : detect an error, take that action. */
2407 0 : yyn += yytoken;
2408 0 : if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2409 : goto yydefault;
2410 0 : yyn = yytable[yyn];
2411 0 : if (yyn <= 0)
2412 : {
2413 : if (yytable_value_is_error (yyn))
2414 : goto yyerrlab;
2415 0 : yyn = -yyn;
2416 0 : goto yyreduce;
2417 : }
2418 :
2419 : /* Count tokens shifted since error; after three, turn off error
2420 : status. */
2421 0 : if (yyerrstatus)
2422 0 : yyerrstatus--;
2423 :
2424 : /* Shift the lookahead token. */
2425 : YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2426 :
2427 : /* Discard the shifted token. */
2428 0 : yychar = YYEMPTY;
2429 :
2430 0 : yystate = yyn;
2431 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2432 0 : *++yyvsp = yylval;
2433 : YY_IGNORE_MAYBE_UNINITIALIZED_END
2434 0 : *++yylsp = yylloc;
2435 0 : goto yynewstate;
2436 :
2437 :
2438 : /*-----------------------------------------------------------.
2439 : | yydefault -- do the default action for the current state. |
2440 : `-----------------------------------------------------------*/
2441 : yydefault:
2442 0 : yyn = yydefact[yystate];
2443 0 : if (yyn == 0)
2444 0 : goto yyerrlab;
2445 0 : goto yyreduce;
2446 :
2447 :
2448 : /*-----------------------------.
2449 : | yyreduce -- Do a reduction. |
2450 : `-----------------------------*/
2451 : yyreduce:
2452 : /* yyn is the number of a rule to reduce with. */
2453 0 : yylen = yyr2[yyn];
2454 :
2455 : /* If YYLEN is nonzero, implement the default value of the action:
2456 : '$$ = $1'.
2457 :
2458 : Otherwise, the following line sets YYVAL to garbage.
2459 : This behavior is undocumented and Bison
2460 : users should not rely upon it. Assigning to YYVAL
2461 : unconditionally makes the parser a bit smaller, and it avoids a
2462 : GCC warning that YYVAL may be used uninitialized. */
2463 0 : yyval = yyvsp[1-yylen];
2464 :
2465 : /* Default location. */
2466 0 : YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
2467 : YY_REDUCE_PRINT (yyn);
2468 0 : switch (yyn)
2469 : {
2470 : case 4:
2471 :
2472 : {
2473 : // The symbol table search was done in the lexical phase
2474 0 : (yyval.interm.intermTypedNode) = context->parseVariableIdentifier((yylsp[0]), (yyvsp[0].lex).string, (yyvsp[0].lex).symbol);
2475 :
2476 : // don't delete $1.string, it's used by error recovery, and the pool
2477 : // pop will reclaim the memory
2478 : }
2479 :
2480 0 : break;
2481 :
2482 : case 5:
2483 :
2484 : {
2485 0 : (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
2486 : }
2487 :
2488 0 : break;
2489 :
2490 : case 6:
2491 :
2492 : {
2493 0 : TConstantUnion *unionArray = new TConstantUnion[1];
2494 0 : unionArray->setIConst((yyvsp[0].lex).i);
2495 0 : (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), (yylsp[0]));
2496 : }
2497 :
2498 0 : break;
2499 :
2500 : case 7:
2501 :
2502 : {
2503 0 : TConstantUnion *unionArray = new TConstantUnion[1];
2504 0 : unionArray->setUConst((yyvsp[0].lex).u);
2505 0 : (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtUInt, EbpUndefined, EvqConst), (yylsp[0]));
2506 : }
2507 :
2508 0 : break;
2509 :
2510 : case 8:
2511 :
2512 : {
2513 0 : TConstantUnion *unionArray = new TConstantUnion[1];
2514 0 : unionArray->setFConst((yyvsp[0].lex).f);
2515 0 : (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtFloat, EbpUndefined, EvqConst), (yylsp[0]));
2516 : }
2517 :
2518 0 : break;
2519 :
2520 : case 9:
2521 :
2522 : {
2523 0 : TConstantUnion *unionArray = new TConstantUnion[1];
2524 0 : unionArray->setBConst((yyvsp[0].lex).b);
2525 0 : (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yylsp[0]));
2526 : }
2527 :
2528 0 : break;
2529 :
2530 : case 10:
2531 :
2532 : {
2533 0 : (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
2534 : }
2535 :
2536 0 : break;
2537 :
2538 : case 11:
2539 :
2540 : {
2541 0 : (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
2542 : }
2543 :
2544 0 : break;
2545 :
2546 : case 12:
2547 :
2548 : {
2549 0 : (yyval.interm.intermTypedNode) = context->addIndexExpression((yyvsp[-3].interm.intermTypedNode), (yylsp[-2]), (yyvsp[-1].interm.intermTypedNode));
2550 : }
2551 :
2552 0 : break;
2553 :
2554 : case 13:
2555 :
2556 : {
2557 0 : (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
2558 : }
2559 :
2560 0 : break;
2561 :
2562 : case 14:
2563 :
2564 : {
2565 0 : (yyval.interm.intermTypedNode) = context->addFieldSelectionExpression((yyvsp[-2].interm.intermTypedNode), (yylsp[-1]), *(yyvsp[0].lex).string, (yylsp[0]));
2566 : }
2567 :
2568 0 : break;
2569 :
2570 : case 15:
2571 :
2572 : {
2573 0 : (yyval.interm.intermTypedNode) = context->addUnaryMathLValue(EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode), (yylsp[0]));
2574 : }
2575 :
2576 0 : break;
2577 :
2578 : case 16:
2579 :
2580 : {
2581 0 : (yyval.interm.intermTypedNode) = context->addUnaryMathLValue(EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode), (yylsp[0]));
2582 : }
2583 :
2584 0 : break;
2585 :
2586 : case 17:
2587 :
2588 : {
2589 0 : context->checkIsScalarInteger((yyvsp[0].interm.intermTypedNode), "[]");
2590 0 : (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
2591 : }
2592 :
2593 0 : break;
2594 :
2595 : case 18:
2596 :
2597 : {
2598 0 : bool fatalError = false;
2599 0 : (yyval.interm.intermTypedNode) = context->addFunctionCallOrMethod((yyvsp[0].interm).function, (yyvsp[0].interm).nodePair.node1, (yyvsp[0].interm).nodePair.node2, (yylsp[0]), &fatalError);
2600 0 : if (fatalError)
2601 : {
2602 0 : YYERROR;
2603 : }
2604 : }
2605 :
2606 0 : break;
2607 :
2608 : case 19:
2609 :
2610 : {
2611 0 : (yyval.interm) = (yyvsp[0].interm);
2612 0 : (yyval.interm).nodePair.node2 = nullptr;
2613 : }
2614 :
2615 0 : break;
2616 :
2617 : case 20:
2618 :
2619 : {
2620 0 : ES3_OR_NEWER("", (yylsp[0]), "methods");
2621 0 : (yyval.interm) = (yyvsp[0].interm);
2622 0 : (yyval.interm).nodePair.node2 = (yyvsp[-2].interm.intermTypedNode);
2623 : }
2624 :
2625 0 : break;
2626 :
2627 : case 21:
2628 :
2629 : {
2630 0 : (yyval.interm) = (yyvsp[-1].interm);
2631 : }
2632 :
2633 0 : break;
2634 :
2635 : case 22:
2636 :
2637 : {
2638 0 : (yyval.interm) = (yyvsp[-1].interm);
2639 : }
2640 :
2641 0 : break;
2642 :
2643 : case 23:
2644 :
2645 : {
2646 0 : (yyval.interm).function = (yyvsp[-1].interm.function);
2647 0 : (yyval.interm).nodePair.node1 = nullptr;
2648 : }
2649 :
2650 0 : break;
2651 :
2652 : case 24:
2653 :
2654 : {
2655 0 : (yyval.interm).function = (yyvsp[0].interm.function);
2656 0 : (yyval.interm).nodePair.node1 = nullptr;
2657 : }
2658 :
2659 0 : break;
2660 :
2661 : case 25:
2662 :
2663 : {
2664 0 : const TType *type = new TType((yyvsp[0].interm.intermTypedNode)->getType());
2665 0 : (yyvsp[-1].interm.function)->addParameter(TConstParameter(type));
2666 0 : (yyval.interm).function = (yyvsp[-1].interm.function);
2667 0 : (yyval.interm).nodePair.node1 = TIntermediate::MakeAggregate((yyvsp[0].interm.intermTypedNode), (yylsp[0]));
2668 : }
2669 :
2670 0 : break;
2671 :
2672 : case 26:
2673 :
2674 : {
2675 0 : const TType *type = new TType((yyvsp[0].interm.intermTypedNode)->getType());
2676 0 : (yyvsp[-2].interm).function->addParameter(TConstParameter(type));
2677 0 : (yyval.interm).function = (yyvsp[-2].interm).function;
2678 0 : (yyval.interm).nodePair.node1 = context->intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2679 : }
2680 :
2681 0 : break;
2682 :
2683 : case 27:
2684 :
2685 : {
2686 0 : (yyval.interm.function) = (yyvsp[-1].interm.function);
2687 : }
2688 :
2689 0 : break;
2690 :
2691 : case 28:
2692 :
2693 : {
2694 0 : if ((yyvsp[0].interm.type).array) {
2695 0 : ES3_OR_NEWER("[]", (yylsp[0]), "array constructor");
2696 : }
2697 0 : (yyval.interm.function) = context->addConstructorFunc((yyvsp[0].interm.type));
2698 : }
2699 :
2700 0 : break;
2701 :
2702 : case 29:
2703 :
2704 : {
2705 0 : context->checkIsNotReserved((yylsp[0]), *(yyvsp[0].lex).string);
2706 0 : const TType *type = TCache::getType(EbtVoid, EbpUndefined);
2707 0 : TFunction *function = new TFunction((yyvsp[0].lex).string, type);
2708 0 : (yyval.interm.function) = function;
2709 : }
2710 :
2711 0 : break;
2712 :
2713 : case 30:
2714 :
2715 : {
2716 0 : context->checkIsNotReserved((yylsp[0]), *(yyvsp[0].lex).string);
2717 0 : const TType *type = TCache::getType(EbtVoid, EbpUndefined);
2718 0 : TFunction *function = new TFunction((yyvsp[0].lex).string, type);
2719 0 : (yyval.interm.function) = function;
2720 : }
2721 :
2722 0 : break;
2723 :
2724 : case 31:
2725 :
2726 : {
2727 0 : (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
2728 : }
2729 :
2730 0 : break;
2731 :
2732 : case 32:
2733 :
2734 : {
2735 0 : (yyval.interm.intermTypedNode) = context->addUnaryMathLValue(EOpPreIncrement, (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2736 : }
2737 :
2738 0 : break;
2739 :
2740 : case 33:
2741 :
2742 : {
2743 0 : (yyval.interm.intermTypedNode) = context->addUnaryMathLValue(EOpPreDecrement, (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2744 : }
2745 :
2746 0 : break;
2747 :
2748 : case 34:
2749 :
2750 : {
2751 0 : if ((yyvsp[-1].interm).op != EOpNull) {
2752 0 : (yyval.interm.intermTypedNode) = context->addUnaryMath((yyvsp[-1].interm).op, (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2753 : } else
2754 0 : (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
2755 : }
2756 :
2757 0 : break;
2758 :
2759 : case 35:
2760 :
2761 0 : { (yyval.interm).op = EOpPositive; }
2762 :
2763 0 : break;
2764 :
2765 : case 36:
2766 :
2767 0 : { (yyval.interm).op = EOpNegative; }
2768 :
2769 0 : break;
2770 :
2771 : case 37:
2772 :
2773 0 : { (yyval.interm).op = EOpLogicalNot; }
2774 :
2775 0 : break;
2776 :
2777 : case 38:
2778 :
2779 : {
2780 0 : ES3_OR_NEWER("~", (yyloc), "bit-wise operator");
2781 0 : (yyval.interm).op = EOpBitwiseNot;
2782 : }
2783 :
2784 0 : break;
2785 :
2786 : case 39:
2787 :
2788 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2789 :
2790 0 : break;
2791 :
2792 : case 40:
2793 :
2794 : {
2795 0 : (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2796 : }
2797 :
2798 0 : break;
2799 :
2800 : case 41:
2801 :
2802 : {
2803 0 : (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2804 : }
2805 :
2806 0 : break;
2807 :
2808 : case 42:
2809 :
2810 : {
2811 0 : ES3_OR_NEWER("%", (yylsp[-1]), "integer modulus operator");
2812 0 : (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpIMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2813 : }
2814 :
2815 0 : break;
2816 :
2817 : case 43:
2818 :
2819 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2820 :
2821 0 : break;
2822 :
2823 : case 44:
2824 :
2825 : {
2826 0 : (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2827 : }
2828 :
2829 0 : break;
2830 :
2831 : case 45:
2832 :
2833 : {
2834 0 : (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2835 : }
2836 :
2837 0 : break;
2838 :
2839 : case 46:
2840 :
2841 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2842 :
2843 0 : break;
2844 :
2845 : case 47:
2846 :
2847 : {
2848 0 : ES3_OR_NEWER("<<", (yylsp[-1]), "bit-wise operator");
2849 0 : (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpBitShiftLeft, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2850 : }
2851 :
2852 0 : break;
2853 :
2854 : case 48:
2855 :
2856 : {
2857 0 : ES3_OR_NEWER(">>", (yylsp[-1]), "bit-wise operator");
2858 0 : (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpBitShiftRight, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2859 : }
2860 :
2861 0 : break;
2862 :
2863 : case 49:
2864 :
2865 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2866 :
2867 0 : break;
2868 :
2869 : case 50:
2870 :
2871 : {
2872 0 : (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2873 : }
2874 :
2875 0 : break;
2876 :
2877 : case 51:
2878 :
2879 : {
2880 0 : (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2881 : }
2882 :
2883 0 : break;
2884 :
2885 : case 52:
2886 :
2887 : {
2888 0 : (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2889 : }
2890 :
2891 0 : break;
2892 :
2893 : case 53:
2894 :
2895 : {
2896 0 : (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2897 : }
2898 :
2899 0 : break;
2900 :
2901 : case 54:
2902 :
2903 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2904 :
2905 0 : break;
2906 :
2907 : case 55:
2908 :
2909 : {
2910 0 : (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2911 : }
2912 :
2913 0 : break;
2914 :
2915 : case 56:
2916 :
2917 : {
2918 0 : (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpNotEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2919 : }
2920 :
2921 0 : break;
2922 :
2923 : case 57:
2924 :
2925 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2926 :
2927 0 : break;
2928 :
2929 : case 58:
2930 :
2931 : {
2932 0 : ES3_OR_NEWER("&", (yylsp[-1]), "bit-wise operator");
2933 0 : (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpBitwiseAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2934 : }
2935 :
2936 0 : break;
2937 :
2938 : case 59:
2939 :
2940 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2941 :
2942 0 : break;
2943 :
2944 : case 60:
2945 :
2946 : {
2947 0 : ES3_OR_NEWER("^", (yylsp[-1]), "bit-wise operator");
2948 0 : (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpBitwiseXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2949 : }
2950 :
2951 0 : break;
2952 :
2953 : case 61:
2954 :
2955 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2956 :
2957 0 : break;
2958 :
2959 : case 62:
2960 :
2961 : {
2962 0 : ES3_OR_NEWER("|", (yylsp[-1]), "bit-wise operator");
2963 0 : (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpBitwiseOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2964 : }
2965 :
2966 0 : break;
2967 :
2968 : case 63:
2969 :
2970 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2971 :
2972 0 : break;
2973 :
2974 : case 64:
2975 :
2976 : {
2977 0 : (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2978 : }
2979 :
2980 0 : break;
2981 :
2982 : case 65:
2983 :
2984 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2985 :
2986 0 : break;
2987 :
2988 : case 66:
2989 :
2990 : {
2991 0 : (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2992 : }
2993 :
2994 0 : break;
2995 :
2996 : case 67:
2997 :
2998 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2999 :
3000 0 : break;
3001 :
3002 : case 68:
3003 :
3004 : {
3005 0 : (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
3006 : }
3007 :
3008 0 : break;
3009 :
3010 : case 69:
3011 :
3012 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
3013 :
3014 0 : break;
3015 :
3016 : case 70:
3017 :
3018 : {
3019 0 : (yyval.interm.intermTypedNode) = context->addTernarySelection((yyvsp[-4].interm.intermTypedNode), (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-3]));
3020 : }
3021 :
3022 0 : break;
3023 :
3024 : case 71:
3025 :
3026 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
3027 :
3028 0 : break;
3029 :
3030 : case 72:
3031 :
3032 : {
3033 0 : context->checkCanBeLValue((yylsp[-1]), "assign", (yyvsp[-2].interm.intermTypedNode));
3034 0 : (yyval.interm.intermTypedNode) = context->addAssign((yyvsp[-1].interm).op, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
3035 : }
3036 :
3037 0 : break;
3038 :
3039 : case 73:
3040 :
3041 0 : { (yyval.interm).op = EOpAssign; }
3042 :
3043 0 : break;
3044 :
3045 : case 74:
3046 :
3047 0 : { (yyval.interm).op = EOpMulAssign; }
3048 :
3049 0 : break;
3050 :
3051 : case 75:
3052 :
3053 0 : { (yyval.interm).op = EOpDivAssign; }
3054 :
3055 0 : break;
3056 :
3057 : case 76:
3058 :
3059 : {
3060 0 : ES3_OR_NEWER("%=", (yyloc), "integer modulus operator");
3061 0 : (yyval.interm).op = EOpIModAssign;
3062 : }
3063 :
3064 0 : break;
3065 :
3066 : case 77:
3067 :
3068 0 : { (yyval.interm).op = EOpAddAssign; }
3069 :
3070 0 : break;
3071 :
3072 : case 78:
3073 :
3074 0 : { (yyval.interm).op = EOpSubAssign; }
3075 :
3076 0 : break;
3077 :
3078 : case 79:
3079 :
3080 : {
3081 0 : ES3_OR_NEWER("<<=", (yyloc), "bit-wise operator");
3082 0 : (yyval.interm).op = EOpBitShiftLeftAssign;
3083 : }
3084 :
3085 0 : break;
3086 :
3087 : case 80:
3088 :
3089 : {
3090 0 : ES3_OR_NEWER(">>=", (yyloc), "bit-wise operator");
3091 0 : (yyval.interm).op = EOpBitShiftRightAssign;
3092 : }
3093 :
3094 0 : break;
3095 :
3096 : case 81:
3097 :
3098 : {
3099 0 : ES3_OR_NEWER("&=", (yyloc), "bit-wise operator");
3100 0 : (yyval.interm).op = EOpBitwiseAndAssign;
3101 : }
3102 :
3103 0 : break;
3104 :
3105 : case 82:
3106 :
3107 : {
3108 0 : ES3_OR_NEWER("^=", (yyloc), "bit-wise operator");
3109 0 : (yyval.interm).op = EOpBitwiseXorAssign;
3110 : }
3111 :
3112 0 : break;
3113 :
3114 : case 83:
3115 :
3116 : {
3117 0 : ES3_OR_NEWER("|=", (yyloc), "bit-wise operator");
3118 0 : (yyval.interm).op = EOpBitwiseOrAssign;
3119 : }
3120 :
3121 0 : break;
3122 :
3123 : case 84:
3124 :
3125 : {
3126 0 : (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
3127 : }
3128 :
3129 0 : break;
3130 :
3131 : case 85:
3132 :
3133 : {
3134 0 : (yyval.interm.intermTypedNode) = context->addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
3135 : }
3136 :
3137 0 : break;
3138 :
3139 : case 86:
3140 :
3141 : {
3142 0 : context->checkIsConst((yyvsp[0].interm.intermTypedNode));
3143 0 : (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
3144 : }
3145 :
3146 0 : break;
3147 :
3148 : case 87:
3149 :
3150 : {
3151 0 : context->enterStructDeclaration((yylsp[-1]), *(yyvsp[-1].lex).string);
3152 0 : (yyval.lex) = (yyvsp[-1].lex);
3153 : }
3154 :
3155 0 : break;
3156 :
3157 : case 88:
3158 :
3159 : {
3160 0 : (yyval.interm.intermNode) = context->addFunctionPrototypeDeclaration(*((yyvsp[-1].interm).function), (yylsp[-1]));
3161 : }
3162 :
3163 0 : break;
3164 :
3165 : case 89:
3166 :
3167 : {
3168 0 : (yyval.interm.intermNode) = (yyvsp[-1].interm).intermDeclaration;
3169 : }
3170 :
3171 0 : break;
3172 :
3173 : case 90:
3174 :
3175 : {
3176 0 : if (((yyvsp[-2].interm.precision) == EbpHigh) && (context->getShaderType() == GL_FRAGMENT_SHADER) && !context->getFragmentPrecisionHigh()) {
3177 0 : context->error((yylsp[-3]), "precision is not supported in fragment shader", "highp");
3178 : }
3179 0 : if (!context->symbolTable.setDefaultPrecision( (yyvsp[-1].interm.type), (yyvsp[-2].interm.precision) )) {
3180 0 : context->error((yylsp[-3]), "illegal type argument for default precision qualifier", getBasicString((yyvsp[-1].interm.type).getBasicType()));
3181 : }
3182 0 : (yyval.interm.intermNode) = 0;
3183 : }
3184 :
3185 0 : break;
3186 :
3187 : case 91:
3188 :
3189 : {
3190 0 : ES3_OR_NEWER((yyvsp[-3].lex).string->c_str(), (yylsp[-4]), "interface blocks");
3191 0 : (yyval.interm.intermNode) = context->addInterfaceBlock(*(yyvsp[-4].interm.typeQualifierBuilder), (yylsp[-3]), *(yyvsp[-3].lex).string, (yyvsp[-2].interm.fieldList), NULL, (yyloc), NULL, (yyloc));
3192 : }
3193 :
3194 0 : break;
3195 :
3196 : case 92:
3197 :
3198 : {
3199 0 : ES3_OR_NEWER((yyvsp[-4].lex).string->c_str(), (yylsp[-5]), "interface blocks");
3200 0 : (yyval.interm.intermNode) = context->addInterfaceBlock(*(yyvsp[-5].interm.typeQualifierBuilder), (yylsp[-4]), *(yyvsp[-4].lex).string, (yyvsp[-3].interm.fieldList), (yyvsp[-1].lex).string, (yylsp[-1]), NULL, (yyloc));
3201 : }
3202 :
3203 0 : break;
3204 :
3205 : case 93:
3206 :
3207 : {
3208 0 : ES3_OR_NEWER((yyvsp[-7].lex).string->c_str(), (yylsp[-8]), "interface blocks");
3209 0 : (yyval.interm.intermNode) = context->addInterfaceBlock(*(yyvsp[-8].interm.typeQualifierBuilder), (yylsp[-7]), *(yyvsp[-7].lex).string, (yyvsp[-6].interm.fieldList), (yyvsp[-4].lex).string, (yylsp[-4]), (yyvsp[-2].interm.intermTypedNode), (yylsp[-3]));
3210 : }
3211 :
3212 0 : break;
3213 :
3214 : case 94:
3215 :
3216 : {
3217 0 : context->parseGlobalLayoutQualifier(*(yyvsp[-1].interm.typeQualifierBuilder));
3218 0 : (yyval.interm.intermNode) = 0;
3219 : }
3220 :
3221 0 : break;
3222 :
3223 : case 95:
3224 :
3225 : {
3226 0 : (yyval.interm.intermNode) = context->parseInvariantDeclaration(*(yyvsp[-2].interm.typeQualifierBuilder), (yylsp[-1]), (yyvsp[-1].lex).string, (yyvsp[-1].lex).symbol);
3227 : }
3228 :
3229 0 : break;
3230 :
3231 : case 96:
3232 :
3233 : {
3234 0 : (yyval.interm).function = context->parseFunctionDeclarator((yylsp[0]), (yyvsp[-1].interm.function));
3235 0 : context->exitFunctionDeclaration();
3236 : }
3237 :
3238 0 : break;
3239 :
3240 : case 97:
3241 :
3242 : {
3243 0 : (yyval.interm.function) = (yyvsp[0].interm.function);
3244 : }
3245 :
3246 0 : break;
3247 :
3248 : case 98:
3249 :
3250 : {
3251 0 : (yyval.interm.function) = (yyvsp[0].interm.function);
3252 : }
3253 :
3254 0 : break;
3255 :
3256 : case 99:
3257 :
3258 : {
3259 : // Add the parameter
3260 0 : (yyval.interm.function) = (yyvsp[-1].interm.function);
3261 0 : if ((yyvsp[0].interm).param.type->getBasicType() != EbtVoid)
3262 0 : (yyvsp[-1].interm.function)->addParameter((yyvsp[0].interm).param.turnToConst());
3263 : else
3264 0 : delete (yyvsp[0].interm).param.type;
3265 : }
3266 :
3267 0 : break;
3268 :
3269 : case 100:
3270 :
3271 : {
3272 : //
3273 : // Only first parameter of one-parameter functions can be void
3274 : // The check for named parameters not being void is done in parameter_declarator
3275 : //
3276 0 : if ((yyvsp[0].interm).param.type->getBasicType() == EbtVoid) {
3277 : //
3278 : // This parameter > first is void
3279 : //
3280 0 : context->error((yylsp[-1]), "cannot be an argument type except for '(void)'", "void");
3281 0 : delete (yyvsp[0].interm).param.type;
3282 : } else {
3283 : // Add the parameter
3284 0 : (yyval.interm.function) = (yyvsp[-2].interm.function);
3285 0 : (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param.turnToConst());
3286 : }
3287 : }
3288 :
3289 0 : break;
3290 :
3291 : case 101:
3292 :
3293 : {
3294 0 : (yyval.interm.function) = context->parseFunctionHeader((yyvsp[-2].interm.type), (yyvsp[-1].lex).string, (yylsp[-1]));
3295 :
3296 0 : context->symbolTable.push();
3297 0 : context->enterFunctionDeclaration();
3298 : }
3299 :
3300 0 : break;
3301 :
3302 : case 102:
3303 :
3304 : {
3305 0 : if ((yyvsp[-1].interm.type).getBasicType() == EbtVoid) {
3306 0 : context->error((yylsp[0]), "illegal use of type 'void'", (yyvsp[0].lex).string->c_str());
3307 : }
3308 0 : context->checkIsNotReserved((yylsp[0]), *(yyvsp[0].lex).string);
3309 0 : TParameter param = {(yyvsp[0].lex).string, new TType((yyvsp[-1].interm.type))};
3310 0 : (yyval.interm).param = param;
3311 : }
3312 :
3313 0 : break;
3314 :
3315 : case 103:
3316 :
3317 : {
3318 : // Check that we can make an array out of this type
3319 0 : context->checkIsValidTypeForArray((yylsp[-2]), (yyvsp[-4].interm.type));
3320 :
3321 0 : context->checkIsNotReserved((yylsp[-3]), *(yyvsp[-3].lex).string);
3322 :
3323 0 : unsigned int size = context->checkIsValidArraySize((yylsp[-2]), (yyvsp[-1].interm.intermTypedNode));
3324 :
3325 0 : (yyvsp[-4].interm.type).setArraySize(size);
3326 :
3327 0 : TType* type = new TType((yyvsp[-4].interm.type));
3328 0 : TParameter param = { (yyvsp[-3].lex).string, type };
3329 0 : (yyval.interm).param = param;
3330 : }
3331 :
3332 0 : break;
3333 :
3334 : case 104:
3335 :
3336 : {
3337 0 : (yyval.interm) = (yyvsp[0].interm);
3338 0 : context->checkIsParameterQualifierValid((yylsp[0]), *(yyvsp[-1].interm.typeQualifierBuilder), (yyvsp[0].interm).param.type);
3339 : }
3340 :
3341 0 : break;
3342 :
3343 : case 105:
3344 :
3345 : {
3346 0 : (yyval.interm) = (yyvsp[0].interm);
3347 0 : (yyval.interm).param.type->setQualifier(EvqIn);
3348 : }
3349 :
3350 0 : break;
3351 :
3352 : case 106:
3353 :
3354 : {
3355 0 : (yyval.interm) = (yyvsp[0].interm);
3356 0 : context->checkIsParameterQualifierValid((yylsp[0]), *(yyvsp[-1].interm.typeQualifierBuilder), (yyvsp[0].interm).param.type);
3357 : }
3358 :
3359 0 : break;
3360 :
3361 : case 107:
3362 :
3363 : {
3364 0 : (yyval.interm) = (yyvsp[0].interm);
3365 0 : (yyval.interm).param.type->setQualifier(EvqIn);
3366 : }
3367 :
3368 0 : break;
3369 :
3370 : case 108:
3371 :
3372 : {
3373 0 : TParameter param = { 0, new TType((yyvsp[0].interm.type)) };
3374 0 : (yyval.interm).param = param;
3375 : }
3376 :
3377 0 : break;
3378 :
3379 : case 109:
3380 :
3381 : {
3382 0 : (yyval.interm) = (yyvsp[0].interm);
3383 : }
3384 :
3385 0 : break;
3386 :
3387 : case 110:
3388 :
3389 : {
3390 0 : (yyval.interm) = (yyvsp[-2].interm);
3391 0 : context->parseDeclarator((yyval.interm).type, (yylsp[0]), *(yyvsp[0].lex).string, (yyval.interm).intermDeclaration);
3392 : }
3393 :
3394 0 : break;
3395 :
3396 : case 111:
3397 :
3398 : {
3399 0 : (yyval.interm) = (yyvsp[-5].interm);
3400 0 : context->parseArrayDeclarator((yyval.interm).type, (yylsp[-3]), *(yyvsp[-3].lex).string, (yylsp[-2]), (yyvsp[-1].interm.intermTypedNode), (yyval.interm).intermDeclaration);
3401 : }
3402 :
3403 0 : break;
3404 :
3405 : case 112:
3406 :
3407 : {
3408 0 : ES3_OR_NEWER("[]", (yylsp[-4]), "implicitly sized array");
3409 0 : (yyval.interm) = (yyvsp[-6].interm);
3410 0 : context->parseArrayInitDeclarator((yyval.interm).type, (yylsp[-4]), *(yyvsp[-4].lex).string, (yylsp[-3]), nullptr, (yylsp[-1]), (yyvsp[0].interm.intermTypedNode), (yyval.interm).intermDeclaration);
3411 : }
3412 :
3413 0 : break;
3414 :
3415 : case 113:
3416 :
3417 : {
3418 0 : ES3_OR_NEWER("=", (yylsp[-1]), "first-class arrays (array initializer)");
3419 0 : (yyval.interm) = (yyvsp[-7].interm);
3420 0 : context->parseArrayInitDeclarator((yyval.interm).type, (yylsp[-5]), *(yyvsp[-5].lex).string, (yylsp[-4]), (yyvsp[-3].interm.intermTypedNode), (yylsp[-1]), (yyvsp[0].interm.intermTypedNode), (yyval.interm).intermDeclaration);
3421 : }
3422 :
3423 0 : break;
3424 :
3425 : case 114:
3426 :
3427 : {
3428 0 : (yyval.interm) = (yyvsp[-4].interm);
3429 0 : context->parseInitDeclarator((yyval.interm).type, (yylsp[-2]), *(yyvsp[-2].lex).string, (yylsp[-1]), (yyvsp[0].interm.intermTypedNode), (yyval.interm).intermDeclaration);
3430 : }
3431 :
3432 0 : break;
3433 :
3434 : case 115:
3435 :
3436 : {
3437 0 : (yyval.interm).type = (yyvsp[0].interm.type);
3438 0 : (yyval.interm).intermDeclaration = context->parseSingleDeclaration((yyval.interm).type, (yylsp[0]), "");
3439 : }
3440 :
3441 0 : break;
3442 :
3443 : case 116:
3444 :
3445 : {
3446 0 : (yyval.interm).type = (yyvsp[-1].interm.type);
3447 0 : (yyval.interm).intermDeclaration = context->parseSingleDeclaration((yyval.interm).type, (yylsp[0]), *(yyvsp[0].lex).string);
3448 : }
3449 :
3450 0 : break;
3451 :
3452 : case 117:
3453 :
3454 : {
3455 0 : (yyval.interm).type = (yyvsp[-4].interm.type);
3456 0 : (yyval.interm).intermDeclaration = context->parseSingleArrayDeclaration((yyval.interm).type, (yylsp[-3]), *(yyvsp[-3].lex).string, (yylsp[-2]), (yyvsp[-1].interm.intermTypedNode));
3457 : }
3458 :
3459 0 : break;
3460 :
3461 : case 118:
3462 :
3463 : {
3464 0 : ES3_OR_NEWER("[]", (yylsp[-3]), "implicitly sized array");
3465 0 : (yyval.interm).type = (yyvsp[-5].interm.type);
3466 0 : (yyval.interm).intermDeclaration = context->parseSingleArrayInitDeclaration((yyval.interm).type, (yylsp[-4]), *(yyvsp[-4].lex).string, (yylsp[-3]), nullptr, (yylsp[-1]), (yyvsp[0].interm.intermTypedNode));
3467 : }
3468 :
3469 0 : break;
3470 :
3471 : case 119:
3472 :
3473 : {
3474 0 : ES3_OR_NEWER("=", (yylsp[-1]), "first-class arrays (array initializer)");
3475 0 : (yyval.interm).type = (yyvsp[-6].interm.type);
3476 0 : (yyval.interm).intermDeclaration = context->parseSingleArrayInitDeclaration((yyval.interm).type, (yylsp[-5]), *(yyvsp[-5].lex).string, (yylsp[-4]), (yyvsp[-3].interm.intermTypedNode), (yylsp[-1]), (yyvsp[0].interm.intermTypedNode));
3477 : }
3478 :
3479 0 : break;
3480 :
3481 : case 120:
3482 :
3483 : {
3484 0 : (yyval.interm).type = (yyvsp[-3].interm.type);
3485 0 : (yyval.interm).intermDeclaration = context->parseSingleInitDeclaration((yyval.interm).type, (yylsp[-2]), *(yyvsp[-2].lex).string, (yylsp[-1]), (yyvsp[0].interm.intermTypedNode));
3486 : }
3487 :
3488 0 : break;
3489 :
3490 : case 121:
3491 :
3492 : {
3493 0 : context->addFullySpecifiedType(&(yyvsp[0].interm.type));
3494 0 : (yyval.interm.type) = (yyvsp[0].interm.type);
3495 : }
3496 :
3497 0 : break;
3498 :
3499 : case 122:
3500 :
3501 : {
3502 0 : (yyval.interm.type) = context->addFullySpecifiedType(*(yyvsp[-1].interm.typeQualifierBuilder), (yyvsp[0].interm.type));
3503 : }
3504 :
3505 0 : break;
3506 :
3507 : case 123:
3508 :
3509 : {
3510 0 : (yyval.interm.qualifier) = EvqSmooth;
3511 : }
3512 :
3513 0 : break;
3514 :
3515 : case 124:
3516 :
3517 : {
3518 0 : (yyval.interm.qualifier) = EvqFlat;
3519 : }
3520 :
3521 0 : break;
3522 :
3523 : case 125:
3524 :
3525 : {
3526 0 : (yyval.interm.typeQualifierBuilder) = context->createTypeQualifierBuilder((yylsp[0]));
3527 0 : (yyval.interm.typeQualifierBuilder)->appendQualifier((yyvsp[0].interm.qualifierWrapper));
3528 : }
3529 :
3530 0 : break;
3531 :
3532 : case 126:
3533 :
3534 : {
3535 0 : (yyval.interm.typeQualifierBuilder) = (yyvsp[-1].interm.typeQualifierBuilder);
3536 0 : (yyval.interm.typeQualifierBuilder)->appendQualifier((yyvsp[0].interm.qualifierWrapper));
3537 : }
3538 :
3539 0 : break;
3540 :
3541 : case 127:
3542 :
3543 : {
3544 : // empty
3545 : }
3546 :
3547 0 : break;
3548 :
3549 : case 128:
3550 :
3551 : {
3552 0 : context->checkLocalVariableConstStorageQualifier(*(yyvsp[0].interm.qualifierWrapper));
3553 0 : (yyval.interm.qualifierWrapper) = (yyvsp[0].interm.qualifierWrapper);
3554 : }
3555 :
3556 0 : break;
3557 :
3558 : case 129:
3559 :
3560 : {
3561 0 : context->checkIsAtGlobalLevel((yylsp[0]), "layout");
3562 0 : (yyval.interm.qualifierWrapper) = new TLayoutQualifierWrapper((yyvsp[0].interm.layoutQualifier), (yylsp[0]));
3563 : }
3564 :
3565 0 : break;
3566 :
3567 : case 130:
3568 :
3569 : {
3570 0 : (yyval.interm.qualifierWrapper) = new TPrecisionQualifierWrapper((yyvsp[0].interm.precision), (yylsp[0]));
3571 : }
3572 :
3573 0 : break;
3574 :
3575 : case 131:
3576 :
3577 : {
3578 0 : (yyval.interm.qualifierWrapper) = new TInterpolationQualifierWrapper((yyvsp[0].interm.qualifier), (yylsp[0]));
3579 : }
3580 :
3581 0 : break;
3582 :
3583 : case 132:
3584 :
3585 : {
3586 0 : context->checkIsAtGlobalLevel((yylsp[0]), "invariant");
3587 0 : (yyval.interm.qualifierWrapper) = new TInvariantQualifierWrapper((yylsp[0]));
3588 : }
3589 :
3590 0 : break;
3591 :
3592 : case 133:
3593 :
3594 : {
3595 0 : VERTEX_ONLY("attribute", (yylsp[0]));
3596 0 : ES2_ONLY("attribute", (yylsp[0]));
3597 0 : context->checkIsAtGlobalLevel((yylsp[0]), "attribute");
3598 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqAttribute, (yylsp[0]));
3599 : }
3600 :
3601 0 : break;
3602 :
3603 : case 134:
3604 :
3605 : {
3606 0 : ES2_ONLY("varying", (yylsp[0]));
3607 0 : context->checkIsAtGlobalLevel((yylsp[0]), "varying");
3608 0 : if (context->getShaderType() == GL_VERTEX_SHADER)
3609 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqVaryingOut, (yylsp[0]));
3610 : else
3611 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqVaryingIn, (yylsp[0]));
3612 : }
3613 :
3614 0 : break;
3615 :
3616 : case 135:
3617 :
3618 : {
3619 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqConst, (yylsp[0]));
3620 : }
3621 :
3622 0 : break;
3623 :
3624 : case 136:
3625 :
3626 : {
3627 0 : if (context->declaringFunction())
3628 : {
3629 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqIn, (yylsp[0]));
3630 : }
3631 0 : else if (context->getShaderType() == GL_FRAGMENT_SHADER)
3632 : {
3633 0 : ES3_OR_NEWER("in", (yylsp[0]), "storage qualifier");
3634 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqFragmentIn, (yylsp[0]));
3635 : }
3636 0 : else if (context->getShaderType() == GL_VERTEX_SHADER)
3637 : {
3638 0 : ES3_OR_NEWER("in", (yylsp[0]), "storage qualifier");
3639 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqVertexIn, (yylsp[0]));
3640 : }
3641 : else
3642 : {
3643 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqComputeIn, (yylsp[0]));
3644 : }
3645 : }
3646 :
3647 0 : break;
3648 :
3649 : case 137:
3650 :
3651 : {
3652 0 : if (context->declaringFunction())
3653 : {
3654 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqOut, (yylsp[0]));
3655 : }
3656 : else
3657 : {
3658 0 : ES3_OR_NEWER("out", (yylsp[0]), "storage qualifier");
3659 0 : NON_COMPUTE_ONLY("out", (yylsp[0]));
3660 0 : if (context->getShaderType() == GL_FRAGMENT_SHADER)
3661 : {
3662 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqFragmentOut, (yylsp[0]));
3663 : }
3664 : else
3665 : {
3666 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqVertexOut, (yylsp[0]));
3667 : }
3668 : }
3669 : }
3670 :
3671 0 : break;
3672 :
3673 : case 138:
3674 :
3675 : {
3676 0 : if (!context->declaringFunction())
3677 : {
3678 0 : context->error((yylsp[0]), "invalid inout qualifier", "'inout' can be only used with function parameters");
3679 : }
3680 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqInOut, (yylsp[0]));
3681 : }
3682 :
3683 0 : break;
3684 :
3685 : case 139:
3686 :
3687 : {
3688 0 : ES3_OR_NEWER("centroid", (yylsp[0]), "storage qualifier");
3689 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqCentroid, (yylsp[0]));
3690 : }
3691 :
3692 0 : break;
3693 :
3694 : case 140:
3695 :
3696 : {
3697 0 : context->checkIsAtGlobalLevel((yylsp[0]), "uniform");
3698 0 : (yyval.interm.qualifierWrapper) = new TStorageQualifierWrapper(EvqUniform, (yylsp[0]));
3699 : }
3700 :
3701 0 : break;
3702 :
3703 : case 141:
3704 :
3705 : {
3706 0 : (yyval.interm.qualifierWrapper) = new TMemoryQualifierWrapper(EvqReadOnly, (yylsp[0]));
3707 : }
3708 :
3709 0 : break;
3710 :
3711 : case 142:
3712 :
3713 : {
3714 0 : (yyval.interm.qualifierWrapper) = new TMemoryQualifierWrapper(EvqWriteOnly, (yylsp[0]));
3715 : }
3716 :
3717 0 : break;
3718 :
3719 : case 143:
3720 :
3721 : {
3722 0 : (yyval.interm.qualifierWrapper) = new TMemoryQualifierWrapper(EvqCoherent, (yylsp[0]));
3723 : }
3724 :
3725 0 : break;
3726 :
3727 : case 144:
3728 :
3729 : {
3730 0 : (yyval.interm.qualifierWrapper) = new TMemoryQualifierWrapper(EvqRestrict, (yylsp[0]));
3731 : }
3732 :
3733 0 : break;
3734 :
3735 : case 145:
3736 :
3737 : {
3738 0 : (yyval.interm.qualifierWrapper) = new TMemoryQualifierWrapper(EvqVolatile, (yylsp[0]));
3739 : }
3740 :
3741 0 : break;
3742 :
3743 : case 146:
3744 :
3745 : {
3746 0 : (yyval.interm.type) = (yyvsp[0].interm.type);
3747 0 : (yyval.interm.type).precision = context->symbolTable.getDefaultPrecision((yyvsp[0].interm.type).getBasicType());
3748 : }
3749 :
3750 0 : break;
3751 :
3752 : case 147:
3753 :
3754 : {
3755 0 : (yyval.interm.precision) = EbpHigh;
3756 : }
3757 :
3758 0 : break;
3759 :
3760 : case 148:
3761 :
3762 : {
3763 0 : (yyval.interm.precision) = EbpMedium;
3764 : }
3765 :
3766 0 : break;
3767 :
3768 : case 149:
3769 :
3770 : {
3771 0 : (yyval.interm.precision) = EbpLow;
3772 : }
3773 :
3774 0 : break;
3775 :
3776 : case 150:
3777 :
3778 : {
3779 0 : ES3_OR_NEWER("layout", (yylsp[-3]), "qualifier");
3780 0 : (yyval.interm.layoutQualifier) = (yyvsp[-1].interm.layoutQualifier);
3781 : }
3782 :
3783 0 : break;
3784 :
3785 : case 151:
3786 :
3787 : {
3788 0 : (yyval.interm.layoutQualifier) = (yyvsp[0].interm.layoutQualifier);
3789 : }
3790 :
3791 0 : break;
3792 :
3793 : case 152:
3794 :
3795 : {
3796 0 : (yyval.interm.layoutQualifier) = context->joinLayoutQualifiers((yyvsp[-2].interm.layoutQualifier), (yyvsp[0].interm.layoutQualifier), (yylsp[0]));
3797 : }
3798 :
3799 0 : break;
3800 :
3801 : case 153:
3802 :
3803 : {
3804 0 : (yyval.interm.layoutQualifier) = context->parseLayoutQualifier(*(yyvsp[0].lex).string, (yylsp[0]));
3805 : }
3806 :
3807 0 : break;
3808 :
3809 : case 154:
3810 :
3811 : {
3812 0 : (yyval.interm.layoutQualifier) = context->parseLayoutQualifier(*(yyvsp[-2].lex).string, (yylsp[-2]), (yyvsp[0].lex).i, (yylsp[0]));
3813 : }
3814 :
3815 0 : break;
3816 :
3817 : case 155:
3818 :
3819 : {
3820 0 : (yyval.interm.layoutQualifier) = context->parseLayoutQualifier(*(yyvsp[-2].lex).string, (yylsp[-2]), (yyvsp[0].lex).i, (yylsp[0]));
3821 : }
3822 :
3823 0 : break;
3824 :
3825 : case 156:
3826 :
3827 : {
3828 0 : (yyval.interm.type).initialize((yyvsp[0].interm.typeSpecifierNonArray), (context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary));
3829 : }
3830 :
3831 0 : break;
3832 :
3833 : case 157:
3834 :
3835 : {
3836 0 : ES3_OR_NEWER("[]", (yylsp[-1]), "implicitly sized array");
3837 0 : (yyval.interm.type).initialize((yyvsp[-2].interm.typeSpecifierNonArray), (context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary));
3838 0 : (yyval.interm.type).setArraySize(0);
3839 : }
3840 :
3841 0 : break;
3842 :
3843 : case 158:
3844 :
3845 : {
3846 0 : (yyval.interm.type).initialize((yyvsp[-3].interm.typeSpecifierNonArray), (context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary));
3847 0 : if (context->checkIsValidTypeForArray((yylsp[-2]), (yyval.interm.type)))
3848 : {
3849 0 : unsigned int size = context->checkIsValidArraySize((yylsp[-2]), (yyvsp[-1].interm.intermTypedNode));
3850 0 : (yyval.interm.type).setArraySize(size);
3851 : }
3852 : }
3853 :
3854 0 : break;
3855 :
3856 : case 159:
3857 :
3858 : {
3859 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtVoid, (yylsp[0]));
3860 : }
3861 :
3862 0 : break;
3863 :
3864 : case 160:
3865 :
3866 : {
3867 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
3868 : }
3869 :
3870 0 : break;
3871 :
3872 : case 161:
3873 :
3874 : {
3875 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtInt, (yylsp[0]));
3876 : }
3877 :
3878 0 : break;
3879 :
3880 : case 162:
3881 :
3882 : {
3883 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtUInt, (yylsp[0]));
3884 : }
3885 :
3886 0 : break;
3887 :
3888 : case 163:
3889 :
3890 : {
3891 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtBool, (yylsp[0]));
3892 : }
3893 :
3894 0 : break;
3895 :
3896 : case 164:
3897 :
3898 : {
3899 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
3900 0 : (yyval.interm.typeSpecifierNonArray).setAggregate(2);
3901 : }
3902 :
3903 0 : break;
3904 :
3905 : case 165:
3906 :
3907 : {
3908 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
3909 0 : (yyval.interm.typeSpecifierNonArray).setAggregate(3);
3910 : }
3911 :
3912 0 : break;
3913 :
3914 : case 166:
3915 :
3916 : {
3917 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
3918 0 : (yyval.interm.typeSpecifierNonArray).setAggregate(4);
3919 : }
3920 :
3921 0 : break;
3922 :
3923 : case 167:
3924 :
3925 : {
3926 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtBool, (yylsp[0]));
3927 0 : (yyval.interm.typeSpecifierNonArray).setAggregate(2);
3928 : }
3929 :
3930 0 : break;
3931 :
3932 : case 168:
3933 :
3934 : {
3935 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtBool, (yylsp[0]));
3936 0 : (yyval.interm.typeSpecifierNonArray).setAggregate(3);
3937 : }
3938 :
3939 0 : break;
3940 :
3941 : case 169:
3942 :
3943 : {
3944 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtBool, (yylsp[0]));
3945 0 : (yyval.interm.typeSpecifierNonArray).setAggregate(4);
3946 : }
3947 :
3948 0 : break;
3949 :
3950 : case 170:
3951 :
3952 : {
3953 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtInt, (yylsp[0]));
3954 0 : (yyval.interm.typeSpecifierNonArray).setAggregate(2);
3955 : }
3956 :
3957 0 : break;
3958 :
3959 : case 171:
3960 :
3961 : {
3962 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtInt, (yylsp[0]));
3963 0 : (yyval.interm.typeSpecifierNonArray).setAggregate(3);
3964 : }
3965 :
3966 0 : break;
3967 :
3968 : case 172:
3969 :
3970 : {
3971 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtInt, (yylsp[0]));
3972 0 : (yyval.interm.typeSpecifierNonArray).setAggregate(4);
3973 : }
3974 :
3975 0 : break;
3976 :
3977 : case 173:
3978 :
3979 : {
3980 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtUInt, (yylsp[0]));
3981 0 : (yyval.interm.typeSpecifierNonArray).setAggregate(2);
3982 : }
3983 :
3984 0 : break;
3985 :
3986 : case 174:
3987 :
3988 : {
3989 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtUInt, (yylsp[0]));
3990 0 : (yyval.interm.typeSpecifierNonArray).setAggregate(3);
3991 : }
3992 :
3993 0 : break;
3994 :
3995 : case 175:
3996 :
3997 : {
3998 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtUInt, (yylsp[0]));
3999 0 : (yyval.interm.typeSpecifierNonArray).setAggregate(4);
4000 : }
4001 :
4002 0 : break;
4003 :
4004 : case 176:
4005 :
4006 : {
4007 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
4008 0 : (yyval.interm.typeSpecifierNonArray).setMatrix(2, 2);
4009 : }
4010 :
4011 0 : break;
4012 :
4013 : case 177:
4014 :
4015 : {
4016 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
4017 0 : (yyval.interm.typeSpecifierNonArray).setMatrix(3, 3);
4018 : }
4019 :
4020 0 : break;
4021 :
4022 : case 178:
4023 :
4024 : {
4025 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
4026 0 : (yyval.interm.typeSpecifierNonArray).setMatrix(4, 4);
4027 : }
4028 :
4029 0 : break;
4030 :
4031 : case 179:
4032 :
4033 : {
4034 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
4035 0 : (yyval.interm.typeSpecifierNonArray).setMatrix(2, 3);
4036 : }
4037 :
4038 0 : break;
4039 :
4040 : case 180:
4041 :
4042 : {
4043 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
4044 0 : (yyval.interm.typeSpecifierNonArray).setMatrix(3, 2);
4045 : }
4046 :
4047 0 : break;
4048 :
4049 : case 181:
4050 :
4051 : {
4052 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
4053 0 : (yyval.interm.typeSpecifierNonArray).setMatrix(2, 4);
4054 : }
4055 :
4056 0 : break;
4057 :
4058 : case 182:
4059 :
4060 : {
4061 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
4062 0 : (yyval.interm.typeSpecifierNonArray).setMatrix(4, 2);
4063 : }
4064 :
4065 0 : break;
4066 :
4067 : case 183:
4068 :
4069 : {
4070 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
4071 0 : (yyval.interm.typeSpecifierNonArray).setMatrix(3, 4);
4072 : }
4073 :
4074 0 : break;
4075 :
4076 : case 184:
4077 :
4078 : {
4079 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtFloat, (yylsp[0]));
4080 0 : (yyval.interm.typeSpecifierNonArray).setMatrix(4, 3);
4081 : }
4082 :
4083 0 : break;
4084 :
4085 : case 185:
4086 :
4087 : {
4088 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtSampler2D, (yylsp[0]));
4089 : }
4090 :
4091 0 : break;
4092 :
4093 : case 186:
4094 :
4095 : {
4096 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtSampler3D, (yylsp[0]));
4097 : }
4098 :
4099 0 : break;
4100 :
4101 : case 187:
4102 :
4103 : {
4104 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtSamplerCube, (yylsp[0]));
4105 : }
4106 :
4107 0 : break;
4108 :
4109 : case 188:
4110 :
4111 : {
4112 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtSampler2DArray, (yylsp[0]));
4113 : }
4114 :
4115 0 : break;
4116 :
4117 : case 189:
4118 :
4119 : {
4120 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtISampler2D, (yylsp[0]));
4121 : }
4122 :
4123 0 : break;
4124 :
4125 : case 190:
4126 :
4127 : {
4128 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtISampler3D, (yylsp[0]));
4129 : }
4130 :
4131 0 : break;
4132 :
4133 : case 191:
4134 :
4135 : {
4136 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtISamplerCube, (yylsp[0]));
4137 : }
4138 :
4139 0 : break;
4140 :
4141 : case 192:
4142 :
4143 : {
4144 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtISampler2DArray, (yylsp[0]));
4145 : }
4146 :
4147 0 : break;
4148 :
4149 : case 193:
4150 :
4151 : {
4152 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtUSampler2D, (yylsp[0]));
4153 : }
4154 :
4155 0 : break;
4156 :
4157 : case 194:
4158 :
4159 : {
4160 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtUSampler3D, (yylsp[0]));
4161 : }
4162 :
4163 0 : break;
4164 :
4165 : case 195:
4166 :
4167 : {
4168 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtUSamplerCube, (yylsp[0]));
4169 : }
4170 :
4171 0 : break;
4172 :
4173 : case 196:
4174 :
4175 : {
4176 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtUSampler2DArray, (yylsp[0]));
4177 : }
4178 :
4179 0 : break;
4180 :
4181 : case 197:
4182 :
4183 : {
4184 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtSampler2DShadow, (yylsp[0]));
4185 : }
4186 :
4187 0 : break;
4188 :
4189 : case 198:
4190 :
4191 : {
4192 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtSamplerCubeShadow, (yylsp[0]));
4193 : }
4194 :
4195 0 : break;
4196 :
4197 : case 199:
4198 :
4199 : {
4200 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtSampler2DArrayShadow, (yylsp[0]));
4201 : }
4202 :
4203 0 : break;
4204 :
4205 : case 200:
4206 :
4207 : {
4208 0 : if (!context->supportsExtension("GL_OES_EGL_image_external") &&
4209 0 : !context->supportsExtension("GL_NV_EGL_stream_consumer_external")) {
4210 0 : context->error((yylsp[0]), "unsupported type", "samplerExternalOES");
4211 : }
4212 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtSamplerExternalOES, (yylsp[0]));
4213 : }
4214 :
4215 0 : break;
4216 :
4217 : case 201:
4218 :
4219 : {
4220 0 : if (!context->supportsExtension("GL_ARB_texture_rectangle")) {
4221 0 : context->error((yylsp[0]), "unsupported type", "sampler2DRect");
4222 : }
4223 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtSampler2DRect, (yylsp[0]));
4224 : }
4225 :
4226 0 : break;
4227 :
4228 : case 202:
4229 :
4230 : {
4231 0 : (yyval.interm.typeSpecifierNonArray) = (yyvsp[0].interm.typeSpecifierNonArray);
4232 : }
4233 :
4234 0 : break;
4235 :
4236 : case 203:
4237 :
4238 : {
4239 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtImage2D, (yylsp[0]));
4240 : }
4241 :
4242 0 : break;
4243 :
4244 : case 204:
4245 :
4246 : {
4247 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtIImage2D, (yylsp[0]));
4248 : }
4249 :
4250 0 : break;
4251 :
4252 : case 205:
4253 :
4254 : {
4255 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtUImage2D, (yylsp[0]));
4256 : }
4257 :
4258 0 : break;
4259 :
4260 : case 206:
4261 :
4262 : {
4263 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtImage3D, (yylsp[0]));
4264 : }
4265 :
4266 0 : break;
4267 :
4268 : case 207:
4269 :
4270 : {
4271 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtIImage3D, (yylsp[0]));
4272 : }
4273 :
4274 0 : break;
4275 :
4276 : case 208:
4277 :
4278 : {
4279 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtUImage3D, (yylsp[0]));
4280 : }
4281 :
4282 0 : break;
4283 :
4284 : case 209:
4285 :
4286 : {
4287 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtImage2DArray, (yylsp[0]));
4288 : }
4289 :
4290 0 : break;
4291 :
4292 : case 210:
4293 :
4294 : {
4295 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtIImage2DArray, (yylsp[0]));
4296 : }
4297 :
4298 0 : break;
4299 :
4300 : case 211:
4301 :
4302 : {
4303 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtUImage2DArray, (yylsp[0]));
4304 : }
4305 :
4306 0 : break;
4307 :
4308 : case 212:
4309 :
4310 : {
4311 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtImageCube, (yylsp[0]));
4312 : }
4313 :
4314 0 : break;
4315 :
4316 : case 213:
4317 :
4318 : {
4319 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtIImageCube, (yylsp[0]));
4320 : }
4321 :
4322 0 : break;
4323 :
4324 : case 214:
4325 :
4326 : {
4327 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtUImageCube, (yylsp[0]));
4328 : }
4329 :
4330 0 : break;
4331 :
4332 : case 215:
4333 :
4334 : {
4335 : //
4336 : // This is for user defined type names. The lexical phase looked up the
4337 : // type.
4338 : //
4339 0 : TType& structure = static_cast<TVariable*>((yyvsp[0].lex).symbol)->getType();
4340 0 : (yyval.interm.typeSpecifierNonArray).initialize(EbtStruct, (yylsp[0]));
4341 0 : (yyval.interm.typeSpecifierNonArray).userDef = &structure;
4342 : }
4343 :
4344 0 : break;
4345 :
4346 : case 216:
4347 :
4348 0 : { context->enterStructDeclaration((yylsp[-1]), *(yyvsp[-1].lex).string); }
4349 :
4350 0 : break;
4351 :
4352 : case 217:
4353 :
4354 : {
4355 0 : (yyval.interm.typeSpecifierNonArray) = context->addStructure((yylsp[-5]), (yylsp[-4]), (yyvsp[-4].lex).string, (yyvsp[-1].interm.fieldList));
4356 : }
4357 :
4358 0 : break;
4359 :
4360 : case 218:
4361 :
4362 0 : { context->enterStructDeclaration((yylsp[0]), *(yyvsp[0].lex).string); }
4363 :
4364 0 : break;
4365 :
4366 : case 219:
4367 :
4368 : {
4369 0 : (yyval.interm.typeSpecifierNonArray) = context->addStructure((yylsp[-4]), (yyloc), NewPoolTString(""), (yyvsp[-1].interm.fieldList));
4370 : }
4371 :
4372 0 : break;
4373 :
4374 : case 220:
4375 :
4376 : {
4377 0 : (yyval.interm.fieldList) = (yyvsp[0].interm.fieldList);
4378 : }
4379 :
4380 0 : break;
4381 :
4382 : case 221:
4383 :
4384 : {
4385 0 : (yyval.interm.fieldList) = (yyvsp[-1].interm.fieldList);
4386 0 : for (size_t i = 0; i < (yyvsp[0].interm.fieldList)->size(); ++i) {
4387 0 : TField* field = (*(yyvsp[0].interm.fieldList))[i];
4388 0 : for (size_t j = 0; j < (yyval.interm.fieldList)->size(); ++j) {
4389 0 : if ((*(yyval.interm.fieldList))[j]->name() == field->name()) {
4390 0 : context->error((yylsp[0]), "duplicate field name in structure:", "struct", field->name().c_str());
4391 : }
4392 : }
4393 0 : (yyval.interm.fieldList)->push_back(field);
4394 : }
4395 : }
4396 :
4397 0 : break;
4398 :
4399 : case 222:
4400 :
4401 : {
4402 0 : (yyval.interm.fieldList) = context->addStructDeclaratorList((yyvsp[-2].interm.type), (yyvsp[-1].interm.fieldList));
4403 : }
4404 :
4405 0 : break;
4406 :
4407 : case 223:
4408 :
4409 : {
4410 : // ES3 Only, but errors should be handled elsewhere
4411 0 : (yyval.interm.fieldList) = context->addStructDeclaratorListWithQualifiers(*(yyvsp[-3].interm.typeQualifierBuilder), &(yyvsp[-2].interm.type), (yyvsp[-1].interm.fieldList));
4412 : }
4413 :
4414 0 : break;
4415 :
4416 : case 224:
4417 :
4418 : {
4419 0 : (yyval.interm.fieldList) = NewPoolTFieldList();
4420 0 : (yyval.interm.fieldList)->push_back((yyvsp[0].interm.field));
4421 : }
4422 :
4423 0 : break;
4424 :
4425 : case 225:
4426 :
4427 : {
4428 0 : (yyval.interm.fieldList)->push_back((yyvsp[0].interm.field));
4429 : }
4430 :
4431 0 : break;
4432 :
4433 : case 226:
4434 :
4435 : {
4436 0 : context->checkIsNotReserved((yylsp[0]), *(yyvsp[0].lex).string);
4437 :
4438 0 : TType* type = new TType(EbtVoid, EbpUndefined);
4439 0 : (yyval.interm.field) = new TField(type, (yyvsp[0].lex).string, (yylsp[0]));
4440 : }
4441 :
4442 0 : break;
4443 :
4444 : case 227:
4445 :
4446 : {
4447 0 : context->checkIsNotReserved((yylsp[-3]), *(yyvsp[-3].lex).string);
4448 :
4449 0 : TType* type = new TType(EbtVoid, EbpUndefined);
4450 0 : unsigned int size = context->checkIsValidArraySize((yylsp[-1]), (yyvsp[-1].interm.intermTypedNode));
4451 0 : type->setArraySize(size);
4452 :
4453 0 : (yyval.interm.field) = new TField(type, (yyvsp[-3].lex).string, (yylsp[-3]));
4454 : }
4455 :
4456 0 : break;
4457 :
4458 : case 228:
4459 :
4460 0 : { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4461 :
4462 0 : break;
4463 :
4464 : case 229:
4465 :
4466 0 : { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4467 :
4468 0 : break;
4469 :
4470 : case 230:
4471 :
4472 0 : { (yyval.interm.intermNode) = (yyvsp[0].interm.intermBlock); }
4473 :
4474 0 : break;
4475 :
4476 : case 231:
4477 :
4478 0 : { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4479 :
4480 0 : break;
4481 :
4482 : case 232:
4483 :
4484 0 : { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4485 :
4486 0 : break;
4487 :
4488 : case 233:
4489 :
4490 0 : { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4491 :
4492 0 : break;
4493 :
4494 : case 234:
4495 :
4496 0 : { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4497 :
4498 0 : break;
4499 :
4500 : case 235:
4501 :
4502 0 : { (yyval.interm.intermNode) = (yyvsp[0].interm.intermSwitch); }
4503 :
4504 0 : break;
4505 :
4506 : case 236:
4507 :
4508 0 : { (yyval.interm.intermNode) = (yyvsp[0].interm.intermCase); }
4509 :
4510 0 : break;
4511 :
4512 : case 237:
4513 :
4514 0 : { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4515 :
4516 0 : break;
4517 :
4518 : case 238:
4519 :
4520 0 : { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4521 :
4522 0 : break;
4523 :
4524 : case 239:
4525 :
4526 0 : { (yyval.interm.intermBlock) = 0; }
4527 :
4528 0 : break;
4529 :
4530 : case 240:
4531 :
4532 0 : { context->symbolTable.push(); }
4533 :
4534 0 : break;
4535 :
4536 : case 241:
4537 :
4538 0 : { context->symbolTable.pop(); }
4539 :
4540 0 : break;
4541 :
4542 : case 242:
4543 :
4544 : {
4545 0 : if ((yyvsp[-2].interm.intermBlock) != 0) {
4546 0 : (yyvsp[-2].interm.intermBlock)->setLine((yyloc));
4547 : }
4548 0 : (yyval.interm.intermBlock) = (yyvsp[-2].interm.intermBlock);
4549 : }
4550 :
4551 0 : break;
4552 :
4553 : case 243:
4554 :
4555 0 : { (yyval.interm.intermNode) = (yyvsp[0].interm.intermBlock); }
4556 :
4557 0 : break;
4558 :
4559 : case 244:
4560 :
4561 0 : { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4562 :
4563 0 : break;
4564 :
4565 : case 245:
4566 :
4567 0 : { context->symbolTable.push(); }
4568 :
4569 0 : break;
4570 :
4571 : case 246:
4572 :
4573 0 : { context->symbolTable.pop(); (yyval.interm.intermNode) = (yyvsp[0].interm.intermBlock); }
4574 :
4575 0 : break;
4576 :
4577 : case 247:
4578 :
4579 0 : { context->symbolTable.push(); }
4580 :
4581 0 : break;
4582 :
4583 : case 248:
4584 :
4585 0 : { context->symbolTable.pop(); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4586 :
4587 0 : break;
4588 :
4589 : case 249:
4590 :
4591 : {
4592 0 : (yyval.interm.intermBlock) = 0;
4593 : }
4594 :
4595 0 : break;
4596 :
4597 : case 250:
4598 :
4599 : {
4600 0 : if ((yyvsp[-1].interm.intermBlock)) {
4601 0 : (yyvsp[-1].interm.intermBlock)->setLine((yyloc));
4602 : }
4603 0 : (yyval.interm.intermBlock) = (yyvsp[-1].interm.intermBlock);
4604 : }
4605 :
4606 0 : break;
4607 :
4608 : case 251:
4609 :
4610 : {
4611 0 : (yyval.interm.intermBlock) = new TIntermBlock();
4612 0 : (yyval.interm.intermBlock)->setLine((yyloc));
4613 0 : (yyval.interm.intermBlock)->appendStatement((yyvsp[0].interm.intermNode));
4614 : }
4615 :
4616 0 : break;
4617 :
4618 : case 252:
4619 :
4620 : {
4621 0 : (yyval.interm.intermBlock) = (yyvsp[-1].interm.intermBlock);
4622 0 : (yyval.interm.intermBlock)->appendStatement((yyvsp[0].interm.intermNode));
4623 : }
4624 :
4625 0 : break;
4626 :
4627 : case 253:
4628 :
4629 0 : { (yyval.interm.intermNode) = 0; }
4630 :
4631 0 : break;
4632 :
4633 : case 254:
4634 :
4635 0 : { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[-1].interm.intermTypedNode)); }
4636 :
4637 0 : break;
4638 :
4639 : case 255:
4640 :
4641 : {
4642 0 : context->checkIsScalarBool((yylsp[-4]), (yyvsp[-2].interm.intermTypedNode));
4643 0 : (yyval.interm.intermNode) = context->intermediate.addIfElse((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yylsp[-4]));
4644 : }
4645 :
4646 0 : break;
4647 :
4648 : case 256:
4649 :
4650 : {
4651 0 : (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode);
4652 0 : (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode);
4653 : }
4654 :
4655 0 : break;
4656 :
4657 : case 257:
4658 :
4659 : {
4660 0 : (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode);
4661 0 : (yyval.interm.nodePair).node2 = 0;
4662 : }
4663 :
4664 0 : break;
4665 :
4666 : case 258:
4667 :
4668 0 : { context->incrSwitchNestingLevel(); }
4669 :
4670 0 : break;
4671 :
4672 : case 259:
4673 :
4674 : {
4675 0 : (yyval.interm.intermSwitch) = context->addSwitch((yyvsp[-3].interm.intermTypedNode), (yyvsp[0].interm.intermBlock), (yylsp[-5]));
4676 0 : context->decrSwitchNestingLevel();
4677 : }
4678 :
4679 0 : break;
4680 :
4681 : case 260:
4682 :
4683 : {
4684 0 : (yyval.interm.intermCase) = context->addCase((yyvsp[-1].interm.intermTypedNode), (yylsp[-2]));
4685 : }
4686 :
4687 0 : break;
4688 :
4689 : case 261:
4690 :
4691 : {
4692 0 : (yyval.interm.intermCase) = context->addDefault((yylsp[-1]));
4693 : }
4694 :
4695 0 : break;
4696 :
4697 : case 262:
4698 :
4699 : {
4700 0 : (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4701 0 : context->checkIsScalarBool((yyvsp[0].interm.intermTypedNode)->getLine(), (yyvsp[0].interm.intermTypedNode));
4702 : }
4703 :
4704 0 : break;
4705 :
4706 : case 263:
4707 :
4708 : {
4709 0 : TIntermBinary *initNode = nullptr;
4710 0 : context->checkIsScalarBool((yylsp[-2]), (yyvsp[-3].interm.type));
4711 :
4712 0 : if (!context->executeInitializer((yylsp[-2]), *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), (yyvsp[0].interm.intermTypedNode), &initNode))
4713 0 : (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4714 : else {
4715 0 : (yyval.interm.intermTypedNode) = 0;
4716 : }
4717 : }
4718 :
4719 0 : break;
4720 :
4721 : case 264:
4722 :
4723 0 : { context->symbolTable.push(); context->incrLoopNestingLevel(); }
4724 :
4725 0 : break;
4726 :
4727 : case 265:
4728 :
4729 : {
4730 0 : context->symbolTable.pop();
4731 0 : (yyval.interm.intermNode) = context->intermediate.addLoop(ELoopWhile, 0, (yyvsp[-2].interm.intermTypedNode), 0, (yyvsp[0].interm.intermNode), (yylsp[-5]));
4732 0 : context->decrLoopNestingLevel();
4733 : }
4734 :
4735 0 : break;
4736 :
4737 : case 266:
4738 :
4739 0 : { context->incrLoopNestingLevel(); }
4740 :
4741 0 : break;
4742 :
4743 : case 267:
4744 :
4745 : {
4746 0 : context->checkIsScalarBool((yylsp[0]), (yyvsp[-2].interm.intermTypedNode));
4747 :
4748 0 : (yyval.interm.intermNode) = context->intermediate.addLoop(ELoopDoWhile, 0, (yyvsp[-2].interm.intermTypedNode), 0, (yyvsp[-5].interm.intermNode), (yylsp[-4]));
4749 0 : context->decrLoopNestingLevel();
4750 : }
4751 :
4752 0 : break;
4753 :
4754 : case 268:
4755 :
4756 0 : { context->symbolTable.push(); context->incrLoopNestingLevel(); }
4757 :
4758 0 : break;
4759 :
4760 : case 269:
4761 :
4762 : {
4763 0 : context->symbolTable.pop();
4764 0 : (yyval.interm.intermNode) = context->intermediate.addLoop(ELoopFor, (yyvsp[-3].interm.intermNode), reinterpret_cast<TIntermTyped*>((yyvsp[-2].interm.nodePair).node1), reinterpret_cast<TIntermTyped*>((yyvsp[-2].interm.nodePair).node2), (yyvsp[0].interm.intermNode), (yylsp[-6]));
4765 0 : context->decrLoopNestingLevel();
4766 : }
4767 :
4768 0 : break;
4769 :
4770 : case 270:
4771 :
4772 : {
4773 0 : (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
4774 : }
4775 :
4776 0 : break;
4777 :
4778 : case 271:
4779 :
4780 : {
4781 0 : (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
4782 : }
4783 :
4784 0 : break;
4785 :
4786 : case 272:
4787 :
4788 : {
4789 0 : (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4790 : }
4791 :
4792 0 : break;
4793 :
4794 : case 273:
4795 :
4796 : {
4797 0 : (yyval.interm.intermTypedNode) = 0;
4798 : }
4799 :
4800 0 : break;
4801 :
4802 : case 274:
4803 :
4804 : {
4805 0 : (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode);
4806 0 : (yyval.interm.nodePair).node2 = 0;
4807 : }
4808 :
4809 0 : break;
4810 :
4811 : case 275:
4812 :
4813 : {
4814 0 : (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode);
4815 0 : (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode);
4816 : }
4817 :
4818 0 : break;
4819 :
4820 : case 276:
4821 :
4822 : {
4823 0 : (yyval.interm.intermNode) = context->addBranch(EOpContinue, (yylsp[-1]));
4824 : }
4825 :
4826 0 : break;
4827 :
4828 : case 277:
4829 :
4830 : {
4831 0 : (yyval.interm.intermNode) = context->addBranch(EOpBreak, (yylsp[-1]));
4832 : }
4833 :
4834 0 : break;
4835 :
4836 : case 278:
4837 :
4838 : {
4839 0 : (yyval.interm.intermNode) = context->addBranch(EOpReturn, (yylsp[-1]));
4840 : }
4841 :
4842 0 : break;
4843 :
4844 : case 279:
4845 :
4846 : {
4847 0 : (yyval.interm.intermNode) = context->addBranch(EOpReturn, (yyvsp[-1].interm.intermTypedNode), (yylsp[-2]));
4848 : }
4849 :
4850 0 : break;
4851 :
4852 : case 280:
4853 :
4854 : {
4855 0 : FRAG_ONLY("discard", (yylsp[-1]));
4856 0 : (yyval.interm.intermNode) = context->addBranch(EOpKill, (yylsp[-1]));
4857 : }
4858 :
4859 0 : break;
4860 :
4861 : case 281:
4862 :
4863 : {
4864 0 : (yyval.interm.intermBlock) = new TIntermBlock();
4865 0 : (yyval.interm.intermBlock)->setLine((yyloc));
4866 0 : (yyval.interm.intermBlock)->appendStatement((yyvsp[0].interm.intermNode));
4867 0 : context->setTreeRoot((yyval.interm.intermBlock));
4868 : }
4869 :
4870 0 : break;
4871 :
4872 : case 282:
4873 :
4874 : {
4875 0 : (yyval.interm.intermBlock)->appendStatement((yyvsp[0].interm.intermNode));
4876 : }
4877 :
4878 0 : break;
4879 :
4880 : case 283:
4881 :
4882 : {
4883 0 : (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
4884 : }
4885 :
4886 0 : break;
4887 :
4888 : case 284:
4889 :
4890 : {
4891 0 : (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
4892 : }
4893 :
4894 0 : break;
4895 :
4896 : case 285:
4897 :
4898 : {
4899 0 : context->parseFunctionDefinitionHeader((yylsp[0]), &((yyvsp[0].interm).function), &(yyvsp[0].interm).intermAggregate);
4900 : }
4901 :
4902 0 : break;
4903 :
4904 : case 286:
4905 :
4906 : {
4907 0 : (yyval.interm.intermNode) = context->addFunctionDefinition(*((yyvsp[-2].interm).function), (yyvsp[-2].interm).intermAggregate, (yyvsp[0].interm.intermBlock), (yylsp[-2]));
4908 : }
4909 :
4910 0 : break;
4911 :
4912 :
4913 :
4914 0 : default: break;
4915 : }
4916 : /* User semantic actions sometimes alter yychar, and that requires
4917 : that yytoken be updated with the new translation. We take the
4918 : approach of translating immediately before every use of yytoken.
4919 : One alternative is translating here after every semantic action,
4920 : but that translation would be missed if the semantic action invokes
4921 : YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
4922 : if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
4923 : incorrect destructor might then be invoked immediately. In the
4924 : case of YYERROR or YYBACKUP, subsequent parser actions might lead
4925 : to an incorrect destructor call or verbose syntax error message
4926 : before the lookahead is translated. */
4927 : YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4928 :
4929 0 : YYPOPSTACK (yylen);
4930 0 : yylen = 0;
4931 : YY_STACK_PRINT (yyss, yyssp);
4932 :
4933 0 : *++yyvsp = yyval;
4934 0 : *++yylsp = yyloc;
4935 :
4936 : /* Now 'shift' the result of the reduction. Determine what state
4937 : that goes to, based on the state we popped back to and the rule
4938 : number reduced by. */
4939 :
4940 0 : yyn = yyr1[yyn];
4941 :
4942 0 : yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4943 0 : if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4944 0 : yystate = yytable[yystate];
4945 : else
4946 0 : yystate = yydefgoto[yyn - YYNTOKENS];
4947 :
4948 0 : goto yynewstate;
4949 :
4950 :
4951 : /*--------------------------------------.
4952 : | yyerrlab -- here on detecting error. |
4953 : `--------------------------------------*/
4954 : yyerrlab:
4955 : /* Make sure we have latest lookahead translation. See comments at
4956 : user semantic actions for why this is necessary. */
4957 0 : yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
4958 :
4959 : /* If not already recovering from an error, report this error. */
4960 0 : if (!yyerrstatus)
4961 : {
4962 0 : ++yynerrs;
4963 : #if ! YYERROR_VERBOSE
4964 0 : yyerror (&yylloc, context, scanner, YY_("syntax error"));
4965 : #else
4966 : # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
4967 : yyssp, yytoken)
4968 : {
4969 : char const *yymsgp = YY_("syntax error");
4970 : int yysyntax_error_status;
4971 : yysyntax_error_status = YYSYNTAX_ERROR;
4972 : if (yysyntax_error_status == 0)
4973 : yymsgp = yymsg;
4974 : else if (yysyntax_error_status == 1)
4975 : {
4976 : if (yymsg != yymsgbuf)
4977 : YYSTACK_FREE (yymsg);
4978 : yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
4979 : if (!yymsg)
4980 : {
4981 : yymsg = yymsgbuf;
4982 : yymsg_alloc = sizeof yymsgbuf;
4983 : yysyntax_error_status = 2;
4984 : }
4985 : else
4986 : {
4987 : yysyntax_error_status = YYSYNTAX_ERROR;
4988 : yymsgp = yymsg;
4989 : }
4990 : }
4991 : yyerror (&yylloc, context, scanner, yymsgp);
4992 : if (yysyntax_error_status == 2)
4993 : goto yyexhaustedlab;
4994 : }
4995 : # undef YYSYNTAX_ERROR
4996 : #endif
4997 : }
4998 :
4999 0 : yyerror_range[1] = yylloc;
5000 :
5001 0 : if (yyerrstatus == 3)
5002 : {
5003 : /* If just tried and failed to reuse lookahead token after an
5004 : error, discard it. */
5005 :
5006 0 : if (yychar <= YYEOF)
5007 : {
5008 : /* Return failure if at end of input. */
5009 0 : if (yychar == YYEOF)
5010 0 : YYABORT;
5011 : }
5012 : else
5013 : {
5014 : yydestruct ("Error: discarding",
5015 0 : yytoken, &yylval, &yylloc, context, scanner);
5016 0 : yychar = YYEMPTY;
5017 : }
5018 : }
5019 :
5020 : /* Else will try to reuse lookahead token after shifting the error
5021 : token. */
5022 0 : goto yyerrlab1;
5023 :
5024 :
5025 : /*---------------------------------------------------.
5026 : | yyerrorlab -- error raised explicitly by YYERROR. |
5027 : `---------------------------------------------------*/
5028 : yyerrorlab:
5029 :
5030 : /* Pacify compilers like GCC when the user code never invokes
5031 : YYERROR and the label yyerrorlab therefore never appears in user
5032 : code. */
5033 : if (/*CONSTCOND*/ 0)
5034 : goto yyerrorlab;
5035 :
5036 0 : yyerror_range[1] = yylsp[1-yylen];
5037 : /* Do not reclaim the symbols of the rule whose action triggered
5038 : this YYERROR. */
5039 0 : YYPOPSTACK (yylen);
5040 0 : yylen = 0;
5041 : YY_STACK_PRINT (yyss, yyssp);
5042 0 : yystate = *yyssp;
5043 0 : goto yyerrlab1;
5044 :
5045 :
5046 : /*-------------------------------------------------------------.
5047 : | yyerrlab1 -- common code for both syntax error and YYERROR. |
5048 : `-------------------------------------------------------------*/
5049 : yyerrlab1:
5050 0 : yyerrstatus = 3; /* Each real token shifted decrements this. */
5051 :
5052 : for (;;)
5053 : {
5054 0 : yyn = yypact[yystate];
5055 0 : if (!yypact_value_is_default (yyn))
5056 : {
5057 0 : yyn += YYTERROR;
5058 0 : if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
5059 : {
5060 0 : yyn = yytable[yyn];
5061 0 : if (0 < yyn)
5062 0 : break;
5063 : }
5064 : }
5065 :
5066 : /* Pop the current state because it cannot handle the error token. */
5067 0 : if (yyssp == yyss)
5068 0 : YYABORT;
5069 :
5070 0 : yyerror_range[1] = *yylsp;
5071 0 : yydestruct ("Error: popping",
5072 0 : yystos[yystate], yyvsp, yylsp, context, scanner);
5073 0 : YYPOPSTACK (1);
5074 0 : yystate = *yyssp;
5075 : YY_STACK_PRINT (yyss, yyssp);
5076 : }
5077 :
5078 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
5079 0 : *++yyvsp = yylval;
5080 : YY_IGNORE_MAYBE_UNINITIALIZED_END
5081 :
5082 0 : yyerror_range[2] = yylloc;
5083 : /* Using YYLLOC is tempting, but would change the location of
5084 : the lookahead. YYLOC is available though. */
5085 0 : YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
5086 0 : *++yylsp = yyloc;
5087 :
5088 : /* Shift the error token. */
5089 : YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
5090 :
5091 0 : yystate = yyn;
5092 0 : goto yynewstate;
5093 :
5094 :
5095 : /*-------------------------------------.
5096 : | yyacceptlab -- YYACCEPT comes here. |
5097 : `-------------------------------------*/
5098 : yyacceptlab:
5099 0 : yyresult = 0;
5100 0 : goto yyreturn;
5101 :
5102 : /*-----------------------------------.
5103 : | yyabortlab -- YYABORT comes here. |
5104 : `-----------------------------------*/
5105 : yyabortlab:
5106 0 : yyresult = 1;
5107 0 : goto yyreturn;
5108 :
5109 : #if !defined yyoverflow || YYERROR_VERBOSE
5110 : /*-------------------------------------------------.
5111 : | yyexhaustedlab -- memory exhaustion comes here. |
5112 : `-------------------------------------------------*/
5113 : yyexhaustedlab:
5114 0 : yyerror (&yylloc, context, scanner, YY_("memory exhausted"));
5115 0 : yyresult = 2;
5116 : /* Fall through. */
5117 : #endif
5118 :
5119 : yyreturn:
5120 0 : if (yychar != YYEMPTY)
5121 : {
5122 : /* Make sure we have latest lookahead translation. See comments at
5123 : user semantic actions for why this is necessary. */
5124 0 : yytoken = YYTRANSLATE (yychar);
5125 : yydestruct ("Cleanup: discarding lookahead",
5126 0 : yytoken, &yylval, &yylloc, context, scanner);
5127 : }
5128 : /* Do not reclaim the symbols of the rule whose action triggered
5129 : this YYABORT or YYACCEPT. */
5130 0 : YYPOPSTACK (yylen);
5131 : YY_STACK_PRINT (yyss, yyssp);
5132 0 : while (yyssp != yyss)
5133 : {
5134 0 : yydestruct ("Cleanup: popping",
5135 0 : yystos[*yyssp], yyvsp, yylsp, context, scanner);
5136 0 : YYPOPSTACK (1);
5137 : }
5138 : #ifndef yyoverflow
5139 0 : if (yyss != yyssa)
5140 0 : YYSTACK_FREE (yyss);
5141 : #endif
5142 : #if YYERROR_VERBOSE
5143 : if (yymsg != yymsgbuf)
5144 : YYSTACK_FREE (yymsg);
5145 : #endif
5146 0 : return yyresult;
5147 : }
5148 :
5149 :
5150 :
5151 0 : int glslang_parse(TParseContext* context) {
5152 0 : return yyparse(context, context->getScanner());
5153 : }
|
