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