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