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