The Tor Browser / file comparison

comparison: gfx/angle/src/compiler/glslang_tab.cpp

gfx/angle/src/compiler/glslang_tab.cpp

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial