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