1 /* A Bison parser, made by GNU Bison 3.1. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018 Free Software Foundation, Inc.
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
29
30 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
32
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
35
36 /* All symbols defined below should begin with yy or YY, to avoid
37 infringing on user name space. This should be done even for local
38 variables, as they might otherwise be expanded by user macros.
39 There are some unavoidable exceptions within include files to
40 define necessary library symbols; they are noted "INFRINGES ON
41 USER NAME SPACE" below. */
42
43 /* Identify Bison output. */
44 #define YYBISON 1
45
46 /* Bison version. */
47 #define YYBISON_VERSION "3.1"
48
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51
52 /* Pure parsers. */
53 #define YYPURE 1
54
55 /* Push parsers. */
56 #define YYPUSH 1
57
58 /* Pull parsers. */
59 #define YYPULL 0
60
61
62 /* Substitute the variable and function names. */
63 #define yypush_parse amp_ac_yypush_parse
64 #define yypstate_new amp_ac_yypstate_new
65 #define yypstate_delete amp_ac_yypstate_delete
66 #define yypstate amp_ac_yypstate
67 #define yylex amp_ac_yylex
68 #define yyerror amp_ac_yyerror
69 #define yydebug amp_ac_yydebug
70 #define yynerrs amp_ac_yynerrs
71
72
73 /* Copy the first part of user declarations. */
74 #line 19 "ac-parser.y" /* yacc.c:339 */
75
76
77 #include "ac-scanner.h"
78 #include "ac-parser.h"
79
80 #include <stdlib.h>
81
82 #define YYDEBUG 1
83
84 #include "libanjuta/anjuta-debug.h"
85
86 /* Token location is found directly from token value, there is no need to
87 * maintain a separate location variable */
88 #define YYLLOC_DEFAULT(Current, Rhs, N) ((Current) = YYRHSLOC(Rhs, (N) ? 1 : 0))
89
90 #line 133 "ac-parser.y" /* yacc.c:339 */
91
92
93 //amp_ac_yydebug = 1;
94
95 static gint
amp_ac_autoconf_macro(AnjutaToken * token)96 amp_ac_autoconf_macro (AnjutaToken *token)
97 {
98 switch (anjuta_token_get_type (token))
99 {
100 case AC_ARG_ENABLE: return AC_TOKEN_AC_ARG_ENABLE;
101 case AC_C_CONST: return AC_TOKEN_AC_C_CONST;
102 case AC_CHECK_FUNCS: return AC_TOKEN_AC_CHECK_FUNCS;
103 case AC_CHECK_HEADERS: return AC_TOKEN_AC_CHECK_HEADERS;
104 case AC_CHECK_LIB: return AC_TOKEN_AC_CHECK_LIB;
105 case AC_CHECK_PROG: return AC_TOKEN_AC_CHECK_PROG;
106 case AC_CONFIG_FILES: return AC_TOKEN_AC_CONFIG_FILES;
107 case AC_CONFIG_HEADERS: return AC_TOKEN_AC_CONFIG_HEADERS;
108 case AC_CONFIG_MACRO_DIR: return AC_TOKEN_AC_CONFIG_MACRO_DIR;
109 case AC_CONFIG_SRCDIR: return AC_TOKEN_AC_CONFIG_SRCDIR;
110 case AC_EGREP_HEADER: return AC_TOKEN_AC_EGREP_HEADER;
111 case AC_EXEEXT: return AC_TOKEN_AC_EXEEXT;
112 case AC_HEADER_STDC: return AC_TOKEN_AC_HEADER_STDC;
113 case AC_INIT: return AC_TOKEN_AC_INIT;
114 case AC_OBJEXT: return AC_TOKEN_AC_OBJEXT;
115 case AC_OUTPUT: return AC_TOKEN_AC_OUTPUT;
116 case OBSOLETE_AC_OUTPUT: return AC_TOKEN_OBSOLETE_AC_OUTPUT;
117 case AC_PREREQ: return AC_TOKEN_AC_PREREQ;
118 case AC_PROG_CC: return AC_TOKEN_AC_PROG_CC;
119 case AC_PROG_CPP: return AC_TOKEN_AC_PROG_CPP;
120 case AC_PROG_CXX: return AC_TOKEN_AC_PROG_CXX;
121 case IT_PROG_INTLTOOL: return AC_TOKEN_IT_PROG_INTLTOOL;
122 case AC_PROG_LEX: return AC_TOKEN_AC_PROG_LEX;
123 case AC_PROG_RANLIB: return AC_TOKEN_AC_PROG_RANLIB;
124 case AC_PROG_YACC: return AC_TOKEN_AC_PROG_YACC;
125 case AC_TYPE_SIZE_T: return AC_TOKEN_AC_TYPE_SIZE_T;
126 case AC_TYPE_OFF_T: return AC_TOKEN_AC_TYPE_OFF_T;
127 case AM_INIT_AUTOMAKE: return AC_TOKEN_AM_INIT_AUTOMAKE;
128 case AM_GLIB_GNU_GETTEXT: return AC_TOKEN_AM_GLIB_GNU_GETTEXT;
129 case AM_MAINTAINER_MODE: return AC_TOKEN_AM_MAINTAINER_MODE;
130 case AC_PROG_LIBTOOL: return AC_TOKEN_AC_PROG_LIBTOOL;
131 case AM_PROG_LIBTOOL: return AC_TOKEN_AM_PROG_LIBTOOL;
132 case LT_INIT: return AC_TOKEN_LT_INIT;
133 case DEFAULT_LT_INIT: return AC_TOKEN_LT_INIT;
134 case LT_PREREQ: return AC_TOKEN_LT_PREREQ;
135 case PKG_CHECK_MODULES: return AC_TOKEN_PKG_CHECK_MODULES;
136 case PKG_PROG_PKG_CONFIG: return AC_TOKEN_PKG_PROG_PKG_CONFIG;
137 default: return anjuta_token_get_type (token);
138 }
139 }
140
141
142 #line 143 "ac-parser.c" /* yacc.c:339 */
143
144 # ifndef YY_NULLPTR
145 # if defined __cplusplus && 201103L <= __cplusplus
146 # define YY_NULLPTR nullptr
147 # else
148 # define YY_NULLPTR 0
149 # endif
150 # endif
151
152 /* Enabling verbose error messages. */
153 #ifdef YYERROR_VERBOSE
154 # undef YYERROR_VERBOSE
155 # define YYERROR_VERBOSE 1
156 #else
157 # define YYERROR_VERBOSE 0
158 #endif
159
160 /* In a future release of Bison, this section will be replaced
161 by #include "ac-parser.h". */
162 #ifndef YY_AMP_AC_YY_AC_PARSER_H_INCLUDED
163 # define YY_AMP_AC_YY_AC_PARSER_H_INCLUDED
164 /* Debug traces. */
165 #ifndef YYDEBUG
166 # define YYDEBUG 1
167 #endif
168 #if YYDEBUG
169 extern int amp_ac_yydebug;
170 #endif
171
172 /* Token type. */
173 #ifndef YYTOKENTYPE
174 # define YYTOKENTYPE
175 enum yytokentype
176 {
177 END_OF_FILE = 259,
178 END_OF_LINE = 260,
179 SPACE = 261,
180 HASH = 262,
181 LEFT_PAREN = 263,
182 RIGHT_PAREN = 264,
183 LEFT_CURLY = 265,
184 RIGHT_CURLY = 266,
185 LEFT_BRACE = 267,
186 RIGHT_BRACE = 268,
187 EQUAL = 269,
188 COMMA = 270,
189 LOWER = 271,
190 GREATER = 272,
191 SINGLE_QUOTE = 273,
192 DOUBLE_QUOTE = 274,
193 COMMENT = 256,
194 NAME = 275,
195 VARIABLE = 276,
196 MACRO = 277,
197 OPERATOR = 278,
198 WORD = 279,
199 JUNK = 280,
200 START_SPACE_LIST = 281,
201 DNL = 282,
202 M4_INCLUDE = 283,
203 AC_MACRO_WITH_ARG = 284,
204 AC_MACRO_WITHOUT_ARG = 285,
205 AC_ARG_ENABLE = 286,
206 AC_C_CONST = 287,
207 AC_CHECK_FUNCS = 288,
208 AC_CHECK_HEADERS = 289,
209 AC_CHECK_LIB = 290,
210 AC_CHECK_PROG = 291,
211 AC_CONFIG_FILES = 292,
212 AC_CONFIG_HEADERS = 293,
213 AC_CONFIG_MACRO_DIR = 294,
214 AC_CONFIG_SRCDIR = 295,
215 AC_EGREP_HEADER = 296,
216 AC_EXEEXT = 297,
217 AC_HEADER_STDC = 298,
218 AC_INIT = 299,
219 AC_OBJEXT = 300,
220 AC_OUTPUT = 301,
221 OBSOLETE_AC_OUTPUT = 302,
222 AC_PREREQ = 303,
223 AC_PROG_CC = 304,
224 AC_PROG_CPP = 305,
225 AC_PROG_CXX = 306,
226 IT_PROG_INTLTOOL = 307,
227 AC_PROG_LEX = 308,
228 AC_PROG_RANLIB = 309,
229 AC_PROG_YACC = 310,
230 AC_SUBST = 311,
231 AC_TYPE_SIZE_T = 312,
232 AC_TYPE_OFF_T = 313,
233 AM_INIT_AUTOMAKE = 314,
234 AM_GLIB_GNU_GETTEXT = 315,
235 AM_MAINTAINER_MODE = 316,
236 AM_PROG_LIBTOOL = 317,
237 AC_PROG_LIBTOOL = 318,
238 LT_INIT = 319,
239 DEFAULT_LT_INIT = 320,
240 LT_PREREQ = 321,
241 PKG_CHECK_MODULES = 322,
242 PKG_PROG_PKG_CONFIG = 323,
243 EMPTY = 324,
244 ARG = 325
245 };
246 #endif
247 /* Tokens. */
248 #define END_OF_FILE 259
249 #define END_OF_LINE 260
250 #define SPACE 261
251 #define HASH 262
252 #define LEFT_PAREN 263
253 #define RIGHT_PAREN 264
254 #define LEFT_CURLY 265
255 #define RIGHT_CURLY 266
256 #define LEFT_BRACE 267
257 #define RIGHT_BRACE 268
258 #define EQUAL 269
259 #define COMMA 270
260 #define LOWER 271
261 #define GREATER 272
262 #define SINGLE_QUOTE 273
263 #define DOUBLE_QUOTE 274
264 #define COMMENT 256
265 #define NAME 275
266 #define VARIABLE 276
267 #define MACRO 277
268 #define OPERATOR 278
269 #define WORD 279
270 #define JUNK 280
271 #define START_SPACE_LIST 281
272 #define DNL 282
273 #define M4_INCLUDE 283
274 #define AC_MACRO_WITH_ARG 284
275 #define AC_MACRO_WITHOUT_ARG 285
276 #define AC_ARG_ENABLE 286
277 #define AC_C_CONST 287
278 #define AC_CHECK_FUNCS 288
279 #define AC_CHECK_HEADERS 289
280 #define AC_CHECK_LIB 290
281 #define AC_CHECK_PROG 291
282 #define AC_CONFIG_FILES 292
283 #define AC_CONFIG_HEADERS 293
284 #define AC_CONFIG_MACRO_DIR 294
285 #define AC_CONFIG_SRCDIR 295
286 #define AC_EGREP_HEADER 296
287 #define AC_EXEEXT 297
288 #define AC_HEADER_STDC 298
289 #define AC_INIT 299
290 #define AC_OBJEXT 300
291 #define AC_OUTPUT 301
292 #define OBSOLETE_AC_OUTPUT 302
293 #define AC_PREREQ 303
294 #define AC_PROG_CC 304
295 #define AC_PROG_CPP 305
296 #define AC_PROG_CXX 306
297 #define IT_PROG_INTLTOOL 307
298 #define AC_PROG_LEX 308
299 #define AC_PROG_RANLIB 309
300 #define AC_PROG_YACC 310
301 #define AC_SUBST 311
302 #define AC_TYPE_SIZE_T 312
303 #define AC_TYPE_OFF_T 313
304 #define AM_INIT_AUTOMAKE 314
305 #define AM_GLIB_GNU_GETTEXT 315
306 #define AM_MAINTAINER_MODE 316
307 #define AM_PROG_LIBTOOL 317
308 #define AC_PROG_LIBTOOL 318
309 #define LT_INIT 319
310 #define DEFAULT_LT_INIT 320
311 #define LT_PREREQ 321
312 #define PKG_CHECK_MODULES 322
313 #define PKG_PROG_PKG_CONFIG 323
314 #define EMPTY 324
315 #define ARG 325
316
317 /* Value type. */
318 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
319 typedef int YYSTYPE;
320 # define YYSTYPE_IS_TRIVIAL 1
321 # define YYSTYPE_IS_DECLARED 1
322 #endif
323
324 /* Location type. */
325 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
326 typedef struct YYLTYPE YYLTYPE;
327 struct YYLTYPE
328 {
329 int first_line;
330 int first_column;
331 int last_line;
332 int last_column;
333 };
334 # define YYLTYPE_IS_DECLARED 1
335 # define YYLTYPE_IS_TRIVIAL 1
336 #endif
337
338
339
340 #ifndef YYPUSH_MORE_DEFINED
341 # define YYPUSH_MORE_DEFINED
342 enum { YYPUSH_MORE = 4 };
343 #endif
344
345 typedef struct amp_ac_yypstate amp_ac_yypstate;
346
347 int amp_ac_yypush_parse (amp_ac_yypstate *ps, int pushed_char, YYSTYPE const *pushed_val, YYLTYPE *pushed_loc, AmpAcScanner* scanner);
348
349 amp_ac_yypstate * amp_ac_yypstate_new (void);
350 void amp_ac_yypstate_delete (amp_ac_yypstate *ps);
351
352 #endif /* !YY_AMP_AC_YY_AC_PARSER_H_INCLUDED */
353
354 /* Copy the second part of user declarations. */
355
356 #line 357 "ac-parser.c" /* yacc.c:358 */
357
358 #ifdef short
359 # undef short
360 #endif
361
362 #ifdef YYTYPE_UINT8
363 typedef YYTYPE_UINT8 yytype_uint8;
364 #else
365 typedef unsigned char yytype_uint8;
366 #endif
367
368 #ifdef YYTYPE_INT8
369 typedef YYTYPE_INT8 yytype_int8;
370 #else
371 typedef signed char yytype_int8;
372 #endif
373
374 #ifdef YYTYPE_UINT16
375 typedef YYTYPE_UINT16 yytype_uint16;
376 #else
377 typedef unsigned short yytype_uint16;
378 #endif
379
380 #ifdef YYTYPE_INT16
381 typedef YYTYPE_INT16 yytype_int16;
382 #else
383 typedef short yytype_int16;
384 #endif
385
386 #ifndef YYSIZE_T
387 # ifdef __SIZE_TYPE__
388 # define YYSIZE_T __SIZE_TYPE__
389 # elif defined size_t
390 # define YYSIZE_T size_t
391 # elif ! defined YYSIZE_T
392 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
393 # define YYSIZE_T size_t
394 # else
395 # define YYSIZE_T unsigned
396 # endif
397 #endif
398
399 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
400
401 #ifndef YY_
402 # if defined YYENABLE_NLS && YYENABLE_NLS
403 # if ENABLE_NLS
404 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
405 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
406 # endif
407 # endif
408 # ifndef YY_
409 # define YY_(Msgid) Msgid
410 # endif
411 #endif
412
413 #ifndef YY_ATTRIBUTE
414 # if (defined __GNUC__ \
415 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
416 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
417 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
418 # else
419 # define YY_ATTRIBUTE(Spec) /* empty */
420 # endif
421 #endif
422
423 #ifndef YY_ATTRIBUTE_PURE
424 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
425 #endif
426
427 #ifndef YY_ATTRIBUTE_UNUSED
428 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
429 #endif
430
431 #if !defined _Noreturn \
432 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
433 # if defined _MSC_VER && 1200 <= _MSC_VER
434 # define _Noreturn __declspec (noreturn)
435 # else
436 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
437 # endif
438 #endif
439
440 /* Suppress unused-variable warnings by "using" E. */
441 #if ! defined lint || defined __GNUC__
442 # define YYUSE(E) ((void) (E))
443 #else
444 # define YYUSE(E) /* empty */
445 #endif
446
447 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
448 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
449 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
450 _Pragma ("GCC diagnostic push") \
451 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
452 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
453 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
454 _Pragma ("GCC diagnostic pop")
455 #else
456 # define YY_INITIAL_VALUE(Value) Value
457 #endif
458 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
459 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
460 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
461 #endif
462 #ifndef YY_INITIAL_VALUE
463 # define YY_INITIAL_VALUE(Value) /* Nothing. */
464 #endif
465
466
467 #if ! defined yyoverflow || YYERROR_VERBOSE
468
469 /* The parser invokes alloca or malloc; define the necessary symbols. */
470
471 # ifdef YYSTACK_ALLOC
472 /* Pacify GCC's 'empty if-body' warning. */
473 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
474 # ifndef YYSTACK_ALLOC_MAXIMUM
475 /* The OS might guarantee only one guard page at the bottom of the stack,
476 and a page size can be as small as 4096 bytes. So we cannot safely
477 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
478 to allow for a few compiler-allocated temporary stack slots. */
479 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
480 # endif
481 # else
482 # define YYSTACK_ALLOC YYMALLOC
483 # define YYSTACK_FREE YYFREE
484 # ifndef YYSTACK_ALLOC_MAXIMUM
485 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
486 # endif
487 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
488 && ! ((defined YYMALLOC || defined malloc) \
489 && (defined YYFREE || defined free)))
490 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
491 # ifndef EXIT_SUCCESS
492 # define EXIT_SUCCESS 0
493 # endif
494 # endif
495 # ifndef YYMALLOC
496 # define YYMALLOC malloc
497 # if ! defined malloc && ! defined EXIT_SUCCESS
498 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
499 # endif
500 # endif
501 # ifndef YYFREE
502 # define YYFREE free
503 # if ! defined free && ! defined EXIT_SUCCESS
504 void free (void *); /* INFRINGES ON USER NAME SPACE */
505 # endif
506 # endif
507 # endif
508 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
509
510
511 #if (! defined yyoverflow \
512 && (! defined __cplusplus \
513 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
514 && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
515
516 /* A type that is properly aligned for any stack member. */
517 union yyalloc
518 {
519 yytype_int16 yyss_alloc;
520 YYSTYPE yyvs_alloc;
521 YYLTYPE yyls_alloc;
522 };
523
524 /* The size of the maximum gap between one aligned stack and the next. */
525 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
526
527 /* The size of an array large to enough to hold all stacks, each with
528 N elements. */
529 # define YYSTACK_BYTES(N) \
530 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
531 + 2 * YYSTACK_GAP_MAXIMUM)
532
533 # define YYCOPY_NEEDED 1
534
535 /* Relocate STACK from its old location to the new one. The
536 local variables YYSIZE and YYSTACKSIZE give the old and new number of
537 elements in the stack, and YYPTR gives the new location of the
538 stack. Advance YYPTR to a properly aligned location for the next
539 stack. */
540 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
541 do \
542 { \
543 YYSIZE_T yynewbytes; \
544 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
545 Stack = &yyptr->Stack_alloc; \
546 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
547 yyptr += yynewbytes / sizeof (*yyptr); \
548 } \
549 while (0)
550
551 #endif
552
553 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
554 /* Copy COUNT objects from SRC to DST. The source and destination do
555 not overlap. */
556 # ifndef YYCOPY
557 # if defined __GNUC__ && 1 < __GNUC__
558 # define YYCOPY(Dst, Src, Count) \
559 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
560 # else
561 # define YYCOPY(Dst, Src, Count) \
562 do \
563 { \
564 YYSIZE_T yyi; \
565 for (yyi = 0; yyi < (Count); yyi++) \
566 (Dst)[yyi] = (Src)[yyi]; \
567 } \
568 while (0)
569 # endif
570 # endif
571 #endif /* !YYCOPY_NEEDED */
572
573 /* YYFINAL -- State number of the termination state. */
574 #define YYFINAL 71
575 /* YYLAST -- Last index in YYTABLE. */
576 #define YYLAST 1633
577
578 /* YYNTOKENS -- Number of terminals. */
579 #define YYNTOKENS 86
580 /* YYNNTS -- Number of nonterminals. */
581 #define YYNNTS 64
582 /* YYNRULES -- Number of rules. */
583 #define YYNRULES 307
584 /* YYNSTATES -- Number of states. */
585 #define YYNSTATES 329
586
587 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
588 by yylex, with out-of-bounds checking. */
589 #define YYUNDEFTOK 2
590 #define YYMAXUTOK 325
591
592 #define YYTRANSLATE(YYX) \
593 ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
594
595 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
596 as returned by yylex, without out-of-bounds checking. */
597 static const yytype_uint8 yytranslate[] =
598 {
599 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
600 5, 2, 2, 2, 2, 2, 2, 2, 2, 2,
601 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
602 2, 2, 7, 2, 33, 9, 2, 2, 2, 31,
603 11, 13, 2, 2, 25, 2, 2, 2, 2, 2,
604 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
605 27, 23, 29, 2, 2, 2, 2, 2, 2, 2,
606 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
607 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
608 2, 19, 2, 21, 2, 2, 2, 2, 2, 2,
609 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
610 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
611 2, 2, 2, 15, 2, 17, 2, 2, 2, 2,
612 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
613 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
614 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
615 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
616 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
617 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
618 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
619 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
620 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
621 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
622 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
623 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
624 2, 2, 2, 2, 2, 2, 34, 1, 2, 3,
625 4, 6, 8, 10, 12, 14, 16, 18, 20, 22,
626 24, 26, 28, 30, 32, 35, 36, 37, 38, 39,
627 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
628 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
629 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
630 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
631 80, 81, 82, 83, 84, 85
632 };
633
634 #if YYDEBUG
635 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
636 static const yytype_uint16 yyrline[] =
637 {
638 0, 188, 188, 189, 192, 194, 198, 199, 204, 213,
639 224, 225, 229, 230, 231, 232, 233, 237, 241, 247,
640 248, 249, 250, 251, 252, 253, 254, 255, 256, 257,
641 261, 262, 263, 264, 265, 266, 267, 268, 269, 273,
642 274, 275, 276, 277, 278, 279, 280, 281, 286, 287,
643 288, 289, 290, 291, 292, 293, 299, 301, 302, 308,
644 309, 312, 318, 319, 323, 329, 333, 342, 343, 344,
645 348, 357, 367, 381, 390, 396, 405, 411, 420, 432,
646 438, 450, 456, 471, 480, 483, 489, 490, 494, 503,
647 506, 512, 513, 514, 515, 516, 517, 518, 519, 520,
648 521, 522, 523, 524, 525, 526, 530, 539, 542, 548,
649 549, 550, 551, 552, 553, 554, 555, 556, 557, 558,
650 559, 560, 561, 565, 574, 577, 580, 586, 595, 598,
651 601, 607, 616, 619, 622, 625, 628, 631, 634, 637,
652 640, 643, 646, 649, 652, 655, 658, 661, 662, 663,
653 672, 675, 689, 692, 698, 699, 700, 704, 705, 706,
654 707, 708, 712, 713, 714, 715, 716, 717, 718, 719,
655 720, 724, 728, 744, 751, 754, 757, 760, 761, 764,
656 767, 770, 773, 776, 779, 782, 785, 788, 789, 792,
657 798, 801, 805, 809, 815, 819, 823, 826, 836, 837,
658 838, 839, 840, 841, 842, 843, 844, 845, 846, 847,
659 848, 849, 850, 851, 855, 856, 857, 858, 859, 860,
660 861, 862, 863, 864, 865, 866, 867, 868, 869, 878,
661 879, 880, 884, 885, 886, 887, 888, 889, 890, 891,
662 892, 893, 894, 895, 896, 900, 901, 902, 903, 904,
663 905, 906, 907, 908, 909, 910, 911, 912, 913, 914,
664 915, 916, 920, 921, 922, 923, 924, 925, 926, 927,
665 928, 932, 933, 934, 935, 936, 937, 938, 939, 940,
666 941, 942, 943, 944, 945, 946, 947, 948, 952, 953,
667 954, 955, 956, 957, 958, 959, 960, 961, 962, 963,
668 964, 965, 966, 967, 968, 969, 973, 976
669 };
670 #endif
671
672 #if YYDEBUG || YYERROR_VERBOSE || 0
673 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
674 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
675 static const char *const yytname[] =
676 {
677 "$end", "error", "$undefined", "END_OF_FILE", "END_OF_LINE", "'\\n'",
678 "SPACE", "' '", "HASH", "'#'", "LEFT_PAREN", "'('", "RIGHT_PAREN", "')'",
679 "LEFT_CURLY", "'{'", "RIGHT_CURLY", "'}'", "LEFT_BRACE", "'['",
680 "RIGHT_BRACE", "']'", "EQUAL", "'='", "COMMA", "','", "LOWER", "'<'",
681 "GREATER", "'>'", "SINGLE_QUOTE", "'\\''", "DOUBLE_QUOTE", "'\"'",
682 "COMMENT", "NAME", "VARIABLE", "MACRO", "OPERATOR", "WORD", "JUNK",
683 "START_SPACE_LIST", "DNL", "M4_INCLUDE", "AC_MACRO_WITH_ARG",
684 "AC_MACRO_WITHOUT_ARG", "AC_ARG_ENABLE", "AC_C_CONST", "AC_CHECK_FUNCS",
685 "AC_CHECK_HEADERS", "AC_CHECK_LIB", "AC_CHECK_PROG", "AC_CONFIG_FILES",
686 "AC_CONFIG_HEADERS", "AC_CONFIG_MACRO_DIR", "AC_CONFIG_SRCDIR",
687 "AC_EGREP_HEADER", "AC_EXEEXT", "AC_HEADER_STDC", "AC_INIT", "AC_OBJEXT",
688 "AC_OUTPUT", "OBSOLETE_AC_OUTPUT", "AC_PREREQ", "AC_PROG_CC",
689 "AC_PROG_CPP", "AC_PROG_CXX", "IT_PROG_INTLTOOL", "AC_PROG_LEX",
690 "AC_PROG_RANLIB", "AC_PROG_YACC", "AC_SUBST", "AC_TYPE_SIZE_T",
691 "AC_TYPE_OFF_T", "AM_INIT_AUTOMAKE", "AM_GLIB_GNU_GETTEXT",
692 "AM_MAINTAINER_MODE", "AM_PROG_LIBTOOL", "AC_PROG_LIBTOOL", "LT_INIT",
693 "DEFAULT_LT_INIT", "LT_PREREQ", "PKG_CHECK_MODULES",
694 "PKG_PROG_PKG_CONFIG", "EMPTY", "ARG", "$accept", "input", "file",
695 "line", "definition", "statement", "other_statement", "value",
696 "value_token", "no_name_token", "no_equal_token", "macro", "space_list",
697 "space_list_body", "item", "operator", "name", "end_statement", "dnl",
698 "include", "pkg_check_modules", "ac_macro_with_arg",
699 "ac_macro_without_arg", "ac_subst", "ac_output", "obsolete_ac_output",
700 "ac_config_files", "arg_list", "arg_list_body", "comment",
701 "not_eol_list", "shell_string", "single_string", "single_string_body",
702 "not_single_token", "double_string", "double_string_body",
703 "not_double_token", "m4_string", "m4_string_body", "raw_string",
704 "raw_string_body", "arg_string", "arg_string_body", "arg", "arg_body",
705 "arg_part_or_space", "arg_part", "arg_token", "separator", "expression",
706 "expression_body", "optional_spaces", "spaces", "spaces_with_eol",
707 "not_eol_token", "not_brace_token", "args_token", "not_operator_token",
708 "word_token", "any_macro", "ac_macro_without_arg_token",
709 "ac_macro_with_arg_token", "end_of_line", YY_NULLPTR
710 };
711 #endif
712
713 # ifdef YYPRINT
714 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
715 (internal) symbol number NUM (which must be that of a token). */
716 static const yytype_uint16 yytoknum[] =
717 {
718 0, 257, 258, 259, 260, 10, 261, 32, 262, 35,
719 263, 40, 264, 41, 265, 123, 266, 125, 267, 91,
720 268, 93, 269, 61, 270, 44, 271, 60, 272, 62,
721 273, 39, 274, 34, 256, 275, 276, 277, 278, 279,
722 280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
723 290, 291, 292, 293, 294, 295, 296, 297, 298, 299,
724 300, 301, 302, 303, 304, 305, 306, 307, 308, 309,
725 310, 311, 312, 313, 314, 315, 316, 317, 318, 319,
726 320, 321, 322, 323, 324, 325
727 };
728 # endif
729
730 #define YYPACT_NINF -288
731
732 #define yypact_value_is_default(Yystate) \
733 (!!((Yystate) == (-288)))
734
735 #define YYTABLE_NINF -3
736
737 #define yytable_value_is_error(Yytable_value) \
738 0
739
740 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
741 STATE-NUM. */
742 static const yytype_int16 yypact[] =
743 {
744 -34, 846, 32, 23, -288, -288, -288, -288, -288, -288,
745 -288, -288, -288, -288, -288, -288, -288, -288, -288, 1086,
746 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
747 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
748 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
749 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
750 -288, 22, -288, -288, 1400, -288, 926, -288, -288, -288,
751 -288, -288, -288, -288, 366, 21, -288, -288, -288, -288,
752 -288, -288, -288, -288, -288, -288, -288, -288, 1086, -288,
753 -288, 1086, 1086, 1086, -288, -288, -288, -288, -288, -288,
754 -288, -288, -288, -288, -288, -3, -288, -288, -288, -288,
755 -288, 1166, -288, 1086, 926, -288, -288, -288, -288, -288,
756 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
757 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
758 -288, -288, -288, -288, -288, -288, -288, -288, 29, -288,
759 -288, -288, 8, -288, 1324, -288, -288, -288, -288, -288,
760 -288, -288, -288, -288, -288, -288, 1006, 606, 285, -288,
761 -288, -288, -288, -288, 22, 1476, 1246, 1, -288, -288,
762 285, 446, 686, 766, 1550, -288, -288, -288, -288, -288,
763 -288, -288, -288, 1324, -288, -288, -288, -288, -288, -288,
764 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
765 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
766 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
767 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
768 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
769 -288, -288, 27, -288, -288, -288, -288, -288, -288, -288,
770 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
771 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
772 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
773 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
774 -288, -288, -288, -288, -288, -288, -288, -288, -288, -288,
775 -288, 1324, -288, -288, -288, -288, -288, 1324, -288, -288,
776 -288, -288, -288, 526, 1324, 1324, -288, -288, -288
777 };
778
779 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
780 Performed when YYTABLE does not specify something else to do. Zero
781 means the default is an error. */
782 static const yytype_uint16 yydefact[] =
783 {
784 4, 56, 0, 190, 195, 194, 232, 235, 236, 233,
785 234, 237, 241, 242, 238, 239, 64, 240, 264, 150,
786 288, 271, 289, 272, 290, 291, 292, 293, 262, 294,
787 295, 296, 297, 273, 274, 267, 275, 263, 265, 298,
788 276, 277, 278, 300, 279, 280, 281, 268, 282, 283,
789 301, 302, 284, 285, 286, 303, 287, 304, 266, 305,
790 3, 57, 59, 63, 62, 244, 0, 65, 243, 270,
791 269, 1, 192, 5, 0, 191, 162, 174, 132, 163,
792 164, 165, 169, 170, 166, 167, 168, 84, 150, 299,
793 76, 150, 150, 150, 159, 160, 48, 52, 49, 50,
794 51, 54, 53, 55, 71, 0, 157, 81, 152, 161,
795 158, 150, 74, 150, 58, 245, 248, 249, 246, 247,
796 252, 250, 253, 254, 258, 259, 255, 256, 251, 257,
797 261, 66, 260, 197, 196, 60, 307, 306, 84, 229,
798 230, 124, 34, 231, 35, 36, 89, 107, 190, 37,
799 38, 10, 0, 11, 12, 33, 6, 67, 68, 31,
800 86, 87, 30, 32, 69, 193, 0, 0, 0, 78,
801 77, 75, 72, 79, 171, 150, 151, 0, 73, 61,
802 0, 0, 0, 0, 14, 7, 29, 23, 24, 25,
803 26, 27, 28, 13, 17, 22, 20, 19, 21, 176,
804 175, 173, 179, 178, 180, 181, 185, 186, 182, 183,
805 184, 187, 177, 189, 188, 134, 133, 135, 136, 137,
806 128, 131, 139, 138, 141, 140, 145, 146, 142, 143,
807 144, 147, 148, 149, 198, 200, 212, 213, 202, 203,
808 204, 208, 209, 205, 206, 201, 207, 211, 85, 199,
809 210, 70, 172, 82, 155, 154, 153, 156, 80, 83,
810 215, 214, 217, 123, 218, 219, 220, 225, 226, 222,
811 223, 221, 224, 228, 126, 125, 216, 227, 103, 101,
812 102, 105, 95, 96, 97, 88, 104, 98, 99, 100,
813 93, 94, 90, 91, 92, 121, 119, 120, 113, 114,
814 115, 122, 106, 116, 117, 118, 111, 112, 108, 109,
815 110, 9, 43, 44, 45, 46, 47, 15, 42, 40,
816 39, 41, 18, 0, 8, 16, 127, 130, 129
817 };
818
819 /* YYPGOTO[NTERM-NUM]. */
820 static const yytype_int16 yypgoto[] =
821 {
822 -288, -288, -288, -288, -288, -288, -288, -287, -188, -288,
823 -288, -72, -288, -288, -58, -288, -288, -116, -21, 5,
824 -288, -288, -288, -288, -288, -288, -288, -74, -73, -129,
825 -98, -64, -288, -288, -288, -288, -288, -288, -59, -288,
826 -282, -288, -124, -288, -132, -288, -288, -131, -288, -288,
827 -122, -288, -102, -288, 3, -288, -276, -54, -288, -288,
828 -63, -1, 2, -146
829 };
830
831 /* YYDEFGOTO[NTERM-NUM]. */
832 static const yytype_int16 yydefgoto[] =
833 {
834 -1, 2, 3, 73, 151, 152, 153, 193, 194, 154,
835 317, 94, 60, 61, 62, 63, 64, 156, 95, 96,
836 97, 98, 99, 100, 101, 102, 103, 104, 105, 158,
837 168, 196, 160, 182, 292, 161, 183, 308, 197, 181,
838 233, 323, 106, 167, 107, 176, 256, 108, 109, 175,
839 110, 166, 74, 75, 111, 248, 275, 198, 67, 131,
840 68, 112, 113, 164
841 };
842
843 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
844 positive, shift that token. If negative, reduce the rule whose
845 number is the opposite. If YYTABLE_NINF, syntax error. */
846 static const yytype_int16 yytable[] =
847 {
848 69, 132, 155, 70, 66, 322, 65, 1, 135, 173,
849 159, 136, 137, 258, 169, 162, 138, 170, 171, 172,
850 163, 174, 251, -2, 324, 174, 4, 165, 5, 72,
851 325, 133, 71, 134, 259, 72, 185, 212, 177, 178,
852 180, 327, 213, 253, 214, 257, 184, 328, 0, 0,
853 87, 0, 0, 157, 0, 0, 179, 0, 0, 0,
854 0, 0, 0, 69, 114, 69, 70, 0, 70, 130,
855 0, 65, 0, 0, 0, 0, 0, 0, 0, 0,
856 0, 0, 195, 0, 0, 0, 0, 0, 0, 0,
857 0, 0, 0, 0, 211, 231, 0, 0, 0, 0,
858 0, 0, 0, 0, 0, 250, 0, 0, 0, 0,
859 290, 306, 318, 69, 249, 0, 70, 250, 277, 65,
860 319, 195, 274, 293, 309, 320, 249, 276, 294, 310,
861 321, 157, 0, 0, 0, 0, 322, 322, 0, 0,
862 0, 0, 0, 0, 0, 0, 232, 0, 0, 0,
863 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
864 0, 291, 307, 0, 0, 0, 0, 69, 0, 0,
865 70, 0, 0, 0, 0, 0, 0, 252, 0, 69,
866 69, 0, 70, 70, 0, 0, 0, 0, 0, 0,
867 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
868 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
869 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
870 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
871 0, 0, 0, 0, 0, 0, 0, 0, 0, 195,
872 0, 0, 0, 0, 0, 195, 0, 0, 0, 0,
873 0, 0, 195, 195, 0, 0, 0, 0, 0, 0,
874 277, 0, 0, 0, 0, 0, 0, 0, 0, 276,
875 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
876 0, 0, 0, 0, 0, 0, 0, 0, 136, 137,
877 0, 234, 0, 235, 0, 139, 0, 140, 0, 0,
878 0, 0, 0, 236, 0, 237, 0, 238, 0, 143,
879 0, 239, 0, 240, 0, 241, 0, 242, 0, 0,
880 243, 244, 69, 245, 246, 70, 0, 18, 247, 20,
881 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
882 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
883 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
884 51, 52, 53, 54, 55, 56, 57, 58, 59, 136,
885 137, 0, 0, 0, 138, 0, 139, 0, 140, 0,
886 0, 0, 0, 0, 141, 0, 0, 0, 142, 0,
887 143, 0, 144, 0, 145, 0, 146, 0, 147, 0,
888 0, 148, 149, 0, 0, 150, 0, 0, 87, 19,
889 20, 21, 22, 23, 24, 25, 26, 27, 88, 29,
890 30, 31, 32, 33, 34, 89, 36, 90, 91, 39,
891 40, 41, 42, 43, 44, 45, 46, 92, 48, 49,
892 50, 51, 52, 53, 54, 55, 56, 57, 93, 59,
893 260, 0, 261, 0, 262, 0, 139, 0, 140, 0,
894 0, 0, 0, 0, 141, 0, 263, 0, 264, 0,
895 143, 0, 265, 0, 266, 0, 267, 0, 268, 0,
896 0, 269, 270, 0, 271, 272, 0, 0, 18, 273,
897 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
898 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
899 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
900 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
901 260, 0, 261, 0, 262, 0, 139, 0, 140, 0,
902 0, 0, 0, 0, 220, 0, 326, 0, 264, 0,
903 143, 0, 265, 0, 266, 0, 267, 0, 268, 0,
904 0, 269, 270, 0, 271, 272, 0, 0, 18, 273,
905 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
906 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
907 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
908 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
909 215, 0, 216, 0, 217, 0, 218, 0, 219, 0,
910 0, 0, 0, 0, 220, 0, 221, 0, 222, 0,
911 223, 0, 224, 0, 225, 0, 226, 0, 227, 0,
912 0, 228, 229, 0, 0, 230, 0, 0, 87, 19,
913 20, 21, 22, 23, 24, 25, 26, 27, 88, 29,
914 30, 31, 32, 33, 34, 89, 36, 90, 91, 39,
915 40, 41, 42, 43, 44, 45, 46, 92, 48, 49,
916 50, 51, 52, 53, 54, 55, 56, 57, 93, 59,
917 278, 0, 279, 0, 280, 0, 139, 0, 140, 0,
918 0, 0, 0, 0, 141, 0, 281, 0, 282, 0,
919 143, 0, 283, 0, 284, 0, 285, 0, 286, 0,
920 0, 287, 288, 0, 0, 289, 0, 0, 87, 19,
921 20, 21, 22, 23, 24, 25, 26, 27, 88, 29,
922 30, 31, 32, 33, 34, 89, 36, 90, 91, 39,
923 40, 41, 42, 43, 44, 45, 46, 92, 48, 49,
924 50, 51, 52, 53, 54, 55, 56, 57, 93, 59,
925 295, 0, 296, 0, 297, 0, 139, 0, 140, 0,
926 0, 0, 0, 0, 141, 0, 0, 0, 298, 0,
927 143, 0, 299, 0, 300, 0, 301, 0, 302, 0,
928 0, 303, 304, 0, 0, 305, 0, 0, 87, 19,
929 20, 21, 22, 23, 24, 25, 26, 27, 88, 29,
930 30, 31, 32, 33, 34, 89, 36, 90, 91, 39,
931 40, 41, 42, 43, 44, 45, 46, 92, 48, 49,
932 50, 51, 52, 53, 54, 55, 56, 57, 93, 59,
933 4, 0, 5, 0, 6, 0, 7, 0, 8, 0,
934 0, 0, 0, 0, 9, 0, 10, 0, 0, 0,
935 11, 0, 0, 0, 0, 0, 12, 0, 13, 0,
936 0, 14, 15, 0, 16, 17, 0, 0, 18, 19,
937 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
938 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
939 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
940 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
941 133, 0, 134, 0, 6, 0, 7, 0, 8, 0,
942 0, 0, 0, 0, 9, 0, 10, 0, 0, 0,
943 11, 0, 0, 0, 0, 0, 12, 0, 13, 0,
944 0, 14, 15, 0, 16, 17, 0, 0, 18, 19,
945 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
946 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
947 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
948 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
949 199, 0, 200, 0, 138, 0, 77, 0, 201, 0,
950 0, 0, 0, 0, 78, 0, 0, 0, 202, 0,
951 203, 0, 204, 0, 205, 0, 206, 0, 207, 0,
952 0, 208, 209, 0, 0, 210, 0, 0, 0, 19,
953 20, 21, 22, 23, 24, 25, 26, 27, 88, 29,
954 30, 31, 32, 33, 34, 89, 36, 90, 91, 39,
955 40, 41, 42, 43, 44, 45, 46, 92, 48, 49,
956 50, 51, 52, 53, 54, 55, 56, 57, 93, 59,
957 4, 0, 5, 0, 76, 0, 77, 0, 0, 0,
958 0, 0, 0, 0, 78, 0, 0, 0, 79, 0,
959 0, 0, 80, 0, 81, 0, 82, 0, 83, 0,
960 0, 84, 85, 0, 0, 86, 0, 0, 87, 19,
961 20, 21, 22, 23, 24, 25, 26, 27, 88, 29,
962 30, 31, 32, 33, 34, 89, 36, 90, 91, 39,
963 40, 41, 42, 43, 44, 45, 46, 92, 48, 49,
964 50, 51, 52, 53, 54, 55, 56, 57, 93, 59,
965 133, 0, 134, 0, 76, 0, 77, 0, 0, 0,
966 0, 0, 0, 0, 78, 0, 0, 0, 79, 0,
967 0, 0, 80, 0, 81, 0, 82, 0, 83, 0,
968 0, 84, 85, 0, 0, 86, 0, 0, 87, 19,
969 20, 21, 22, 23, 24, 25, 26, 27, 88, 29,
970 30, 31, 32, 33, 34, 89, 36, 90, 91, 39,
971 40, 41, 42, 43, 44, 45, 46, 92, 48, 49,
972 50, 51, 52, 53, 54, 55, 56, 57, 93, 59,
973 254, 0, 255, 0, 76, 0, 77, 0, 0, 0,
974 0, 0, 0, 0, 78, 0, 0, 0, 79, 0,
975 0, 0, 80, 0, 81, 0, 82, 0, 83, 0,
976 0, 84, 85, 0, 0, 86, 0, 0, 87, 19,
977 20, 21, 22, 23, 24, 25, 26, 27, 88, 29,
978 30, 31, 32, 33, 34, 89, 36, 90, 91, 39,
979 40, 41, 42, 43, 44, 45, 46, 92, 48, 49,
980 50, 51, 52, 53, 54, 55, 56, 57, 93, 59,
981 186, 0, 0, 0, 139, 0, 140, 0, 0, 0,
982 0, 0, 141, 0, 0, 0, 187, 0, 143, 0,
983 188, 0, 189, 0, 146, 0, 147, 0, 0, 190,
984 191, 0, 0, 192, 0, 0, 0, 19, 20, 21,
985 22, 23, 24, 25, 26, 27, 88, 29, 30, 31,
986 32, 33, 34, 89, 36, 90, 91, 39, 40, 41,
987 42, 43, 44, 45, 46, 92, 48, 49, 50, 51,
988 52, 53, 54, 55, 56, 57, 93, 59, 115, 0,
989 116, 0, 117, 0, 0, 0, 0, 0, 118, 0,
990 119, 0, 120, 0, 121, 0, 122, 0, 123, 0,
991 124, 0, 125, 0, 0, 126, 127, 0, 128, 129,
992 0, 0, 18, 19, 20, 21, 22, 23, 24, 25,
993 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
994 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
995 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
996 56, 57, 58, 59, 76, 0, 77, 0, 0, 0,
997 0, 0, 0, 0, 78, 0, 0, 0, 79, 0,
998 0, 0, 80, 0, 81, 0, 82, 0, 83, 0,
999 0, 84, 85, 0, 0, 86, 0, 0, 87, 19,
1000 20, 21, 22, 23, 24, 25, 26, 27, 88, 29,
1001 30, 31, 32, 33, 34, 89, 36, 90, 91, 39,
1002 40, 41, 42, 43, 44, 45, 46, 92, 48, 49,
1003 50, 51, 52, 53, 54, 55, 56, 57, 93, 59,
1004 139, 0, 140, 0, 0, 0, 0, 0, 141, 0,
1005 0, 0, 311, 0, 143, 0, 312, 0, 313, 0,
1006 146, 0, 147, 0, 0, 314, 315, 0, 0, 316,
1007 0, 0, 0, 19, 20, 21, 22, 23, 24, 25,
1008 26, 27, 88, 29, 30, 31, 32, 33, 34, 89,
1009 36, 90, 91, 39, 40, 41, 42, 43, 44, 45,
1010 46, 92, 48, 49, 50, 51, 52, 53, 54, 55,
1011 56, 57, 93, 59
1012 };
1013
1014 static const yytype_int16 yycheck[] =
1015 {
1016 1, 64, 74, 1, 1, 193, 1, 41, 66, 12,
1017 74, 3, 4, 12, 88, 74, 8, 91, 92, 93,
1018 74, 24, 168, 0, 311, 24, 4, 6, 6, 6,
1019 317, 4, 0, 6, 180, 6, 152, 166, 111, 113,
1020 138, 323, 166, 175, 166, 176, 148, 323, -1, -1,
1021 42, -1, -1, 74, -1, -1, 114, -1, -1, -1,
1022 -1, -1, -1, 64, 61, 66, 64, -1, 66, 64,
1023 -1, 66, -1, -1, -1, -1, -1, -1, -1, -1,
1024 -1, -1, 154, -1, -1, -1, -1, -1, -1, -1,
1025 -1, -1, -1, -1, 166, 167, -1, -1, -1, -1,
1026 -1, -1, -1, -1, -1, 168, -1, -1, -1, -1,
1027 182, 183, 184, 114, 168, -1, 114, 180, 181, 114,
1028 184, 193, 181, 182, 183, 184, 180, 181, 182, 183,
1029 184, 152, -1, -1, -1, -1, 324, 325, -1, -1,
1030 -1, -1, -1, -1, -1, -1, 167, -1, -1, -1,
1031 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1032 -1, 182, 183, -1, -1, -1, -1, 168, -1, -1,
1033 168, -1, -1, -1, -1, -1, -1, 174, -1, 180,
1034 181, -1, 180, 181, -1, -1, -1, -1, -1, -1,
1035 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1036 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1037 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1038 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1039 -1, -1, -1, -1, -1, -1, -1, -1, -1, 311,
1040 -1, -1, -1, -1, -1, 317, -1, -1, -1, -1,
1041 -1, -1, 324, 325, -1, -1, -1, -1, -1, -1,
1042 323, -1, -1, -1, -1, -1, -1, -1, -1, 323,
1043 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1044 -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
1045 -1, 6, -1, 8, -1, 10, -1, 12, -1, -1,
1046 -1, -1, -1, 18, -1, 20, -1, 22, -1, 24,
1047 -1, 26, -1, 28, -1, 30, -1, 32, -1, -1,
1048 35, 36, 323, 38, 39, 323, -1, 42, 43, 44,
1049 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1050 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1051 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1052 75, 76, 77, 78, 79, 80, 81, 82, 83, 3,
1053 4, -1, -1, -1, 8, -1, 10, -1, 12, -1,
1054 -1, -1, -1, -1, 18, -1, -1, -1, 22, -1,
1055 24, -1, 26, -1, 28, -1, 30, -1, 32, -1,
1056 -1, 35, 36, -1, -1, 39, -1, -1, 42, 43,
1057 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1058 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1059 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1060 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1061 4, -1, 6, -1, 8, -1, 10, -1, 12, -1,
1062 -1, -1, -1, -1, 18, -1, 20, -1, 22, -1,
1063 24, -1, 26, -1, 28, -1, 30, -1, 32, -1,
1064 -1, 35, 36, -1, 38, 39, -1, -1, 42, 43,
1065 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1066 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1067 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1068 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1069 4, -1, 6, -1, 8, -1, 10, -1, 12, -1,
1070 -1, -1, -1, -1, 18, -1, 20, -1, 22, -1,
1071 24, -1, 26, -1, 28, -1, 30, -1, 32, -1,
1072 -1, 35, 36, -1, 38, 39, -1, -1, 42, 43,
1073 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1074 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1075 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1076 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1077 4, -1, 6, -1, 8, -1, 10, -1, 12, -1,
1078 -1, -1, -1, -1, 18, -1, 20, -1, 22, -1,
1079 24, -1, 26, -1, 28, -1, 30, -1, 32, -1,
1080 -1, 35, 36, -1, -1, 39, -1, -1, 42, 43,
1081 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1082 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1083 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1084 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1085 4, -1, 6, -1, 8, -1, 10, -1, 12, -1,
1086 -1, -1, -1, -1, 18, -1, 20, -1, 22, -1,
1087 24, -1, 26, -1, 28, -1, 30, -1, 32, -1,
1088 -1, 35, 36, -1, -1, 39, -1, -1, 42, 43,
1089 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1090 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1091 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1092 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1093 4, -1, 6, -1, 8, -1, 10, -1, 12, -1,
1094 -1, -1, -1, -1, 18, -1, -1, -1, 22, -1,
1095 24, -1, 26, -1, 28, -1, 30, -1, 32, -1,
1096 -1, 35, 36, -1, -1, 39, -1, -1, 42, 43,
1097 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1098 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1099 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1100 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1101 4, -1, 6, -1, 8, -1, 10, -1, 12, -1,
1102 -1, -1, -1, -1, 18, -1, 20, -1, -1, -1,
1103 24, -1, -1, -1, -1, -1, 30, -1, 32, -1,
1104 -1, 35, 36, -1, 38, 39, -1, -1, 42, 43,
1105 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1106 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1107 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1108 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1109 4, -1, 6, -1, 8, -1, 10, -1, 12, -1,
1110 -1, -1, -1, -1, 18, -1, 20, -1, -1, -1,
1111 24, -1, -1, -1, -1, -1, 30, -1, 32, -1,
1112 -1, 35, 36, -1, 38, 39, -1, -1, 42, 43,
1113 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1114 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1115 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1116 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1117 4, -1, 6, -1, 8, -1, 10, -1, 12, -1,
1118 -1, -1, -1, -1, 18, -1, -1, -1, 22, -1,
1119 24, -1, 26, -1, 28, -1, 30, -1, 32, -1,
1120 -1, 35, 36, -1, -1, 39, -1, -1, -1, 43,
1121 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1122 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1123 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1124 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1125 4, -1, 6, -1, 8, -1, 10, -1, -1, -1,
1126 -1, -1, -1, -1, 18, -1, -1, -1, 22, -1,
1127 -1, -1, 26, -1, 28, -1, 30, -1, 32, -1,
1128 -1, 35, 36, -1, -1, 39, -1, -1, 42, 43,
1129 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1130 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1131 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1132 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1133 4, -1, 6, -1, 8, -1, 10, -1, -1, -1,
1134 -1, -1, -1, -1, 18, -1, -1, -1, 22, -1,
1135 -1, -1, 26, -1, 28, -1, 30, -1, 32, -1,
1136 -1, 35, 36, -1, -1, 39, -1, -1, 42, 43,
1137 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1138 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1139 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1140 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1141 4, -1, 6, -1, 8, -1, 10, -1, -1, -1,
1142 -1, -1, -1, -1, 18, -1, -1, -1, 22, -1,
1143 -1, -1, 26, -1, 28, -1, 30, -1, 32, -1,
1144 -1, 35, 36, -1, -1, 39, -1, -1, 42, 43,
1145 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1146 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1147 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1148 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1149 6, -1, -1, -1, 10, -1, 12, -1, -1, -1,
1150 -1, -1, 18, -1, -1, -1, 22, -1, 24, -1,
1151 26, -1, 28, -1, 30, -1, 32, -1, -1, 35,
1152 36, -1, -1, 39, -1, -1, -1, 43, 44, 45,
1153 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1154 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1155 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1156 76, 77, 78, 79, 80, 81, 82, 83, 8, -1,
1157 10, -1, 12, -1, -1, -1, -1, -1, 18, -1,
1158 20, -1, 22, -1, 24, -1, 26, -1, 28, -1,
1159 30, -1, 32, -1, -1, 35, 36, -1, 38, 39,
1160 -1, -1, 42, 43, 44, 45, 46, 47, 48, 49,
1161 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1162 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
1163 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1164 80, 81, 82, 83, 8, -1, 10, -1, -1, -1,
1165 -1, -1, -1, -1, 18, -1, -1, -1, 22, -1,
1166 -1, -1, 26, -1, 28, -1, 30, -1, 32, -1,
1167 -1, 35, 36, -1, -1, 39, -1, -1, 42, 43,
1168 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1169 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1170 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1171 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1172 10, -1, 12, -1, -1, -1, -1, -1, 18, -1,
1173 -1, -1, 22, -1, 24, -1, 26, -1, 28, -1,
1174 30, -1, 32, -1, -1, 35, 36, -1, -1, 39,
1175 -1, -1, -1, 43, 44, 45, 46, 47, 48, 49,
1176 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1177 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
1178 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1179 80, 81, 82, 83
1180 };
1181
1182 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1183 symbol of state STATE-NUM. */
1184 static const yytype_uint8 yystos[] =
1185 {
1186 0, 41, 87, 88, 4, 6, 8, 10, 12, 18,
1187 20, 24, 30, 32, 35, 36, 38, 39, 42, 43,
1188 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1189 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1190 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1191 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1192 98, 99, 100, 101, 102, 105, 140, 144, 146, 147,
1193 148, 0, 6, 89, 138, 139, 8, 10, 18, 22,
1194 26, 28, 30, 32, 35, 36, 39, 42, 52, 59,
1195 61, 62, 71, 82, 97, 104, 105, 106, 107, 108,
1196 109, 110, 111, 112, 113, 114, 128, 130, 133, 134,
1197 136, 140, 147, 148, 140, 8, 10, 12, 18, 20,
1198 22, 24, 26, 28, 30, 32, 35, 36, 38, 39,
1199 105, 145, 146, 4, 6, 100, 3, 4, 8, 10,
1200 12, 18, 22, 24, 26, 28, 30, 32, 35, 36,
1201 39, 90, 91, 92, 95, 97, 103, 104, 115, 117,
1202 118, 121, 124, 143, 149, 6, 137, 129, 116, 113,
1203 113, 113, 113, 12, 24, 135, 131, 114, 113, 100,
1204 116, 125, 119, 122, 138, 103, 6, 22, 26, 28,
1205 35, 36, 39, 93, 94, 97, 117, 124, 143, 4,
1206 6, 12, 22, 24, 26, 28, 30, 32, 35, 36,
1207 39, 97, 115, 128, 136, 4, 6, 8, 10, 12,
1208 18, 20, 22, 24, 26, 28, 30, 32, 35, 36,
1209 39, 97, 104, 126, 6, 8, 18, 20, 22, 26,
1210 28, 30, 32, 35, 36, 38, 39, 43, 141, 143,
1211 146, 149, 140, 130, 4, 6, 132, 133, 12, 149,
1212 4, 6, 8, 20, 22, 26, 28, 30, 32, 35,
1213 36, 38, 39, 43, 124, 142, 143, 146, 4, 6,
1214 8, 20, 22, 26, 28, 30, 32, 35, 36, 39,
1215 97, 104, 120, 124, 143, 4, 6, 8, 22, 26,
1216 28, 30, 32, 35, 36, 39, 97, 104, 123, 124,
1217 143, 22, 26, 28, 35, 36, 39, 96, 97, 117,
1218 124, 143, 94, 127, 93, 93, 20, 126, 142
1219 };
1220
1221 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1222 static const yytype_uint8 yyr1[] =
1223 {
1224 0, 86, 87, 87, 88, 88, 89, 89, 90, 90,
1225 91, 91, 92, 92, 92, 92, 92, 93, 93, 94,
1226 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
1227 95, 95, 95, 95, 95, 95, 95, 95, 95, 96,
1228 96, 96, 96, 96, 96, 96, 96, 96, 97, 97,
1229 97, 97, 97, 97, 97, 97, 98, 98, 98, 99,
1230 99, 99, 100, 100, 101, 102, 102, 103, 103, 103,
1231 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
1232 113, 114, 114, 115, 116, 116, 117, 117, 118, 119,
1233 119, 120, 120, 120, 120, 120, 120, 120, 120, 120,
1234 120, 120, 120, 120, 120, 120, 121, 122, 122, 123,
1235 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
1236 123, 123, 123, 124, 125, 125, 125, 126, 127, 127,
1237 127, 128, 129, 129, 129, 129, 129, 129, 129, 129,
1238 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
1239 130, 130, 131, 131, 132, 132, 132, 133, 133, 133,
1240 133, 133, 134, 134, 134, 134, 134, 134, 134, 134,
1241 134, 135, 135, 136, 137, 137, 137, 137, 137, 137,
1242 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
1243 138, 138, 139, 139, 140, 140, 140, 140, 141, 141,
1244 141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
1245 141, 141, 141, 141, 142, 142, 142, 142, 142, 142,
1246 142, 142, 142, 142, 142, 142, 142, 142, 142, 143,
1247 143, 143, 144, 144, 144, 144, 144, 144, 144, 144,
1248 144, 144, 144, 144, 144, 145, 145, 145, 145, 145,
1249 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
1250 145, 145, 146, 146, 146, 146, 146, 146, 146, 146,
1251 146, 147, 147, 147, 147, 147, 147, 147, 147, 147,
1252 147, 147, 147, 147, 147, 147, 147, 147, 148, 148,
1253 148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
1254 148, 148, 148, 148, 148, 148, 149, 149
1255 };
1256
1257 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1258 static const yytype_uint8 yyr2[] =
1259 {
1260 0, 2, 1, 2, 0, 2, 2, 3, 4, 3,
1261 1, 1, 1, 2, 2, 3, 4, 1, 2, 1,
1262 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1263 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1264 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1265 1, 1, 1, 1, 1, 1, 0, 1, 2, 1,
1266 2, 3, 1, 1, 1, 1, 2, 1, 1, 1,
1267 3, 2, 2, 2, 1, 2, 1, 2, 2, 2,
1268 3, 1, 3, 3, 0, 2, 1, 1, 3, 0,
1269 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1270 1, 1, 1, 1, 1, 1, 3, 0, 2, 1,
1271 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1272 1, 1, 1, 3, 0, 2, 2, 3, 0, 2,
1273 2, 3, 0, 2, 2, 2, 2, 2, 2, 2,
1274 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1275 0, 2, 0, 2, 1, 1, 1, 1, 1, 1,
1276 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1277 1, 1, 2, 3, 0, 2, 2, 2, 2, 2,
1278 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1279 0, 1, 1, 2, 1, 1, 2, 2, 1, 1,
1280 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1281 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1282 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1283 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1284 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1285 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1286 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1287 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1288 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1289 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1290 1, 1, 1, 1, 1, 1, 1, 1
1291 };
1292
1293
1294 #define yyerrok (yyerrstatus = 0)
1295 #define yyclearin (yychar = YYEMPTY)
1296 #define YYEMPTY (-2)
1297 #define YYEOF 0
1298
1299 #define YYACCEPT goto yyacceptlab
1300 #define YYABORT goto yyabortlab
1301 #define YYERROR goto yyerrorlab
1302
1303
1304 #define YYRECOVERING() (!!yyerrstatus)
1305
1306 #define YYBACKUP(Token, Value) \
1307 do \
1308 if (yychar == YYEMPTY) \
1309 { \
1310 yychar = (Token); \
1311 yylval = (Value); \
1312 YYPOPSTACK (yylen); \
1313 yystate = *yyssp; \
1314 goto yybackup; \
1315 } \
1316 else \
1317 { \
1318 yyerror (&yylloc, scanner, YY_("syntax error: cannot back up")); \
1319 YYERROR; \
1320 } \
1321 while (0)
1322
1323 /* Error token number */
1324 #define YYTERROR 1
1325 #define YYERRCODE 256
1326
1327
1328 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1329 If N is 0, then set CURRENT to the empty location which ends
1330 the previous symbol: RHS[0] (always defined). */
1331
1332 #ifndef YYLLOC_DEFAULT
1333 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1334 do \
1335 if (N) \
1336 { \
1337 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1338 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1339 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1340 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1341 } \
1342 else \
1343 { \
1344 (Current).first_line = (Current).last_line = \
1345 YYRHSLOC (Rhs, 0).last_line; \
1346 (Current).first_column = (Current).last_column = \
1347 YYRHSLOC (Rhs, 0).last_column; \
1348 } \
1349 while (0)
1350 #endif
1351
1352 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1353
1354
1355 /* Enable debugging if requested. */
1356 #if YYDEBUG
1357
1358 # ifndef YYFPRINTF
1359 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1360 # define YYFPRINTF fprintf
1361 # endif
1362
1363 # define YYDPRINTF(Args) \
1364 do { \
1365 if (yydebug) \
1366 YYFPRINTF Args; \
1367 } while (0)
1368
1369
1370 /* YY_LOCATION_PRINT -- Print the location on the stream.
1371 This macro was not mandated originally: define only if we know
1372 we won't break user code: when these are the locations we know. */
1373
1374 #ifndef YY_LOCATION_PRINT
1375 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1376
1377 /* Print *YYLOCP on YYO. Private, do not rely on its existence. */
1378
1379 YY_ATTRIBUTE_UNUSED
1380 static unsigned
yy_location_print_(FILE * yyo,YYLTYPE const * const yylocp)1381 yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
1382 {
1383 unsigned res = 0;
1384 int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
1385 if (0 <= yylocp->first_line)
1386 {
1387 res += YYFPRINTF (yyo, "%d", yylocp->first_line);
1388 if (0 <= yylocp->first_column)
1389 res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
1390 }
1391 if (0 <= yylocp->last_line)
1392 {
1393 if (yylocp->first_line < yylocp->last_line)
1394 {
1395 res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
1396 if (0 <= end_col)
1397 res += YYFPRINTF (yyo, ".%d", end_col);
1398 }
1399 else if (0 <= end_col && yylocp->first_column < end_col)
1400 res += YYFPRINTF (yyo, "-%d", end_col);
1401 }
1402 return res;
1403 }
1404
1405 # define YY_LOCATION_PRINT(File, Loc) \
1406 yy_location_print_ (File, &(Loc))
1407
1408 # else
1409 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1410 # endif
1411 #endif
1412
1413
1414 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1415 do { \
1416 if (yydebug) \
1417 { \
1418 YYFPRINTF (stderr, "%s ", Title); \
1419 yy_symbol_print (stderr, \
1420 Type, Value, Location, scanner); \
1421 YYFPRINTF (stderr, "\n"); \
1422 } \
1423 } while (0)
1424
1425
1426 /*----------------------------------------.
1427 | Print this symbol's value on YYOUTPUT. |
1428 `----------------------------------------*/
1429
1430 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,YYLTYPE const * const yylocationp,AmpAcScanner * scanner)1431 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, AmpAcScanner* scanner)
1432 {
1433 FILE *yyo = yyoutput;
1434 YYUSE (yyo);
1435 YYUSE (yylocationp);
1436 YYUSE (scanner);
1437 if (!yyvaluep)
1438 return;
1439 # ifdef YYPRINT
1440 if (yytype < YYNTOKENS)
1441 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1442 # endif
1443 YYUSE (yytype);
1444 }
1445
1446
1447 /*--------------------------------.
1448 | Print this symbol on YYOUTPUT. |
1449 `--------------------------------*/
1450
1451 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,YYLTYPE const * const yylocationp,AmpAcScanner * scanner)1452 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, AmpAcScanner* scanner)
1453 {
1454 YYFPRINTF (yyoutput, "%s %s (",
1455 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1456
1457 YY_LOCATION_PRINT (yyoutput, *yylocationp);
1458 YYFPRINTF (yyoutput, ": ");
1459 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, scanner);
1460 YYFPRINTF (yyoutput, ")");
1461 }
1462
1463 /*------------------------------------------------------------------.
1464 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1465 | TOP (included). |
1466 `------------------------------------------------------------------*/
1467
1468 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)1469 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1470 {
1471 YYFPRINTF (stderr, "Stack now");
1472 for (; yybottom <= yytop; yybottom++)
1473 {
1474 int yybot = *yybottom;
1475 YYFPRINTF (stderr, " %d", yybot);
1476 }
1477 YYFPRINTF (stderr, "\n");
1478 }
1479
1480 # define YY_STACK_PRINT(Bottom, Top) \
1481 do { \
1482 if (yydebug) \
1483 yy_stack_print ((Bottom), (Top)); \
1484 } while (0)
1485
1486
1487 /*------------------------------------------------.
1488 | Report that the YYRULE is going to be reduced. |
1489 `------------------------------------------------*/
1490
1491 static void
yy_reduce_print(yytype_int16 * yyssp,YYSTYPE * yyvsp,YYLTYPE * yylsp,int yyrule,AmpAcScanner * scanner)1492 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, AmpAcScanner* scanner)
1493 {
1494 unsigned long yylno = yyrline[yyrule];
1495 int yynrhs = yyr2[yyrule];
1496 int yyi;
1497 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1498 yyrule - 1, yylno);
1499 /* The symbols being reduced. */
1500 for (yyi = 0; yyi < yynrhs; yyi++)
1501 {
1502 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1503 yy_symbol_print (stderr,
1504 yystos[yyssp[yyi + 1 - yynrhs]],
1505 &(yyvsp[(yyi + 1) - (yynrhs)])
1506 , &(yylsp[(yyi + 1) - (yynrhs)]) , scanner);
1507 YYFPRINTF (stderr, "\n");
1508 }
1509 }
1510
1511 # define YY_REDUCE_PRINT(Rule) \
1512 do { \
1513 if (yydebug) \
1514 yy_reduce_print (yyssp, yyvsp, yylsp, Rule, scanner); \
1515 } while (0)
1516
1517 /* Nonzero means print parse trace. It is left uninitialized so that
1518 multiple parsers can coexist. */
1519 int yydebug;
1520 #else /* !YYDEBUG */
1521 # define YYDPRINTF(Args)
1522 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1523 # define YY_STACK_PRINT(Bottom, Top)
1524 # define YY_REDUCE_PRINT(Rule)
1525 #endif /* !YYDEBUG */
1526
1527
1528 /* YYINITDEPTH -- initial size of the parser's stacks. */
1529 #ifndef YYINITDEPTH
1530 # define YYINITDEPTH 200
1531 #endif
1532
1533 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1534 if the built-in stack extension method is used).
1535
1536 Do not make this value too large; the results are undefined if
1537 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1538 evaluated with infinite-precision integer arithmetic. */
1539
1540 #ifndef YYMAXDEPTH
1541 # define YYMAXDEPTH 10000
1542 #endif
1543
1544
1545 #if YYERROR_VERBOSE
1546
1547 # ifndef yystrlen
1548 # if defined __GLIBC__ && defined _STRING_H
1549 # define yystrlen strlen
1550 # else
1551 /* Return the length of YYSTR. */
1552 static YYSIZE_T
yystrlen(const char * yystr)1553 yystrlen (const char *yystr)
1554 {
1555 YYSIZE_T yylen;
1556 for (yylen = 0; yystr[yylen]; yylen++)
1557 continue;
1558 return yylen;
1559 }
1560 # endif
1561 # endif
1562
1563 # ifndef yystpcpy
1564 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1565 # define yystpcpy stpcpy
1566 # else
1567 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1568 YYDEST. */
1569 static char *
yystpcpy(char * yydest,const char * yysrc)1570 yystpcpy (char *yydest, const char *yysrc)
1571 {
1572 char *yyd = yydest;
1573 const char *yys = yysrc;
1574
1575 while ((*yyd++ = *yys++) != '\0')
1576 continue;
1577
1578 return yyd - 1;
1579 }
1580 # endif
1581 # endif
1582
1583 # ifndef yytnamerr
1584 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1585 quotes and backslashes, so that it's suitable for yyerror. The
1586 heuristic is that double-quoting is unnecessary unless the string
1587 contains an apostrophe, a comma, or backslash (other than
1588 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1589 null, do not copy; instead, return the length of what the result
1590 would have been. */
1591 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)1592 yytnamerr (char *yyres, const char *yystr)
1593 {
1594 if (*yystr == '"')
1595 {
1596 YYSIZE_T yyn = 0;
1597 char const *yyp = yystr;
1598
1599 for (;;)
1600 switch (*++yyp)
1601 {
1602 case '\'':
1603 case ',':
1604 goto do_not_strip_quotes;
1605
1606 case '\\':
1607 if (*++yyp != '\\')
1608 goto do_not_strip_quotes;
1609 /* Fall through. */
1610 default:
1611 if (yyres)
1612 yyres[yyn] = *yyp;
1613 yyn++;
1614 break;
1615
1616 case '"':
1617 if (yyres)
1618 yyres[yyn] = '\0';
1619 return yyn;
1620 }
1621 do_not_strip_quotes: ;
1622 }
1623
1624 if (! yyres)
1625 return yystrlen (yystr);
1626
1627 return yystpcpy (yyres, yystr) - yyres;
1628 }
1629 # endif
1630
1631 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1632 about the unexpected token YYTOKEN for the state stack whose top is
1633 YYSSP.
1634
1635 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1636 not large enough to hold the message. In that case, also set
1637 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1638 required number of bytes is too large to store. */
1639 static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)1640 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1641 yytype_int16 *yyssp, int yytoken)
1642 {
1643 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1644 YYSIZE_T yysize = yysize0;
1645 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1646 /* Internationalized format string. */
1647 const char *yyformat = YY_NULLPTR;
1648 /* Arguments of yyformat. */
1649 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1650 /* Number of reported tokens (one for the "unexpected", one per
1651 "expected"). */
1652 int yycount = 0;
1653
1654 /* There are many possibilities here to consider:
1655 - If this state is a consistent state with a default action, then
1656 the only way this function was invoked is if the default action
1657 is an error action. In that case, don't check for expected
1658 tokens because there are none.
1659 - The only way there can be no lookahead present (in yychar) is if
1660 this state is a consistent state with a default action. Thus,
1661 detecting the absence of a lookahead is sufficient to determine
1662 that there is no unexpected or expected token to report. In that
1663 case, just report a simple "syntax error".
1664 - Don't assume there isn't a lookahead just because this state is a
1665 consistent state with a default action. There might have been a
1666 previous inconsistent state, consistent state with a non-default
1667 action, or user semantic action that manipulated yychar.
1668 - Of course, the expected token list depends on states to have
1669 correct lookahead information, and it depends on the parser not
1670 to perform extra reductions after fetching a lookahead from the
1671 scanner and before detecting a syntax error. Thus, state merging
1672 (from LALR or IELR) and default reductions corrupt the expected
1673 token list. However, the list is correct for canonical LR with
1674 one exception: it will still contain any token that will not be
1675 accepted due to an error action in a later state.
1676 */
1677 if (yytoken != YYEMPTY)
1678 {
1679 int yyn = yypact[*yyssp];
1680 yyarg[yycount++] = yytname[yytoken];
1681 if (!yypact_value_is_default (yyn))
1682 {
1683 /* Start YYX at -YYN if negative to avoid negative indexes in
1684 YYCHECK. In other words, skip the first -YYN actions for
1685 this state because they are default actions. */
1686 int yyxbegin = yyn < 0 ? -yyn : 0;
1687 /* Stay within bounds of both yycheck and yytname. */
1688 int yychecklim = YYLAST - yyn + 1;
1689 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1690 int yyx;
1691
1692 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1693 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1694 && !yytable_value_is_error (yytable[yyx + yyn]))
1695 {
1696 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1697 {
1698 yycount = 1;
1699 yysize = yysize0;
1700 break;
1701 }
1702 yyarg[yycount++] = yytname[yyx];
1703 {
1704 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1705 if (! (yysize <= yysize1
1706 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1707 return 2;
1708 yysize = yysize1;
1709 }
1710 }
1711 }
1712 }
1713
1714 switch (yycount)
1715 {
1716 # define YYCASE_(N, S) \
1717 case N: \
1718 yyformat = S; \
1719 break
1720 default: /* Avoid compiler warnings. */
1721 YYCASE_(0, YY_("syntax error"));
1722 YYCASE_(1, YY_("syntax error, unexpected %s"));
1723 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1724 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1725 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1726 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1727 # undef YYCASE_
1728 }
1729
1730 {
1731 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1732 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1733 return 2;
1734 yysize = yysize1;
1735 }
1736
1737 if (*yymsg_alloc < yysize)
1738 {
1739 *yymsg_alloc = 2 * yysize;
1740 if (! (yysize <= *yymsg_alloc
1741 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1742 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1743 return 1;
1744 }
1745
1746 /* Avoid sprintf, as that infringes on the user's name space.
1747 Don't have undefined behavior even if the translation
1748 produced a string with the wrong number of "%s"s. */
1749 {
1750 char *yyp = *yymsg;
1751 int yyi = 0;
1752 while ((*yyp = *yyformat) != '\0')
1753 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1754 {
1755 yyp += yytnamerr (yyp, yyarg[yyi++]);
1756 yyformat += 2;
1757 }
1758 else
1759 {
1760 yyp++;
1761 yyformat++;
1762 }
1763 }
1764 return 0;
1765 }
1766 #endif /* YYERROR_VERBOSE */
1767
1768 /*-----------------------------------------------.
1769 | Release the memory associated to this symbol. |
1770 `-----------------------------------------------*/
1771
1772 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep,YYLTYPE * yylocationp,AmpAcScanner * scanner)1773 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, AmpAcScanner* scanner)
1774 {
1775 YYUSE (yyvaluep);
1776 YYUSE (yylocationp);
1777 YYUSE (scanner);
1778 if (!yymsg)
1779 yymsg = "Deleting";
1780 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1781
1782 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1783 YYUSE (yytype);
1784 YY_IGNORE_MAYBE_UNINITIALIZED_END
1785 }
1786
1787
1788
1789 struct yypstate
1790 {
1791 /* Number of syntax errors so far. */
1792 int yynerrs;
1793
1794 int yystate;
1795 /* Number of tokens to shift before error messages enabled. */
1796 int yyerrstatus;
1797
1798 /* The stacks and their tools:
1799 'yyss': related to states.
1800 'yyvs': related to semantic values.
1801 'yyls': related to locations.
1802
1803 Refer to the stacks through separate pointers, to allow yyoverflow
1804 to reallocate them elsewhere. */
1805
1806 /* The state stack. */
1807 yytype_int16 yyssa[YYINITDEPTH];
1808 yytype_int16 *yyss;
1809 yytype_int16 *yyssp;
1810
1811 /* The semantic value stack. */
1812 YYSTYPE yyvsa[YYINITDEPTH];
1813 YYSTYPE *yyvs;
1814 YYSTYPE *yyvsp;
1815
1816 /* The location stack. */
1817 YYLTYPE yylsa[YYINITDEPTH];
1818 YYLTYPE *yyls;
1819 YYLTYPE *yylsp;
1820
1821 /* The locations where the error started and ended. */
1822 YYLTYPE yyerror_range[3];
1823
1824 YYSIZE_T yystacksize;
1825 /* Used to determine if this is the first time this instance has
1826 been used. */
1827 int yynew;
1828 };
1829
1830 /* Initialize the parser data structure. */
1831 yypstate *
yypstate_new(void)1832 yypstate_new (void)
1833 {
1834 yypstate *yyps;
1835 yyps = (yypstate *) malloc (sizeof *yyps);
1836 if (!yyps)
1837 return YY_NULLPTR;
1838 yyps->yynew = 1;
1839 return yyps;
1840 }
1841
1842 void
yypstate_delete(yypstate * yyps)1843 yypstate_delete (yypstate *yyps)
1844 {
1845 if (yyps)
1846 {
1847 #ifndef yyoverflow
1848 /* If the stack was reallocated but the parse did not complete, then the
1849 stack still needs to be freed. */
1850 if (!yyps->yynew && yyps->yyss != yyps->yyssa)
1851 YYSTACK_FREE (yyps->yyss);
1852 #endif
1853 free (yyps);
1854 }
1855 }
1856
1857 #define amp_ac_yynerrs yyps->amp_ac_yynerrs
1858 #define yystate yyps->yystate
1859 #define yyerrstatus yyps->yyerrstatus
1860 #define yyssa yyps->yyssa
1861 #define yyss yyps->yyss
1862 #define yyssp yyps->yyssp
1863 #define yyvsa yyps->yyvsa
1864 #define yyvs yyps->yyvs
1865 #define yyvsp yyps->yyvsp
1866 #define yylsa yyps->yylsa
1867 #define yyls yyps->yyls
1868 #define yylsp yyps->yylsp
1869 #define yyerror_range yyps->yyerror_range
1870 #define yystacksize yyps->yystacksize
1871
1872
1873 /*---------------.
1874 | yypush_parse. |
1875 `---------------*/
1876
1877 int
yypush_parse(yypstate * yyps,int yypushed_char,YYSTYPE const * yypushed_val,YYLTYPE * yypushed_loc,AmpAcScanner * scanner)1878 yypush_parse (yypstate *yyps, int yypushed_char, YYSTYPE const *yypushed_val, YYLTYPE *yypushed_loc, AmpAcScanner* scanner)
1879 {
1880 /* The lookahead symbol. */
1881 int yychar;
1882
1883
1884 /* The semantic value of the lookahead symbol. */
1885 /* Default value used for initialization, for pacifying older GCCs
1886 or non-GCC compilers. */
1887 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1888 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1889
1890 /* Location data for the lookahead symbol. */
1891 static YYLTYPE yyloc_default
1892 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1893 = { 1, 1, 1, 1 }
1894 # endif
1895 ;
1896 YYLTYPE yylloc = yyloc_default;
1897
1898 int yyn;
1899 int yyresult;
1900 /* Lookahead token as an internal (translated) token number. */
1901 int yytoken = 0;
1902 /* The variables used to return semantic value and location from the
1903 action routines. */
1904 YYSTYPE yyval;
1905 YYLTYPE yyloc;
1906
1907 #if YYERROR_VERBOSE
1908 /* Buffer for error messages, and its allocated size. */
1909 char yymsgbuf[128];
1910 char *yymsg = yymsgbuf;
1911 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1912 #endif
1913
1914 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
1915
1916 /* The number of symbols on the RHS of the reduced rule.
1917 Keep to zero when no symbol should be popped. */
1918 int yylen = 0;
1919
1920 if (!yyps->yynew)
1921 {
1922 yyn = yypact[yystate];
1923 goto yyread_pushed_token;
1924 }
1925
1926 yyssp = yyss = yyssa;
1927 yyvsp = yyvs = yyvsa;
1928 yylsp = yyls = yylsa;
1929 yystacksize = YYINITDEPTH;
1930
1931 YYDPRINTF ((stderr, "Starting parse\n"));
1932
1933 yystate = 0;
1934 yyerrstatus = 0;
1935 yynerrs = 0;
1936 yychar = YYEMPTY; /* Cause a token to be read. */
1937 yylsp[0] = *yypushed_loc;
1938 goto yysetstate;
1939
1940 /*------------------------------------------------------------.
1941 | yynewstate -- Push a new state, which is found in yystate. |
1942 `------------------------------------------------------------*/
1943 yynewstate:
1944 /* In all cases, when you get here, the value and location stacks
1945 have just been pushed. So pushing a state here evens the stacks. */
1946 yyssp++;
1947
1948 yysetstate:
1949 *yyssp = yystate;
1950
1951 if (yyss + yystacksize - 1 <= yyssp)
1952 {
1953 /* Get the current used size of the three stacks, in elements. */
1954 YYSIZE_T yysize = yyssp - yyss + 1;
1955
1956 #ifdef yyoverflow
1957 {
1958 /* Give user a chance to reallocate the stack. Use copies of
1959 these so that the &'s don't force the real ones into
1960 memory. */
1961 YYSTYPE *yyvs1 = yyvs;
1962 yytype_int16 *yyss1 = yyss;
1963 YYLTYPE *yyls1 = yyls;
1964
1965 /* Each stack pointer address is followed by the size of the
1966 data in use in that stack, in bytes. This used to be a
1967 conditional around just the two extra args, but that might
1968 be undefined if yyoverflow is a macro. */
1969 yyoverflow (YY_("memory exhausted"),
1970 &yyss1, yysize * sizeof (*yyssp),
1971 &yyvs1, yysize * sizeof (*yyvsp),
1972 &yyls1, yysize * sizeof (*yylsp),
1973 &yystacksize);
1974
1975 yyls = yyls1;
1976 yyss = yyss1;
1977 yyvs = yyvs1;
1978 }
1979 #else /* no yyoverflow */
1980 # ifndef YYSTACK_RELOCATE
1981 goto yyexhaustedlab;
1982 # else
1983 /* Extend the stack our own way. */
1984 if (YYMAXDEPTH <= yystacksize)
1985 goto yyexhaustedlab;
1986 yystacksize *= 2;
1987 if (YYMAXDEPTH < yystacksize)
1988 yystacksize = YYMAXDEPTH;
1989
1990 {
1991 yytype_int16 *yyss1 = yyss;
1992 union yyalloc *yyptr =
1993 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1994 if (! yyptr)
1995 goto yyexhaustedlab;
1996 YYSTACK_RELOCATE (yyss_alloc, yyss);
1997 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1998 YYSTACK_RELOCATE (yyls_alloc, yyls);
1999 # undef YYSTACK_RELOCATE
2000 if (yyss1 != yyssa)
2001 YYSTACK_FREE (yyss1);
2002 }
2003 # endif
2004 #endif /* no yyoverflow */
2005
2006 yyssp = yyss + yysize - 1;
2007 yyvsp = yyvs + yysize - 1;
2008 yylsp = yyls + yysize - 1;
2009
2010 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2011 (unsigned long) yystacksize));
2012
2013 if (yyss + yystacksize - 1 <= yyssp)
2014 YYABORT;
2015 }
2016
2017 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2018
2019 if (yystate == YYFINAL)
2020 YYACCEPT;
2021
2022 goto yybackup;
2023
2024 /*-----------.
2025 | yybackup. |
2026 `-----------*/
2027 yybackup:
2028
2029 /* Do appropriate processing given the current state. Read a
2030 lookahead token if we need one and don't already have one. */
2031
2032 /* First try to decide what to do without reference to lookahead token. */
2033 yyn = yypact[yystate];
2034 if (yypact_value_is_default (yyn))
2035 goto yydefault;
2036
2037 /* Not known => get a lookahead token if don't already have one. */
2038
2039 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2040 if (yychar == YYEMPTY)
2041 {
2042 if (!yyps->yynew)
2043 {
2044 YYDPRINTF ((stderr, "Return for a new token:\n"));
2045 yyresult = YYPUSH_MORE;
2046 goto yypushreturn;
2047 }
2048 yyps->yynew = 0;
2049 yyread_pushed_token:
2050 YYDPRINTF ((stderr, "Reading a token: "));
2051 yychar = yypushed_char;
2052 if (yypushed_val)
2053 yylval = *yypushed_val;
2054 if (yypushed_loc)
2055 yylloc = *yypushed_loc;
2056 }
2057
2058 if (yychar <= YYEOF)
2059 {
2060 yychar = yytoken = YYEOF;
2061 YYDPRINTF ((stderr, "Now at end of input.\n"));
2062 }
2063 else
2064 {
2065 yytoken = YYTRANSLATE (yychar);
2066 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2067 }
2068
2069 /* If the proper action on seeing token YYTOKEN is to reduce or to
2070 detect an error, take that action. */
2071 yyn += yytoken;
2072 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2073 goto yydefault;
2074 yyn = yytable[yyn];
2075 if (yyn <= 0)
2076 {
2077 if (yytable_value_is_error (yyn))
2078 goto yyerrlab;
2079 yyn = -yyn;
2080 goto yyreduce;
2081 }
2082
2083 /* Count tokens shifted since error; after three, turn off error
2084 status. */
2085 if (yyerrstatus)
2086 yyerrstatus--;
2087
2088 /* Shift the lookahead token. */
2089 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2090
2091 /* Discard the shifted token. */
2092 yychar = YYEMPTY;
2093
2094 yystate = yyn;
2095 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2096 *++yyvsp = yylval;
2097 YY_IGNORE_MAYBE_UNINITIALIZED_END
2098 *++yylsp = yylloc;
2099 goto yynewstate;
2100
2101
2102 /*-----------------------------------------------------------.
2103 | yydefault -- do the default action for the current state. |
2104 `-----------------------------------------------------------*/
2105 yydefault:
2106 yyn = yydefact[yystate];
2107 if (yyn == 0)
2108 goto yyerrlab;
2109 goto yyreduce;
2110
2111
2112 /*-----------------------------.
2113 | yyreduce -- Do a reduction. |
2114 `-----------------------------*/
2115 yyreduce:
2116 /* yyn is the number of a rule to reduce with. */
2117 yylen = yyr2[yyn];
2118
2119 /* If YYLEN is nonzero, implement the default value of the action:
2120 '$$ = $1'.
2121
2122 Otherwise, the following line sets YYVAL to garbage.
2123 This behavior is undocumented and Bison
2124 users should not rely upon it. Assigning to YYVAL
2125 unconditionally makes the parser a bit smaller, and it avoids a
2126 GCC warning that YYVAL may be used uninitialized. */
2127 yyval = yyvsp[1-yylen];
2128
2129 /* Default location. */
2130 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
2131 yyerror_range[1] = yyloc;
2132 YY_REDUCE_PRINT (yyn);
2133 switch (yyn)
2134 {
2135 case 8:
2136 #line 204 "ac-parser.y" /* yacc.c:1651 */
2137 {
2138 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_DEFINITION, NULL);
2139 if ((yyvsp[-2])) anjuta_token_set_type ((yyvsp[-2]), ANJUTA_TOKEN_NEXT);
2140 anjuta_token_merge ((yyval), (yyvsp[-3]));
2141 anjuta_token_merge ((yyval), (yyvsp[-2]));
2142 anjuta_token_merge ((yyval), (yyvsp[-1]));
2143 anjuta_token_merge ((yyval), (yyvsp[0]));
2144 amp_ac_scanner_update_variable (scanner, (yyval));
2145 }
2146 #line 2147 "ac-parser.c" /* yacc.c:1651 */
2147 break;
2148
2149 case 9:
2150 #line 213 "ac-parser.y" /* yacc.c:1651 */
2151 {
2152 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_DEFINITION, NULL);
2153 if ((yyvsp[-1])) anjuta_token_set_type ((yyvsp[-1]), ANJUTA_TOKEN_NEXT);
2154 anjuta_token_merge ((yyval), (yyvsp[-2]));
2155 anjuta_token_merge ((yyval), (yyvsp[-1]));
2156 anjuta_token_merge ((yyval), (yyvsp[0]));
2157 amp_ac_scanner_update_variable (scanner, (yyval));
2158 }
2159 #line 2160 "ac-parser.c" /* yacc.c:1651 */
2160 break;
2161
2162 case 17:
2163 #line 237 "ac-parser.y" /* yacc.c:1651 */
2164 {
2165 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_LIST, NULL);
2166 anjuta_token_merge ((yyval), (yyvsp[0]));
2167 }
2168 #line 2169 "ac-parser.c" /* yacc.c:1651 */
2169 break;
2170
2171 case 18:
2172 #line 241 "ac-parser.y" /* yacc.c:1651 */
2173 {
2174 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2175 }
2176 #line 2177 "ac-parser.c" /* yacc.c:1651 */
2177 break;
2178
2179 case 58:
2180 #line 302 "ac-parser.y" /* yacc.c:1651 */
2181 {
2182 anjuta_token_set_type ((yyvsp[0]), ANJUTA_TOKEN_LAST);
2183 }
2184 #line 2185 "ac-parser.c" /* yacc.c:1651 */
2185 break;
2186
2187 case 60:
2188 #line 309 "ac-parser.y" /* yacc.c:1651 */
2189 {
2190 anjuta_token_set_type ((yyvsp[-1]), ANJUTA_TOKEN_NEXT);
2191 }
2192 #line 2193 "ac-parser.c" /* yacc.c:1651 */
2193 break;
2194
2195 case 61:
2196 #line 312 "ac-parser.y" /* yacc.c:1651 */
2197 {
2198 anjuta_token_set_type ((yyvsp[-1]), ANJUTA_TOKEN_NEXT);
2199 }
2200 #line 2201 "ac-parser.c" /* yacc.c:1651 */
2201 break;
2202
2203 case 64:
2204 #line 323 "ac-parser.y" /* yacc.c:1651 */
2205 {
2206 anjuta_token_set_type ((yyvsp[0]), ANJUTA_TOKEN_OPERATOR);
2207 }
2208 #line 2209 "ac-parser.c" /* yacc.c:1651 */
2209 break;
2210
2211 case 65:
2212 #line 329 "ac-parser.y" /* yacc.c:1651 */
2213 {
2214 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_NAME, NULL);
2215 anjuta_token_merge ((yyval), (yyvsp[0]));
2216 }
2217 #line 2218 "ac-parser.c" /* yacc.c:1651 */
2218 break;
2219
2220 case 66:
2221 #line 333 "ac-parser.y" /* yacc.c:1651 */
2222 {
2223 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2224 }
2225 #line 2226 "ac-parser.c" /* yacc.c:1651 */
2226 break;
2227
2228 case 70:
2229 #line 348 "ac-parser.y" /* yacc.c:1651 */
2230 {
2231 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_COMMENT, NULL);
2232 anjuta_token_merge ((yyval), (yyvsp[-2]));
2233 anjuta_token_merge ((yyval), (yyvsp[-1]));
2234 anjuta_token_merge ((yyval), (yyvsp[0]));
2235 }
2236 #line 2237 "ac-parser.c" /* yacc.c:1651 */
2237 break;
2238
2239 case 71:
2240 #line 357 "ac-parser.y" /* yacc.c:1651 */
2241 {
2242 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_LIST, NULL);
2243 anjuta_token_merge ((yyval), (yyvsp[-1]));
2244 anjuta_token_merge ((yyval), (yyvsp[0]));
2245 amp_ac_scanner_include (scanner, (yyval));
2246 }
2247 #line 2248 "ac-parser.c" /* yacc.c:1651 */
2248 break;
2249
2250 case 72:
2251 #line 367 "ac-parser.y" /* yacc.c:1651 */
2252 {
2253 (yyval) = anjuta_token_new_static (AC_TOKEN_PKG_CHECK_MODULES, NULL);
2254 anjuta_token_merge ((yyval), (yyvsp[-1]));
2255 anjuta_token_merge ((yyval), (yyvsp[0]));
2256 amp_ac_scanner_load_module (scanner, (yyvsp[0]));
2257 }
2258 #line 2259 "ac-parser.c" /* yacc.c:1651 */
2259 break;
2260
2261 case 73:
2262 #line 381 "ac-parser.y" /* yacc.c:1651 */
2263 {
2264 (yyval) = anjuta_token_new_static (amp_ac_autoconf_macro ((yyvsp[-1])), NULL);
2265 anjuta_token_merge ((yyval), (yyvsp[-1]));
2266 anjuta_token_merge ((yyval), (yyvsp[0]));
2267 amp_ac_scanner_load_properties (scanner, (yyval), (yyvsp[0]));
2268 }
2269 #line 2270 "ac-parser.c" /* yacc.c:1651 */
2270 break;
2271
2272 case 74:
2273 #line 390 "ac-parser.y" /* yacc.c:1651 */
2274 {
2275 anjuta_token_set_type ((yyvsp[0]), amp_ac_autoconf_macro ((yyvsp[0])));
2276 amp_ac_scanner_load_properties (scanner, (yyval), NULL);
2277 }
2278 #line 2279 "ac-parser.c" /* yacc.c:1651 */
2279 break;
2280
2281 case 75:
2282 #line 396 "ac-parser.y" /* yacc.c:1651 */
2283 {
2284 (yyval) = anjuta_token_new_static (AC_TOKEN_AC_SUBST, NULL);
2285 anjuta_token_merge ((yyval), (yyvsp[-1]));
2286 anjuta_token_merge ((yyval), (yyvsp[0]));
2287 amp_ac_scanner_subst_variable (scanner, (yyvsp[0]));
2288 }
2289 #line 2290 "ac-parser.c" /* yacc.c:1651 */
2290 break;
2291
2292 case 76:
2293 #line 405 "ac-parser.y" /* yacc.c:1651 */
2294 {
2295 anjuta_token_set_type ((yyvsp[0]), AC_TOKEN_AC_OUTPUT);
2296 }
2297 #line 2298 "ac-parser.c" /* yacc.c:1651 */
2298 break;
2299
2300 case 77:
2301 #line 411 "ac-parser.y" /* yacc.c:1651 */
2302 {
2303 (yyval) = anjuta_token_new_static (AC_TOKEN_OBSOLETE_AC_OUTPUT, NULL);
2304 anjuta_token_merge ((yyval), (yyvsp[-1]));
2305 anjuta_token_merge ((yyval), (yyvsp[0]));
2306 amp_ac_scanner_load_config (scanner, (yyvsp[0]));
2307 }
2308 #line 2309 "ac-parser.c" /* yacc.c:1651 */
2309 break;
2310
2311 case 78:
2312 #line 420 "ac-parser.y" /* yacc.c:1651 */
2313 {
2314 (yyval) = anjuta_token_new_static (AC_TOKEN_AC_CONFIG_FILES, NULL);
2315 anjuta_token_merge ((yyval), (yyvsp[-1]));
2316 anjuta_token_merge ((yyval), (yyvsp[0]));
2317 amp_ac_scanner_load_config (scanner, (yyvsp[0]));
2318 }
2319 #line 2320 "ac-parser.c" /* yacc.c:1651 */
2320 break;
2321
2322 case 79:
2323 #line 432 "ac-parser.y" /* yacc.c:1651 */
2324 {
2325 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_LAST, NULL);
2326 anjuta_token_merge ((yyval), (yyvsp[0]));
2327 anjuta_token_merge ((yyvsp[-1]), (yyval));
2328 (yyval) = (yyvsp[-1]);
2329 }
2330 #line 2331 "ac-parser.c" /* yacc.c:1651 */
2331 break;
2332
2333 case 80:
2334 #line 438 "ac-parser.y" /* yacc.c:1651 */
2335 {
2336 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_LAST, NULL);
2337 anjuta_token_merge ((yyval), (yyvsp[0]));
2338 anjuta_token_merge ((yyvsp[-1]), (yyval));
2339 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_LIST, NULL);
2340 anjuta_token_set_type ((yyvsp[-2]), ANJUTA_TOKEN_START);
2341 anjuta_token_merge ((yyval), (yyvsp[-2]));
2342 anjuta_token_merge_children ((yyval), (yyvsp[-1]));
2343 }
2344 #line 2345 "ac-parser.c" /* yacc.c:1651 */
2345 break;
2346
2347 case 81:
2348 #line 450 "ac-parser.y" /* yacc.c:1651 */
2349 {
2350 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_LIST, NULL);
2351 anjuta_token_merge ((yyval), (yyvsp[0]));
2352 //fprintf(stdout, "arg_list_body arg\n");
2353 //anjuta_token_dump ($1);
2354 }
2355 #line 2356 "ac-parser.c" /* yacc.c:1651 */
2356 break;
2357
2358 case 82:
2359 #line 456 "ac-parser.y" /* yacc.c:1651 */
2360 {
2361 //fprintf(stdout, "arg_list_body body\n");
2362 //anjuta_token_dump ($1);
2363 //fprintf(stdout, "arg_list_body separator\n");
2364 //anjuta_token_dump ($2);
2365 //fprintf(stdout, "arg_list_body arg\n");
2366 //anjuta_token_dump ($3);
2367 anjuta_token_merge ((yyvsp[-2]), (yyvsp[-1]));
2368 anjuta_token_merge ((yyvsp[-2]), (yyvsp[0]));
2369 //fprintf(stdout, "arg_list_body merge\n");
2370 //anjuta_token_dump ($1);
2371 }
2372 #line 2373 "ac-parser.c" /* yacc.c:1651 */
2373 break;
2374
2375 case 83:
2376 #line 471 "ac-parser.y" /* yacc.c:1651 */
2377 {
2378 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_COMMENT, NULL);
2379 anjuta_token_merge ((yyval), (yyvsp[-2]));
2380 anjuta_token_merge ((yyval), (yyvsp[-1]));
2381 anjuta_token_merge ((yyval), (yyvsp[0]));
2382 }
2383 #line 2384 "ac-parser.c" /* yacc.c:1651 */
2384 break;
2385
2386 case 84:
2387 #line 480 "ac-parser.y" /* yacc.c:1651 */
2388 {
2389 (yyval) = NULL;
2390 }
2391 #line 2392 "ac-parser.c" /* yacc.c:1651 */
2392 break;
2393
2394 case 85:
2395 #line 483 "ac-parser.y" /* yacc.c:1651 */
2396 {
2397 (yyval) = (yyvsp[0]);
2398 }
2399 #line 2400 "ac-parser.c" /* yacc.c:1651 */
2400 break;
2401
2402 case 88:
2403 #line 494 "ac-parser.y" /* yacc.c:1651 */
2404 {
2405 anjuta_token_set_type ((yyvsp[-2]), ANJUTA_TOKEN_OPEN_QUOTE);
2406 anjuta_token_set_type ((yyvsp[0]), ANJUTA_TOKEN_CLOSE_QUOTE);
2407 (yyval) = anjuta_token_merge_previous ((yyvsp[-1]), (yyvsp[-2]));
2408 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2409 }
2410 #line 2411 "ac-parser.c" /* yacc.c:1651 */
2411 break;
2412
2413 case 89:
2414 #line 503 "ac-parser.y" /* yacc.c:1651 */
2415 {
2416 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_STRING, NULL);
2417 }
2418 #line 2419 "ac-parser.c" /* yacc.c:1651 */
2419 break;
2420
2421 case 90:
2422 #line 506 "ac-parser.y" /* yacc.c:1651 */
2423 {
2424 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2425 }
2426 #line 2427 "ac-parser.c" /* yacc.c:1651 */
2427 break;
2428
2429 case 106:
2430 #line 530 "ac-parser.y" /* yacc.c:1651 */
2431 {
2432 anjuta_token_set_type ((yyvsp[-2]), ANJUTA_TOKEN_OPEN_QUOTE);
2433 anjuta_token_set_type ((yyvsp[0]), ANJUTA_TOKEN_CLOSE_QUOTE);
2434 (yyval) = anjuta_token_merge_previous ((yyvsp[-1]), (yyvsp[-2]));
2435 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2436 }
2437 #line 2438 "ac-parser.c" /* yacc.c:1651 */
2438 break;
2439
2440 case 107:
2441 #line 539 "ac-parser.y" /* yacc.c:1651 */
2442 {
2443 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_STRING, NULL);
2444 }
2445 #line 2446 "ac-parser.c" /* yacc.c:1651 */
2446 break;
2447
2448 case 108:
2449 #line 542 "ac-parser.y" /* yacc.c:1651 */
2450 {
2451 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2452 }
2453 #line 2454 "ac-parser.c" /* yacc.c:1651 */
2454 break;
2455
2456 case 123:
2457 #line 565 "ac-parser.y" /* yacc.c:1651 */
2458 {
2459 anjuta_token_set_type ((yyvsp[-2]), ANJUTA_TOKEN_OPEN_QUOTE);
2460 anjuta_token_set_type ((yyvsp[0]), ANJUTA_TOKEN_CLOSE_QUOTE);
2461 (yyval) = anjuta_token_merge_previous ((yyvsp[-1]), (yyvsp[-2]));
2462 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2463 }
2464 #line 2465 "ac-parser.c" /* yacc.c:1651 */
2465 break;
2466
2467 case 124:
2468 #line 574 "ac-parser.y" /* yacc.c:1651 */
2469 {
2470 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_STRING, NULL);
2471 }
2472 #line 2473 "ac-parser.c" /* yacc.c:1651 */
2473 break;
2474
2475 case 125:
2476 #line 577 "ac-parser.y" /* yacc.c:1651 */
2477 {
2478 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2479 }
2480 #line 2481 "ac-parser.c" /* yacc.c:1651 */
2481 break;
2482
2483 case 126:
2484 #line 580 "ac-parser.y" /* yacc.c:1651 */
2485 {
2486 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2487 }
2488 #line 2489 "ac-parser.c" /* yacc.c:1651 */
2489 break;
2490
2491 case 127:
2492 #line 586 "ac-parser.y" /* yacc.c:1651 */
2493 {
2494 anjuta_token_set_type ((yyvsp[-2]), ANJUTA_TOKEN_OPEN_QUOTE);
2495 anjuta_token_set_type ((yyvsp[0]), ANJUTA_TOKEN_CLOSE_QUOTE);
2496 (yyval) = anjuta_token_merge_previous ((yyvsp[-1]), (yyvsp[-2]));
2497 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2498 }
2499 #line 2500 "ac-parser.c" /* yacc.c:1651 */
2500 break;
2501
2502 case 128:
2503 #line 595 "ac-parser.y" /* yacc.c:1651 */
2504 {
2505 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_STRING, NULL);
2506 }
2507 #line 2508 "ac-parser.c" /* yacc.c:1651 */
2508 break;
2509
2510 case 129:
2511 #line 598 "ac-parser.y" /* yacc.c:1651 */
2512 {
2513 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2514 }
2515 #line 2516 "ac-parser.c" /* yacc.c:1651 */
2516 break;
2517
2518 case 130:
2519 #line 601 "ac-parser.y" /* yacc.c:1651 */
2520 {
2521 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2522 }
2523 #line 2524 "ac-parser.c" /* yacc.c:1651 */
2524 break;
2525
2526 case 131:
2527 #line 607 "ac-parser.y" /* yacc.c:1651 */
2528 {
2529 anjuta_token_set_type ((yyvsp[-2]), ANJUTA_TOKEN_OPEN_QUOTE);
2530 anjuta_token_set_type ((yyvsp[0]), ANJUTA_TOKEN_CLOSE_QUOTE);
2531 (yyval) = anjuta_token_merge_previous ((yyvsp[-1]), (yyvsp[-2]));
2532 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2533 }
2534 #line 2535 "ac-parser.c" /* yacc.c:1651 */
2535 break;
2536
2537 case 132:
2538 #line 616 "ac-parser.y" /* yacc.c:1651 */
2539 {
2540 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_STRING, NULL);
2541 }
2542 #line 2543 "ac-parser.c" /* yacc.c:1651 */
2543 break;
2544
2545 case 133:
2546 #line 619 "ac-parser.y" /* yacc.c:1651 */
2547 {
2548 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2549 }
2550 #line 2551 "ac-parser.c" /* yacc.c:1651 */
2551 break;
2552
2553 case 134:
2554 #line 622 "ac-parser.y" /* yacc.c:1651 */
2555 {
2556 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2557 }
2558 #line 2559 "ac-parser.c" /* yacc.c:1651 */
2559 break;
2560
2561 case 135:
2562 #line 625 "ac-parser.y" /* yacc.c:1651 */
2563 {
2564 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2565 }
2566 #line 2567 "ac-parser.c" /* yacc.c:1651 */
2567 break;
2568
2569 case 136:
2570 #line 628 "ac-parser.y" /* yacc.c:1651 */
2571 {
2572 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2573 }
2574 #line 2575 "ac-parser.c" /* yacc.c:1651 */
2575 break;
2576
2577 case 137:
2578 #line 631 "ac-parser.y" /* yacc.c:1651 */
2579 {
2580 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2581 }
2582 #line 2583 "ac-parser.c" /* yacc.c:1651 */
2583 break;
2584
2585 case 138:
2586 #line 634 "ac-parser.y" /* yacc.c:1651 */
2587 {
2588 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2589 }
2590 #line 2591 "ac-parser.c" /* yacc.c:1651 */
2591 break;
2592
2593 case 139:
2594 #line 637 "ac-parser.y" /* yacc.c:1651 */
2595 {
2596 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2597 }
2598 #line 2599 "ac-parser.c" /* yacc.c:1651 */
2599 break;
2600
2601 case 140:
2602 #line 640 "ac-parser.y" /* yacc.c:1651 */
2603 {
2604 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2605 }
2606 #line 2607 "ac-parser.c" /* yacc.c:1651 */
2607 break;
2608
2609 case 141:
2610 #line 643 "ac-parser.y" /* yacc.c:1651 */
2611 {
2612 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2613 }
2614 #line 2615 "ac-parser.c" /* yacc.c:1651 */
2615 break;
2616
2617 case 142:
2618 #line 646 "ac-parser.y" /* yacc.c:1651 */
2619 {
2620 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2621 }
2622 #line 2623 "ac-parser.c" /* yacc.c:1651 */
2623 break;
2624
2625 case 143:
2626 #line 649 "ac-parser.y" /* yacc.c:1651 */
2627 {
2628 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2629 }
2630 #line 2631 "ac-parser.c" /* yacc.c:1651 */
2631 break;
2632
2633 case 144:
2634 #line 652 "ac-parser.y" /* yacc.c:1651 */
2635 {
2636 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2637 }
2638 #line 2639 "ac-parser.c" /* yacc.c:1651 */
2639 break;
2640
2641 case 145:
2642 #line 655 "ac-parser.y" /* yacc.c:1651 */
2643 {
2644 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2645 }
2646 #line 2647 "ac-parser.c" /* yacc.c:1651 */
2647 break;
2648
2649 case 146:
2650 #line 658 "ac-parser.y" /* yacc.c:1651 */
2651 {
2652 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2653 }
2654 #line 2655 "ac-parser.c" /* yacc.c:1651 */
2655 break;
2656
2657 case 149:
2658 #line 663 "ac-parser.y" /* yacc.c:1651 */
2659 {
2660 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2661 }
2662 #line 2663 "ac-parser.c" /* yacc.c:1651 */
2663 break;
2664
2665 case 150:
2666 #line 672 "ac-parser.y" /* yacc.c:1651 */
2667 {
2668 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_ITEM, NULL);
2669 }
2670 #line 2671 "ac-parser.c" /* yacc.c:1651 */
2671 break;
2672
2673 case 151:
2674 #line 675 "ac-parser.y" /* yacc.c:1651 */
2675 {
2676 //fprintf(stdout, "arg part\n");
2677 //anjuta_token_dump ($1);
2678 //fprintf(stdout, "arg body\n");
2679 //anjuta_token_dump ($2);
2680 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_ITEM, NULL);
2681 anjuta_token_merge ((yyval), (yyvsp[-1]));
2682 anjuta_token_merge_children ((yyval), (yyvsp[0]));
2683 //fprintf(stdout, "arg merge\n");
2684 //anjuta_token_dump ($1);
2685 }
2686 #line 2687 "ac-parser.c" /* yacc.c:1651 */
2687 break;
2688
2689 case 152:
2690 #line 689 "ac-parser.y" /* yacc.c:1651 */
2691 {
2692 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_ITEM, NULL);
2693 }
2694 #line 2695 "ac-parser.c" /* yacc.c:1651 */
2695 break;
2696
2697 case 153:
2698 #line 692 "ac-parser.y" /* yacc.c:1651 */
2699 {
2700 (yyval) = anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2701 }
2702 #line 2703 "ac-parser.c" /* yacc.c:1651 */
2703 break;
2704
2705 case 171:
2706 #line 724 "ac-parser.y" /* yacc.c:1651 */
2707 {
2708 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_NEXT, NULL);
2709 anjuta_token_merge ((yyval), (yyvsp[0]));
2710 }
2711 #line 2712 "ac-parser.c" /* yacc.c:1651 */
2712 break;
2713
2714 case 172:
2715 #line 728 "ac-parser.y" /* yacc.c:1651 */
2716 {
2717 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_NEXT, NULL);
2718 //fprintf(stdout, "separator spaces\n");
2719 //anjuta_token_dump ($2);
2720 //fprintf(stdout, "separator comma\n");
2721 //anjuta_token_dump ($1);
2722 //fprintf(stdout, "separator next\n");
2723 //anjuta_token_dump ($$);
2724 anjuta_token_merge ((yyval), (yyvsp[-1]));
2725 anjuta_token_merge_children ((yyval), (yyvsp[0]));
2726 //fprintf(stdout, "separator merge\n");
2727 //anjuta_token_dump ($$);
2728 }
2729 #line 2730 "ac-parser.c" /* yacc.c:1651 */
2730 break;
2731
2732 case 173:
2733 #line 744 "ac-parser.y" /* yacc.c:1651 */
2734 {
2735 (yyval) = anjuta_token_merge_previous ((yyvsp[-1]), (yyvsp[-2]));
2736 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2737 }
2738 #line 2739 "ac-parser.c" /* yacc.c:1651 */
2739 break;
2740
2741 case 174:
2742 #line 751 "ac-parser.y" /* yacc.c:1651 */
2743 {
2744 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_STRING, NULL);
2745 }
2746 #line 2747 "ac-parser.c" /* yacc.c:1651 */
2747 break;
2748
2749 case 175:
2750 #line 754 "ac-parser.y" /* yacc.c:1651 */
2751 {
2752 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2753 }
2754 #line 2755 "ac-parser.c" /* yacc.c:1651 */
2755 break;
2756
2757 case 176:
2758 #line 757 "ac-parser.y" /* yacc.c:1651 */
2759 {
2760 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2761 }
2762 #line 2763 "ac-parser.c" /* yacc.c:1651 */
2763 break;
2764
2765 case 178:
2766 #line 761 "ac-parser.y" /* yacc.c:1651 */
2767 {
2768 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2769 }
2770 #line 2771 "ac-parser.c" /* yacc.c:1651 */
2771 break;
2772
2773 case 179:
2774 #line 764 "ac-parser.y" /* yacc.c:1651 */
2775 {
2776 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2777 }
2778 #line 2779 "ac-parser.c" /* yacc.c:1651 */
2779 break;
2780
2781 case 180:
2782 #line 767 "ac-parser.y" /* yacc.c:1651 */
2783 {
2784 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2785 }
2786 #line 2787 "ac-parser.c" /* yacc.c:1651 */
2787 break;
2788
2789 case 181:
2790 #line 770 "ac-parser.y" /* yacc.c:1651 */
2791 {
2792 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2793 }
2794 #line 2795 "ac-parser.c" /* yacc.c:1651 */
2795 break;
2796
2797 case 182:
2798 #line 773 "ac-parser.y" /* yacc.c:1651 */
2799 {
2800 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2801 }
2802 #line 2803 "ac-parser.c" /* yacc.c:1651 */
2803 break;
2804
2805 case 183:
2806 #line 776 "ac-parser.y" /* yacc.c:1651 */
2807 {
2808 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2809 }
2810 #line 2811 "ac-parser.c" /* yacc.c:1651 */
2811 break;
2812
2813 case 184:
2814 #line 779 "ac-parser.y" /* yacc.c:1651 */
2815 {
2816 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2817 }
2818 #line 2819 "ac-parser.c" /* yacc.c:1651 */
2819 break;
2820
2821 case 185:
2822 #line 782 "ac-parser.y" /* yacc.c:1651 */
2823 {
2824 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2825 }
2826 #line 2827 "ac-parser.c" /* yacc.c:1651 */
2827 break;
2828
2829 case 186:
2830 #line 785 "ac-parser.y" /* yacc.c:1651 */
2831 {
2832 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2833 }
2834 #line 2835 "ac-parser.c" /* yacc.c:1651 */
2835 break;
2836
2837 case 188:
2838 #line 789 "ac-parser.y" /* yacc.c:1651 */
2839 {
2840 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2841 }
2842 #line 2843 "ac-parser.c" /* yacc.c:1651 */
2843 break;
2844
2845 case 189:
2846 #line 792 "ac-parser.y" /* yacc.c:1651 */
2847 {
2848 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2849 }
2850 #line 2851 "ac-parser.c" /* yacc.c:1651 */
2851 break;
2852
2853 case 190:
2854 #line 798 "ac-parser.y" /* yacc.c:1651 */
2855 {
2856 (yyval) = NULL;
2857 }
2858 #line 2859 "ac-parser.c" /* yacc.c:1651 */
2859 break;
2860
2861 case 192:
2862 #line 805 "ac-parser.y" /* yacc.c:1651 */
2863 {
2864 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_SPACE, NULL);
2865 anjuta_token_merge ((yyval), (yyvsp[0]));
2866 }
2867 #line 2868 "ac-parser.c" /* yacc.c:1651 */
2868 break;
2869
2870 case 193:
2871 #line 809 "ac-parser.y" /* yacc.c:1651 */
2872 {
2873 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2874 }
2875 #line 2876 "ac-parser.c" /* yacc.c:1651 */
2876 break;
2877
2878 case 194:
2879 #line 815 "ac-parser.y" /* yacc.c:1651 */
2880 {
2881 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_SPACE, NULL);
2882 anjuta_token_merge ((yyval), (yyvsp[0]));
2883 }
2884 #line 2885 "ac-parser.c" /* yacc.c:1651 */
2885 break;
2886
2887 case 195:
2888 #line 819 "ac-parser.y" /* yacc.c:1651 */
2889 {
2890 (yyval) = anjuta_token_new_static (ANJUTA_TOKEN_SPACE, NULL);
2891 anjuta_token_merge ((yyval), (yyvsp[0]));
2892 }
2893 #line 2894 "ac-parser.c" /* yacc.c:1651 */
2894 break;
2895
2896 case 196:
2897 #line 823 "ac-parser.y" /* yacc.c:1651 */
2898 {
2899 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2900 }
2901 #line 2902 "ac-parser.c" /* yacc.c:1651 */
2902 break;
2903
2904 case 197:
2905 #line 826 "ac-parser.y" /* yacc.c:1651 */
2906 {
2907 anjuta_token_merge ((yyvsp[-1]), (yyvsp[0]));
2908 }
2909 #line 2910 "ac-parser.c" /* yacc.c:1651 */
2910 break;
2911
2912 case 306:
2913 #line 973 "ac-parser.y" /* yacc.c:1651 */
2914 {
2915 anjuta_token_set_type ((yyvsp[0]), ANJUTA_TOKEN_EOL);
2916 }
2917 #line 2918 "ac-parser.c" /* yacc.c:1651 */
2918 break;
2919
2920
2921 #line 2922 "ac-parser.c" /* yacc.c:1651 */
2922 default: break;
2923 }
2924 /* User semantic actions sometimes alter yychar, and that requires
2925 that yytoken be updated with the new translation. We take the
2926 approach of translating immediately before every use of yytoken.
2927 One alternative is translating here after every semantic action,
2928 but that translation would be missed if the semantic action invokes
2929 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2930 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2931 incorrect destructor might then be invoked immediately. In the
2932 case of YYERROR or YYBACKUP, subsequent parser actions might lead
2933 to an incorrect destructor call or verbose syntax error message
2934 before the lookahead is translated. */
2935 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2936
2937 YYPOPSTACK (yylen);
2938 yylen = 0;
2939 YY_STACK_PRINT (yyss, yyssp);
2940
2941 *++yyvsp = yyval;
2942 *++yylsp = yyloc;
2943
2944 /* Now 'shift' the result of the reduction. Determine what state
2945 that goes to, based on the state we popped back to and the rule
2946 number reduced by. */
2947
2948 yyn = yyr1[yyn];
2949
2950 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2951 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2952 yystate = yytable[yystate];
2953 else
2954 yystate = yydefgoto[yyn - YYNTOKENS];
2955
2956 goto yynewstate;
2957
2958
2959 /*--------------------------------------.
2960 | yyerrlab -- here on detecting error. |
2961 `--------------------------------------*/
2962 yyerrlab:
2963 /* Make sure we have latest lookahead translation. See comments at
2964 user semantic actions for why this is necessary. */
2965 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2966
2967 /* If not already recovering from an error, report this error. */
2968 if (!yyerrstatus)
2969 {
2970 ++yynerrs;
2971 #if ! YYERROR_VERBOSE
2972 yyerror (&yylloc, scanner, YY_("syntax error"));
2973 #else
2974 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2975 yyssp, yytoken)
2976 {
2977 char const *yymsgp = YY_("syntax error");
2978 int yysyntax_error_status;
2979 yysyntax_error_status = YYSYNTAX_ERROR;
2980 if (yysyntax_error_status == 0)
2981 yymsgp = yymsg;
2982 else if (yysyntax_error_status == 1)
2983 {
2984 if (yymsg != yymsgbuf)
2985 YYSTACK_FREE (yymsg);
2986 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2987 if (!yymsg)
2988 {
2989 yymsg = yymsgbuf;
2990 yymsg_alloc = sizeof yymsgbuf;
2991 yysyntax_error_status = 2;
2992 }
2993 else
2994 {
2995 yysyntax_error_status = YYSYNTAX_ERROR;
2996 yymsgp = yymsg;
2997 }
2998 }
2999 yyerror (&yylloc, scanner, yymsgp);
3000 if (yysyntax_error_status == 2)
3001 goto yyexhaustedlab;
3002 }
3003 # undef YYSYNTAX_ERROR
3004 #endif
3005 }
3006
3007 yyerror_range[1] = yylloc;
3008
3009 if (yyerrstatus == 3)
3010 {
3011 /* If just tried and failed to reuse lookahead token after an
3012 error, discard it. */
3013
3014 if (yychar <= YYEOF)
3015 {
3016 /* Return failure if at end of input. */
3017 if (yychar == YYEOF)
3018 YYABORT;
3019 }
3020 else
3021 {
3022 yydestruct ("Error: discarding",
3023 yytoken, &yylval, &yylloc, scanner);
3024 yychar = YYEMPTY;
3025 }
3026 }
3027
3028 /* Else will try to reuse lookahead token after shifting the error
3029 token. */
3030 goto yyerrlab1;
3031
3032
3033 /*---------------------------------------------------.
3034 | yyerrorlab -- error raised explicitly by YYERROR. |
3035 `---------------------------------------------------*/
3036 yyerrorlab:
3037
3038 /* Pacify compilers like GCC when the user code never invokes
3039 YYERROR and the label yyerrorlab therefore never appears in user
3040 code. */
3041 if (/*CONSTCOND*/ 0)
3042 goto yyerrorlab;
3043
3044 /* Do not reclaim the symbols of the rule whose action triggered
3045 this YYERROR. */
3046 YYPOPSTACK (yylen);
3047 yylen = 0;
3048 YY_STACK_PRINT (yyss, yyssp);
3049 yystate = *yyssp;
3050 goto yyerrlab1;
3051
3052
3053 /*-------------------------------------------------------------.
3054 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3055 `-------------------------------------------------------------*/
3056 yyerrlab1:
3057 yyerrstatus = 3; /* Each real token shifted decrements this. */
3058
3059 for (;;)
3060 {
3061 yyn = yypact[yystate];
3062 if (!yypact_value_is_default (yyn))
3063 {
3064 yyn += YYTERROR;
3065 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3066 {
3067 yyn = yytable[yyn];
3068 if (0 < yyn)
3069 break;
3070 }
3071 }
3072
3073 /* Pop the current state because it cannot handle the error token. */
3074 if (yyssp == yyss)
3075 YYABORT;
3076
3077 yyerror_range[1] = *yylsp;
3078 yydestruct ("Error: popping",
3079 yystos[yystate], yyvsp, yylsp, scanner);
3080 YYPOPSTACK (1);
3081 yystate = *yyssp;
3082 YY_STACK_PRINT (yyss, yyssp);
3083 }
3084
3085 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3086 *++yyvsp = yylval;
3087 YY_IGNORE_MAYBE_UNINITIALIZED_END
3088
3089 yyerror_range[2] = yylloc;
3090 /* Using YYLLOC is tempting, but would change the location of
3091 the lookahead. YYLOC is available though. */
3092 YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
3093 *++yylsp = yyloc;
3094
3095 /* Shift the error token. */
3096 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3097
3098 yystate = yyn;
3099 goto yynewstate;
3100
3101
3102 /*-------------------------------------.
3103 | yyacceptlab -- YYACCEPT comes here. |
3104 `-------------------------------------*/
3105 yyacceptlab:
3106 yyresult = 0;
3107 goto yyreturn;
3108
3109 /*-----------------------------------.
3110 | yyabortlab -- YYABORT comes here. |
3111 `-----------------------------------*/
3112 yyabortlab:
3113 yyresult = 1;
3114 goto yyreturn;
3115
3116 #if !defined yyoverflow || YYERROR_VERBOSE
3117 /*-------------------------------------------------.
3118 | yyexhaustedlab -- memory exhaustion comes here. |
3119 `-------------------------------------------------*/
3120 yyexhaustedlab:
3121 yyerror (&yylloc, scanner, YY_("memory exhausted"));
3122 yyresult = 2;
3123 /* Fall through. */
3124 #endif
3125
3126 yyreturn:
3127 if (yychar != YYEMPTY)
3128 {
3129 /* Make sure we have latest lookahead translation. See comments at
3130 user semantic actions for why this is necessary. */
3131 yytoken = YYTRANSLATE (yychar);
3132 yydestruct ("Cleanup: discarding lookahead",
3133 yytoken, &yylval, &yylloc, scanner);
3134 }
3135 /* Do not reclaim the symbols of the rule whose action triggered
3136 this YYABORT or YYACCEPT. */
3137 YYPOPSTACK (yylen);
3138 YY_STACK_PRINT (yyss, yyssp);
3139 while (yyssp != yyss)
3140 {
3141 yydestruct ("Cleanup: popping",
3142 yystos[*yyssp], yyvsp, yylsp, scanner);
3143 YYPOPSTACK (1);
3144 }
3145 #ifndef yyoverflow
3146 if (yyss != yyssa)
3147 YYSTACK_FREE (yyss);
3148 #endif
3149 yyps->yynew = 1;
3150
3151 yypushreturn:
3152 #if YYERROR_VERBOSE
3153 if (yymsg != yymsgbuf)
3154 YYSTACK_FREE (yymsg);
3155 #endif
3156 return yyresult;
3157 }
3158 #line 979 "ac-parser.y" /* yacc.c:1910 */
3159
3160