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