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