1*b88e3e88Schristos /* A Bison parser, made by GNU Bison 3.0.5. */
2ed0d50c3Schristos
306324dcfSchristos /* Bison implementation for Yacc-like parsers in C
4ed0d50c3Schristos
5*b88e3e88Schristos Copyright (C) 1984, 1989-1990, 2000-2015, 2018 Free Software Foundation, Inc.
6ed0d50c3Schristos
706324dcfSchristos This program is free software: you can redistribute it and/or modify
8ed0d50c3Schristos it under the terms of the GNU General Public License as published by
906324dcfSchristos the Free Software Foundation, either version 3 of the License, or
1006324dcfSchristos (at your option) any later version.
11ed0d50c3Schristos
12ed0d50c3Schristos This program is distributed in the hope that it will be useful,
13ed0d50c3Schristos but WITHOUT ANY WARRANTY; without even the implied warranty of
14ed0d50c3Schristos MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15ed0d50c3Schristos GNU General Public License for more details.
16ed0d50c3Schristos
17ed0d50c3Schristos You should have received a copy of the GNU General Public License
1806324dcfSchristos along with this program. If not, see <http://www.gnu.org/licenses/>. */
19ed0d50c3Schristos
20ed0d50c3Schristos /* As a special exception, you may create a larger work that contains
21ed0d50c3Schristos part or all of the Bison parser skeleton and distribute that work
22ed0d50c3Schristos under terms of your choice, so long as that work isn't itself a
23ed0d50c3Schristos parser generator using the skeleton or a modified version thereof
24ed0d50c3Schristos as a parser skeleton. Alternatively, if you modify or redistribute
25ed0d50c3Schristos the parser skeleton itself, you may (at your option) remove this
26ed0d50c3Schristos special exception, which will cause the skeleton and the resulting
27ed0d50c3Schristos Bison output files to be licensed under the GNU General Public
28ed0d50c3Schristos License without this special exception.
29ed0d50c3Schristos
30ed0d50c3Schristos This special exception was added by the Free Software Foundation in
31ed0d50c3Schristos version 2.2 of Bison. */
32ed0d50c3Schristos
33ed0d50c3Schristos /* C LALR(1) parser skeleton written by Richard Stallman, by
34ed0d50c3Schristos simplifying the original so-called "semantic" parser. */
35ed0d50c3Schristos
36ed0d50c3Schristos /* All symbols defined below should begin with yy or YY, to avoid
37ed0d50c3Schristos infringing on user name space. This should be done even for local
38ed0d50c3Schristos variables, as they might otherwise be expanded by user macros.
39ed0d50c3Schristos There are some unavoidable exceptions within include files to
40ed0d50c3Schristos define necessary library symbols; they are noted "INFRINGES ON
41ed0d50c3Schristos USER NAME SPACE" below. */
42ed0d50c3Schristos
43ed0d50c3Schristos /* Identify Bison output. */
44ed0d50c3Schristos #define YYBISON 1
45ed0d50c3Schristos
46ed0d50c3Schristos /* Bison version. */
47*b88e3e88Schristos #define YYBISON_VERSION "3.0.5"
48ed0d50c3Schristos
49ed0d50c3Schristos /* Skeleton name. */
50ed0d50c3Schristos #define YYSKELETON_NAME "yacc.c"
51ed0d50c3Schristos
52ed0d50c3Schristos /* Pure parsers. */
53ed0d50c3Schristos #define YYPURE 0
54ed0d50c3Schristos
5506324dcfSchristos /* Push parsers. */
5606324dcfSchristos #define YYPUSH 0
5706324dcfSchristos
5806324dcfSchristos /* Pull parsers. */
5906324dcfSchristos #define YYPULL 1
60ed0d50c3Schristos
61ed0d50c3Schristos
62ed0d50c3Schristos
6306324dcfSchristos
6406324dcfSchristos /* Copy the first part of user declarations. */
6506324dcfSchristos #line 1 "arparse.y" /* yacc.c:339 */
6606324dcfSchristos
6706324dcfSchristos /* arparse.y - Strange script language parser */
6806324dcfSchristos
69*b88e3e88Schristos /* Copyright (C) 1992-2020 Free Software Foundation, Inc.
7006324dcfSchristos
7106324dcfSchristos This file is part of GNU Binutils.
7206324dcfSchristos
7306324dcfSchristos This program is free software; you can redistribute it and/or modify
7406324dcfSchristos it under the terms of the GNU General Public License as published by
7506324dcfSchristos the Free Software Foundation; either version 3 of the License, or
7606324dcfSchristos (at your option) any later version.
7706324dcfSchristos
7806324dcfSchristos This program is distributed in the hope that it will be useful,
7906324dcfSchristos but WITHOUT ANY WARRANTY; without even the implied warranty of
8006324dcfSchristos MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
8106324dcfSchristos GNU General Public License for more details.
8206324dcfSchristos
8306324dcfSchristos You should have received a copy of the GNU General Public License
8406324dcfSchristos along with this program; if not, write to the Free Software
8506324dcfSchristos Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
8606324dcfSchristos MA 02110-1301, USA. */
8706324dcfSchristos
8806324dcfSchristos
8906324dcfSchristos /* Contributed by Steve Chamberlain
9006324dcfSchristos sac@cygnus.com
9106324dcfSchristos
9206324dcfSchristos */
9306324dcfSchristos #define DONTDECLARE_MALLOC
9406324dcfSchristos #include "sysdep.h"
9506324dcfSchristos #include "bfd.h"
9606324dcfSchristos #include "arsup.h"
9706324dcfSchristos extern int verbose;
9806324dcfSchristos extern int yylex (void);
9906324dcfSchristos static int yyerror (const char *);
10006324dcfSchristos
10106324dcfSchristos #line 102 "arparse.c" /* yacc.c:339 */
10206324dcfSchristos
10306324dcfSchristos # ifndef YY_NULLPTR
10406324dcfSchristos # if defined __cplusplus && 201103L <= __cplusplus
10506324dcfSchristos # define YY_NULLPTR nullptr
10606324dcfSchristos # else
10706324dcfSchristos # define YY_NULLPTR 0
10806324dcfSchristos # endif
10906324dcfSchristos # endif
11006324dcfSchristos
11106324dcfSchristos /* Enabling verbose error messages. */
11206324dcfSchristos #ifdef YYERROR_VERBOSE
11306324dcfSchristos # undef YYERROR_VERBOSE
11406324dcfSchristos # define YYERROR_VERBOSE 1
11506324dcfSchristos #else
11606324dcfSchristos # define YYERROR_VERBOSE 0
11706324dcfSchristos #endif
11806324dcfSchristos
11906324dcfSchristos /* In a future release of Bison, this section will be replaced
12006324dcfSchristos by #include "y.tab.h". */
12106324dcfSchristos #ifndef YY_YY_ARPARSE_H_INCLUDED
12206324dcfSchristos # define YY_YY_ARPARSE_H_INCLUDED
12306324dcfSchristos /* Debug traces. */
12406324dcfSchristos #ifndef YYDEBUG
12506324dcfSchristos # define YYDEBUG 0
12606324dcfSchristos #endif
12706324dcfSchristos #if YYDEBUG
12806324dcfSchristos extern int yydebug;
12906324dcfSchristos #endif
13006324dcfSchristos
13106324dcfSchristos /* Token type. */
132ed0d50c3Schristos #ifndef YYTOKENTYPE
133ed0d50c3Schristos # define YYTOKENTYPE
13406324dcfSchristos enum yytokentype
13506324dcfSchristos {
136ed0d50c3Schristos NEWLINE = 258,
137ed0d50c3Schristos VERBOSE = 259,
138ed0d50c3Schristos FILENAME = 260,
139ed0d50c3Schristos ADDLIB = 261,
140ed0d50c3Schristos LIST = 262,
141ed0d50c3Schristos ADDMOD = 263,
142ed0d50c3Schristos CLEAR = 264,
143ed0d50c3Schristos CREATE = 265,
144ed0d50c3Schristos DELETE = 266,
145ed0d50c3Schristos DIRECTORY = 267,
146ed0d50c3Schristos END = 268,
147ed0d50c3Schristos EXTRACT = 269,
148ed0d50c3Schristos FULLDIR = 270,
149ed0d50c3Schristos HELP = 271,
150ed0d50c3Schristos QUIT = 272,
151ed0d50c3Schristos REPLACE = 273,
152ed0d50c3Schristos SAVE = 274,
153ed0d50c3Schristos OPEN = 275
154ed0d50c3Schristos };
155ed0d50c3Schristos #endif
156ed0d50c3Schristos /* Tokens. */
157ed0d50c3Schristos #define NEWLINE 258
158ed0d50c3Schristos #define VERBOSE 259
159ed0d50c3Schristos #define FILENAME 260
160ed0d50c3Schristos #define ADDLIB 261
161ed0d50c3Schristos #define LIST 262
162ed0d50c3Schristos #define ADDMOD 263
163ed0d50c3Schristos #define CLEAR 264
164ed0d50c3Schristos #define CREATE 265
165ed0d50c3Schristos #define DELETE 266
166ed0d50c3Schristos #define DIRECTORY 267
167ed0d50c3Schristos #define END 268
168ed0d50c3Schristos #define EXTRACT 269
169ed0d50c3Schristos #define FULLDIR 270
170ed0d50c3Schristos #define HELP 271
171ed0d50c3Schristos #define QUIT 272
172ed0d50c3Schristos #define REPLACE 273
173ed0d50c3Schristos #define SAVE 274
174ed0d50c3Schristos #define OPEN 275
175ed0d50c3Schristos
17606324dcfSchristos /* Value type. */
177ed0d50c3Schristos #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
17806324dcfSchristos
17906324dcfSchristos union YYSTYPE
180ed0d50c3Schristos {
18106324dcfSchristos #line 37 "arparse.y" /* yacc.c:355 */
18206324dcfSchristos
183ed0d50c3Schristos char *name;
184ed0d50c3Schristos struct list *list ;
185ed0d50c3Schristos
18606324dcfSchristos
18706324dcfSchristos #line 188 "arparse.c" /* yacc.c:355 */
18806324dcfSchristos };
18906324dcfSchristos
19006324dcfSchristos typedef union YYSTYPE YYSTYPE;
191ed0d50c3Schristos # define YYSTYPE_IS_TRIVIAL 1
19206324dcfSchristos # define YYSTYPE_IS_DECLARED 1
193ed0d50c3Schristos #endif
194ed0d50c3Schristos
195ed0d50c3Schristos
19606324dcfSchristos extern YYSTYPE yylval;
19706324dcfSchristos
19806324dcfSchristos int yyparse (void);
19906324dcfSchristos
20006324dcfSchristos #endif /* !YY_YY_ARPARSE_H_INCLUDED */
201ed0d50c3Schristos
202ed0d50c3Schristos /* Copy the second part of user declarations. */
203ed0d50c3Schristos
20406324dcfSchristos #line 205 "arparse.c" /* yacc.c:358 */
205ed0d50c3Schristos
206ed0d50c3Schristos #ifdef short
207ed0d50c3Schristos # undef short
208ed0d50c3Schristos #endif
209ed0d50c3Schristos
210ed0d50c3Schristos #ifdef YYTYPE_UINT8
211ed0d50c3Schristos typedef YYTYPE_UINT8 yytype_uint8;
212ed0d50c3Schristos #else
213ed0d50c3Schristos typedef unsigned char yytype_uint8;
214ed0d50c3Schristos #endif
215ed0d50c3Schristos
216ed0d50c3Schristos #ifdef YYTYPE_INT8
217ed0d50c3Schristos typedef YYTYPE_INT8 yytype_int8;
218ed0d50c3Schristos #else
21906324dcfSchristos typedef signed char yytype_int8;
220ed0d50c3Schristos #endif
221ed0d50c3Schristos
222ed0d50c3Schristos #ifdef YYTYPE_UINT16
223ed0d50c3Schristos typedef YYTYPE_UINT16 yytype_uint16;
224ed0d50c3Schristos #else
225ed0d50c3Schristos typedef unsigned short int yytype_uint16;
226ed0d50c3Schristos #endif
227ed0d50c3Schristos
228ed0d50c3Schristos #ifdef YYTYPE_INT16
229ed0d50c3Schristos typedef YYTYPE_INT16 yytype_int16;
230ed0d50c3Schristos #else
231ed0d50c3Schristos typedef short int yytype_int16;
232ed0d50c3Schristos #endif
233ed0d50c3Schristos
234ed0d50c3Schristos #ifndef YYSIZE_T
235ed0d50c3Schristos # ifdef __SIZE_TYPE__
236ed0d50c3Schristos # define YYSIZE_T __SIZE_TYPE__
237ed0d50c3Schristos # elif defined size_t
238ed0d50c3Schristos # define YYSIZE_T size_t
23906324dcfSchristos # elif ! defined YYSIZE_T
240ed0d50c3Schristos # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
241ed0d50c3Schristos # define YYSIZE_T size_t
242ed0d50c3Schristos # else
243ed0d50c3Schristos # define YYSIZE_T unsigned int
244ed0d50c3Schristos # endif
245ed0d50c3Schristos #endif
246ed0d50c3Schristos
247ed0d50c3Schristos #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
248ed0d50c3Schristos
249ed0d50c3Schristos #ifndef YY_
250ed0d50c3Schristos # if defined YYENABLE_NLS && YYENABLE_NLS
251ed0d50c3Schristos # if ENABLE_NLS
252ed0d50c3Schristos # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
25306324dcfSchristos # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
254ed0d50c3Schristos # endif
255ed0d50c3Schristos # endif
256ed0d50c3Schristos # ifndef YY_
25706324dcfSchristos # define YY_(Msgid) Msgid
25806324dcfSchristos # endif
25906324dcfSchristos #endif
26006324dcfSchristos
26106324dcfSchristos #ifndef YY_ATTRIBUTE
26206324dcfSchristos # if (defined __GNUC__ \
26306324dcfSchristos && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
26406324dcfSchristos || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
26506324dcfSchristos # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
26606324dcfSchristos # else
26706324dcfSchristos # define YY_ATTRIBUTE(Spec) /* empty */
26806324dcfSchristos # endif
26906324dcfSchristos #endif
27006324dcfSchristos
27106324dcfSchristos #ifndef YY_ATTRIBUTE_PURE
27206324dcfSchristos # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
27306324dcfSchristos #endif
27406324dcfSchristos
27506324dcfSchristos #ifndef YY_ATTRIBUTE_UNUSED
27606324dcfSchristos # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
27706324dcfSchristos #endif
27806324dcfSchristos
27906324dcfSchristos #if !defined _Noreturn \
28006324dcfSchristos && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
28106324dcfSchristos # if defined _MSC_VER && 1200 <= _MSC_VER
28206324dcfSchristos # define _Noreturn __declspec (noreturn)
28306324dcfSchristos # else
28406324dcfSchristos # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
285ed0d50c3Schristos # endif
286ed0d50c3Schristos #endif
287ed0d50c3Schristos
288ed0d50c3Schristos /* Suppress unused-variable warnings by "using" E. */
289ed0d50c3Schristos #if ! defined lint || defined __GNUC__
29006324dcfSchristos # define YYUSE(E) ((void) (E))
291ed0d50c3Schristos #else
29206324dcfSchristos # define YYUSE(E) /* empty */
293ed0d50c3Schristos #endif
294ed0d50c3Schristos
29506324dcfSchristos #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
29606324dcfSchristos /* Suppress an incorrect diagnostic about yylval being uninitialized. */
29706324dcfSchristos # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
29806324dcfSchristos _Pragma ("GCC diagnostic push") \
29906324dcfSchristos _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
30006324dcfSchristos _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
30106324dcfSchristos # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
30206324dcfSchristos _Pragma ("GCC diagnostic pop")
303ed0d50c3Schristos #else
30406324dcfSchristos # define YY_INITIAL_VALUE(Value) Value
305ed0d50c3Schristos #endif
30606324dcfSchristos #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
30706324dcfSchristos # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
30806324dcfSchristos # define YY_IGNORE_MAYBE_UNINITIALIZED_END
309ed0d50c3Schristos #endif
31006324dcfSchristos #ifndef YY_INITIAL_VALUE
31106324dcfSchristos # define YY_INITIAL_VALUE(Value) /* Nothing. */
31206324dcfSchristos #endif
31306324dcfSchristos
314ed0d50c3Schristos
315ed0d50c3Schristos #if ! defined yyoverflow || YYERROR_VERBOSE
316ed0d50c3Schristos
317ed0d50c3Schristos /* The parser invokes alloca or malloc; define the necessary symbols. */
318ed0d50c3Schristos
319ed0d50c3Schristos # ifdef YYSTACK_USE_ALLOCA
320ed0d50c3Schristos # if YYSTACK_USE_ALLOCA
321ed0d50c3Schristos # ifdef __GNUC__
322ed0d50c3Schristos # define YYSTACK_ALLOC __builtin_alloca
323ed0d50c3Schristos # elif defined __BUILTIN_VA_ARG_INCR
324ed0d50c3Schristos # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
325ed0d50c3Schristos # elif defined _AIX
326ed0d50c3Schristos # define YYSTACK_ALLOC __alloca
327ed0d50c3Schristos # elif defined _MSC_VER
328ed0d50c3Schristos # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
329ed0d50c3Schristos # define alloca _alloca
330ed0d50c3Schristos # else
331ed0d50c3Schristos # define YYSTACK_ALLOC alloca
33206324dcfSchristos # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
333ed0d50c3Schristos # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
33406324dcfSchristos /* Use EXIT_SUCCESS as a witness for stdlib.h. */
33506324dcfSchristos # ifndef EXIT_SUCCESS
33606324dcfSchristos # define EXIT_SUCCESS 0
337ed0d50c3Schristos # endif
338ed0d50c3Schristos # endif
339ed0d50c3Schristos # endif
340ed0d50c3Schristos # endif
341ed0d50c3Schristos # endif
342ed0d50c3Schristos
343ed0d50c3Schristos # ifdef YYSTACK_ALLOC
34406324dcfSchristos /* Pacify GCC's 'empty if-body' warning. */
34506324dcfSchristos # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
346ed0d50c3Schristos # ifndef YYSTACK_ALLOC_MAXIMUM
347ed0d50c3Schristos /* The OS might guarantee only one guard page at the bottom of the stack,
348ed0d50c3Schristos and a page size can be as small as 4096 bytes. So we cannot safely
349ed0d50c3Schristos invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
350ed0d50c3Schristos to allow for a few compiler-allocated temporary stack slots. */
351ed0d50c3Schristos # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
352ed0d50c3Schristos # endif
353ed0d50c3Schristos # else
354ed0d50c3Schristos # define YYSTACK_ALLOC YYMALLOC
355ed0d50c3Schristos # define YYSTACK_FREE YYFREE
356ed0d50c3Schristos # ifndef YYSTACK_ALLOC_MAXIMUM
357ed0d50c3Schristos # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
358ed0d50c3Schristos # endif
35906324dcfSchristos # if (defined __cplusplus && ! defined EXIT_SUCCESS \
360ed0d50c3Schristos && ! ((defined YYMALLOC || defined malloc) \
361ed0d50c3Schristos && (defined YYFREE || defined free)))
362ed0d50c3Schristos # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
36306324dcfSchristos # ifndef EXIT_SUCCESS
36406324dcfSchristos # define EXIT_SUCCESS 0
365ed0d50c3Schristos # endif
366ed0d50c3Schristos # endif
367ed0d50c3Schristos # ifndef YYMALLOC
368ed0d50c3Schristos # define YYMALLOC malloc
36906324dcfSchristos # if ! defined malloc && ! defined EXIT_SUCCESS
370ed0d50c3Schristos void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
371ed0d50c3Schristos # endif
372ed0d50c3Schristos # endif
373ed0d50c3Schristos # ifndef YYFREE
374ed0d50c3Schristos # define YYFREE free
37506324dcfSchristos # if ! defined free && ! defined EXIT_SUCCESS
376ed0d50c3Schristos void free (void *); /* INFRINGES ON USER NAME SPACE */
377ed0d50c3Schristos # endif
378ed0d50c3Schristos # endif
379ed0d50c3Schristos # endif
380ed0d50c3Schristos #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
381ed0d50c3Schristos
382ed0d50c3Schristos
383ed0d50c3Schristos #if (! defined yyoverflow \
384ed0d50c3Schristos && (! defined __cplusplus \
385ed0d50c3Schristos || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
386ed0d50c3Schristos
387ed0d50c3Schristos /* A type that is properly aligned for any stack member. */
388ed0d50c3Schristos union yyalloc
389ed0d50c3Schristos {
39006324dcfSchristos yytype_int16 yyss_alloc;
39106324dcfSchristos YYSTYPE yyvs_alloc;
392ed0d50c3Schristos };
393ed0d50c3Schristos
394ed0d50c3Schristos /* The size of the maximum gap between one aligned stack and the next. */
395ed0d50c3Schristos # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
396ed0d50c3Schristos
397ed0d50c3Schristos /* The size of an array large to enough to hold all stacks, each with
398ed0d50c3Schristos N elements. */
399ed0d50c3Schristos # define YYSTACK_BYTES(N) \
400ed0d50c3Schristos ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
401ed0d50c3Schristos + YYSTACK_GAP_MAXIMUM)
402ed0d50c3Schristos
40306324dcfSchristos # define YYCOPY_NEEDED 1
404ed0d50c3Schristos
405ed0d50c3Schristos /* Relocate STACK from its old location to the new one. The
406ed0d50c3Schristos local variables YYSIZE and YYSTACKSIZE give the old and new number of
407ed0d50c3Schristos elements in the stack, and YYPTR gives the new location of the
408ed0d50c3Schristos stack. Advance YYPTR to a properly aligned location for the next
409ed0d50c3Schristos stack. */
41006324dcfSchristos # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
411ed0d50c3Schristos do \
412ed0d50c3Schristos { \
413ed0d50c3Schristos YYSIZE_T yynewbytes; \
41406324dcfSchristos YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
41506324dcfSchristos Stack = &yyptr->Stack_alloc; \
416ed0d50c3Schristos yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
417ed0d50c3Schristos yyptr += yynewbytes / sizeof (*yyptr); \
418ed0d50c3Schristos } \
41906324dcfSchristos while (0)
420ed0d50c3Schristos
421ed0d50c3Schristos #endif
422ed0d50c3Schristos
42306324dcfSchristos #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
42406324dcfSchristos /* Copy COUNT objects from SRC to DST. The source and destination do
42506324dcfSchristos not overlap. */
42606324dcfSchristos # ifndef YYCOPY
42706324dcfSchristos # if defined __GNUC__ && 1 < __GNUC__
42806324dcfSchristos # define YYCOPY(Dst, Src, Count) \
42906324dcfSchristos __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
43006324dcfSchristos # else
43106324dcfSchristos # define YYCOPY(Dst, Src, Count) \
43206324dcfSchristos do \
43306324dcfSchristos { \
43406324dcfSchristos YYSIZE_T yyi; \
43506324dcfSchristos for (yyi = 0; yyi < (Count); yyi++) \
43606324dcfSchristos (Dst)[yyi] = (Src)[yyi]; \
43706324dcfSchristos } \
43806324dcfSchristos while (0)
43906324dcfSchristos # endif
44006324dcfSchristos # endif
44106324dcfSchristos #endif /* !YYCOPY_NEEDED */
44206324dcfSchristos
443ed0d50c3Schristos /* YYFINAL -- State number of the termination state. */
444ed0d50c3Schristos #define YYFINAL 3
445ed0d50c3Schristos /* YYLAST -- Last index in YYTABLE. */
446ed0d50c3Schristos #define YYLAST 34
447ed0d50c3Schristos
448ed0d50c3Schristos /* YYNTOKENS -- Number of terminals. */
449ed0d50c3Schristos #define YYNTOKENS 24
450ed0d50c3Schristos /* YYNNTS -- Number of nonterminals. */
451ed0d50c3Schristos #define YYNNTS 22
452ed0d50c3Schristos /* YYNRULES -- Number of rules. */
453ed0d50c3Schristos #define YYNRULES 42
45406324dcfSchristos /* YYNSTATES -- Number of states. */
455ed0d50c3Schristos #define YYNSTATES 53
456ed0d50c3Schristos
45706324dcfSchristos /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
45806324dcfSchristos by yylex, with out-of-bounds checking. */
459ed0d50c3Schristos #define YYUNDEFTOK 2
460ed0d50c3Schristos #define YYMAXUTOK 275
461ed0d50c3Schristos
462ed0d50c3Schristos #define YYTRANSLATE(YYX) \
463ed0d50c3Schristos ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
464ed0d50c3Schristos
46506324dcfSchristos /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
46606324dcfSchristos as returned by yylex, without out-of-bounds checking. */
467ed0d50c3Schristos static const yytype_uint8 yytranslate[] =
468ed0d50c3Schristos {
469ed0d50c3Schristos 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
470ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
471ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
472ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
473ed0d50c3Schristos 21, 22, 2, 2, 23, 2, 2, 2, 2, 2,
474ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
475ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
476ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
477ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
478ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
479ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
480ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
481ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
482ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
483ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
484ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
485ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
486ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
487ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
488ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
489ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
490ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
491ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
492ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
493ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
494ed0d50c3Schristos 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
495ed0d50c3Schristos 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
496ed0d50c3Schristos 15, 16, 17, 18, 19, 20
497ed0d50c3Schristos };
498ed0d50c3Schristos
499ed0d50c3Schristos #if YYDEBUG
50006324dcfSchristos /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
501ed0d50c3Schristos static const yytype_uint8 yyrline[] =
502ed0d50c3Schristos {
503ed0d50c3Schristos 0, 68, 68, 68, 72, 73, 77, 81, 82, 83,
504ed0d50c3Schristos 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
505ed0d50c3Schristos 94, 95, 96, 101, 106, 111, 116, 120, 125, 130,
506ed0d50c3Schristos 137, 142, 148, 152, 159, 161, 165, 168, 172, 178,
507ed0d50c3Schristos 183, 184, 189
508ed0d50c3Schristos };
509ed0d50c3Schristos #endif
510ed0d50c3Schristos
51106324dcfSchristos #if YYDEBUG || YYERROR_VERBOSE || 0
512ed0d50c3Schristos /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
513ed0d50c3Schristos First, the terminals, then, starting at YYNTOKENS, nonterminals. */
514ed0d50c3Schristos static const char *const yytname[] =
515ed0d50c3Schristos {
516ed0d50c3Schristos "$end", "error", "$undefined", "NEWLINE", "VERBOSE", "FILENAME",
517ed0d50c3Schristos "ADDLIB", "LIST", "ADDMOD", "CLEAR", "CREATE", "DELETE", "DIRECTORY",
518ed0d50c3Schristos "END", "EXTRACT", "FULLDIR", "HELP", "QUIT", "REPLACE", "SAVE", "OPEN",
51906324dcfSchristos "'('", "')'", "','", "$accept", "start", "$@1", "session",
52006324dcfSchristos "command_line", "command", "extract_command", "replace_command",
52106324dcfSchristos "clear_command", "delete_command", "addmod_command", "list_command",
52206324dcfSchristos "save_command", "open_command", "create_command", "addlib_command",
52306324dcfSchristos "directory_command", "optional_filename", "modulelist", "modulename",
52406324dcfSchristos "optcomma", "verbose_command", YY_NULLPTR
525ed0d50c3Schristos };
526ed0d50c3Schristos #endif
527ed0d50c3Schristos
528ed0d50c3Schristos # ifdef YYPRINT
52906324dcfSchristos /* YYTOKNUM[NUM] -- (External) token number corresponding to the
53006324dcfSchristos (internal) symbol number NUM (which must be that of a token). */
531ed0d50c3Schristos static const yytype_uint16 yytoknum[] =
532ed0d50c3Schristos {
533ed0d50c3Schristos 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
534ed0d50c3Schristos 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
535ed0d50c3Schristos 275, 40, 41, 44
536ed0d50c3Schristos };
537ed0d50c3Schristos # endif
538ed0d50c3Schristos
53906324dcfSchristos #define YYPACT_NINF -14
54006324dcfSchristos
54106324dcfSchristos #define yypact_value_is_default(Yystate) \
54206324dcfSchristos (!!((Yystate) == (-14)))
54306324dcfSchristos
54406324dcfSchristos #define YYTABLE_NINF -42
54506324dcfSchristos
54606324dcfSchristos #define yytable_value_is_error(Yytable_value) \
54706324dcfSchristos 0
54806324dcfSchristos
54906324dcfSchristos /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
55006324dcfSchristos STATE-NUM. */
55106324dcfSchristos static const yytype_int8 yypact[] =
552ed0d50c3Schristos {
55306324dcfSchristos -14, 1, -14, -14, 5, -14, -14, -14, 2, -14,
55406324dcfSchristos -14, -14, 21, -14, 22, -14, -14, -14, -14, 23,
55506324dcfSchristos -14, 26, -14, -14, -14, -14, -14, -14, -14, -14,
55606324dcfSchristos -14, -14, -14, -14, 10, -3, -14, -3, 10, -3,
55706324dcfSchristos -3, -14, -14, -14, -14, -14, 27, 28, -1, -14,
55806324dcfSchristos -14, -14, -14
559ed0d50c3Schristos };
560ed0d50c3Schristos
56106324dcfSchristos /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
56206324dcfSchristos Performed when YYTABLE does not specify something else to do. Zero
563ed0d50c3Schristos means the default is an error. */
564ed0d50c3Schristos static const yytype_uint8 yydefact[] =
565ed0d50c3Schristos {
566ed0d50c3Schristos 2, 0, 5, 1, 0, 20, 42, 21, 0, 28,
567ed0d50c3Schristos 39, 25, 0, 39, 0, 19, 39, 39, 29, 0,
568ed0d50c3Schristos 4, 0, 15, 16, 12, 17, 13, 18, 14, 7,
569ed0d50c3Schristos 8, 11, 10, 9, 37, 27, 31, 26, 37, 23,
570ed0d50c3Schristos 24, 30, 6, 39, 32, 40, 0, 35, 41, 38,
571ed0d50c3Schristos 34, 33, 36
572ed0d50c3Schristos };
573ed0d50c3Schristos
574ed0d50c3Schristos /* YYPGOTO[NTERM-NUM]. */
575ed0d50c3Schristos static const yytype_int8 yypgoto[] =
576ed0d50c3Schristos {
577ed0d50c3Schristos -14, -14, -14, -14, -14, -14, -14, -14, -14, -14,
578ed0d50c3Schristos -14, -14, -14, -14, -14, -14, -14, -14, -4, -13,
579ed0d50c3Schristos -14, -14
580ed0d50c3Schristos };
581ed0d50c3Schristos
58206324dcfSchristos /* YYDEFGOTO[NTERM-NUM]. */
58306324dcfSchristos static const yytype_int8 yydefgoto[] =
58406324dcfSchristos {
58506324dcfSchristos -1, 1, 2, 4, 20, 21, 22, 23, 24, 25,
58606324dcfSchristos 26, 27, 28, 29, 30, 31, 32, 51, 44, 35,
58706324dcfSchristos 46, 33
58806324dcfSchristos };
58906324dcfSchristos
59006324dcfSchristos /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
59106324dcfSchristos positive, shift that token. If negative, reduce the rule whose
59206324dcfSchristos number is the opposite. If YYTABLE_NINF, syntax error. */
593ed0d50c3Schristos static const yytype_int8 yytable[] =
594ed0d50c3Schristos {
595ed0d50c3Schristos 37, 3, -41, 39, 40, -3, 5, 34, -22, 6,
596ed0d50c3Schristos 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
597ed0d50c3Schristos 45, 52, 45, 17, 18, 19, 36, 38, 41, 42,
598ed0d50c3Schristos 48, 43, 49, 50, 47
599ed0d50c3Schristos };
600ed0d50c3Schristos
601ed0d50c3Schristos static const yytype_uint8 yycheck[] =
602ed0d50c3Schristos {
603ed0d50c3Schristos 13, 0, 5, 16, 17, 0, 1, 5, 3, 4,
604ed0d50c3Schristos 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
605ed0d50c3Schristos 23, 22, 23, 18, 19, 20, 5, 5, 5, 3,
606ed0d50c3Schristos 43, 21, 5, 5, 38
607ed0d50c3Schristos };
608ed0d50c3Schristos
609ed0d50c3Schristos /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
610ed0d50c3Schristos symbol of state STATE-NUM. */
611ed0d50c3Schristos static const yytype_uint8 yystos[] =
612ed0d50c3Schristos {
613ed0d50c3Schristos 0, 25, 26, 0, 27, 1, 4, 5, 6, 7,
614ed0d50c3Schristos 8, 9, 10, 11, 12, 13, 14, 18, 19, 20,
615ed0d50c3Schristos 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
616ed0d50c3Schristos 38, 39, 40, 45, 5, 43, 5, 43, 5, 43,
617ed0d50c3Schristos 43, 5, 3, 21, 42, 23, 44, 42, 43, 5,
618ed0d50c3Schristos 5, 41, 22
619ed0d50c3Schristos };
620ed0d50c3Schristos
62106324dcfSchristos /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
62206324dcfSchristos static const yytype_uint8 yyr1[] =
62306324dcfSchristos {
62406324dcfSchristos 0, 24, 26, 25, 27, 27, 28, 29, 29, 29,
62506324dcfSchristos 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
62606324dcfSchristos 29, 29, 29, 30, 31, 32, 33, 34, 35, 36,
62706324dcfSchristos 37, 38, 39, 40, 41, 41, 42, 42, 43, 43,
62806324dcfSchristos 44, 44, 45
62906324dcfSchristos };
63006324dcfSchristos
63106324dcfSchristos /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
63206324dcfSchristos static const yytype_uint8 yyr2[] =
63306324dcfSchristos {
63406324dcfSchristos 0, 2, 0, 2, 2, 0, 2, 1, 1, 1,
63506324dcfSchristos 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
63606324dcfSchristos 1, 1, 0, 2, 2, 1, 2, 2, 1, 1,
63706324dcfSchristos 2, 2, 3, 4, 1, 0, 3, 0, 3, 0,
63806324dcfSchristos 1, 0, 1
63906324dcfSchristos };
64006324dcfSchristos
64106324dcfSchristos
642ed0d50c3Schristos #define yyerrok (yyerrstatus = 0)
643ed0d50c3Schristos #define yyclearin (yychar = YYEMPTY)
644ed0d50c3Schristos #define YYEMPTY (-2)
645ed0d50c3Schristos #define YYEOF 0
646ed0d50c3Schristos
647ed0d50c3Schristos #define YYACCEPT goto yyacceptlab
648ed0d50c3Schristos #define YYABORT goto yyabortlab
649ed0d50c3Schristos #define YYERROR goto yyerrorlab
650ed0d50c3Schristos
651ed0d50c3Schristos
652ed0d50c3Schristos #define YYRECOVERING() (!!yyerrstatus)
653ed0d50c3Schristos
654ed0d50c3Schristos #define YYBACKUP(Token, Value) \
655ed0d50c3Schristos do \
65606324dcfSchristos if (yychar == YYEMPTY) \
657ed0d50c3Schristos { \
658ed0d50c3Schristos yychar = (Token); \
659ed0d50c3Schristos yylval = (Value); \
66006324dcfSchristos YYPOPSTACK (yylen); \
66106324dcfSchristos yystate = *yyssp; \
662ed0d50c3Schristos goto yybackup; \
663ed0d50c3Schristos } \
664ed0d50c3Schristos else \
665ed0d50c3Schristos { \
666ed0d50c3Schristos yyerror (YY_("syntax error: cannot back up")); \
667ed0d50c3Schristos YYERROR; \
668ed0d50c3Schristos } \
66906324dcfSchristos while (0)
670ed0d50c3Schristos
67106324dcfSchristos /* Error token number */
672ed0d50c3Schristos #define YYTERROR 1
673ed0d50c3Schristos #define YYERRCODE 256
674ed0d50c3Schristos
675ed0d50c3Schristos
676ed0d50c3Schristos
677ed0d50c3Schristos /* Enable debugging if requested. */
678ed0d50c3Schristos #if YYDEBUG
679ed0d50c3Schristos
680ed0d50c3Schristos # ifndef YYFPRINTF
681ed0d50c3Schristos # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
682ed0d50c3Schristos # define YYFPRINTF fprintf
683ed0d50c3Schristos # endif
684ed0d50c3Schristos
685ed0d50c3Schristos # define YYDPRINTF(Args) \
686ed0d50c3Schristos do { \
687ed0d50c3Schristos if (yydebug) \
688ed0d50c3Schristos YYFPRINTF Args; \
68906324dcfSchristos } while (0)
69006324dcfSchristos
69106324dcfSchristos /* This macro is provided for backward compatibility. */
69206324dcfSchristos #ifndef YY_LOCATION_PRINT
69306324dcfSchristos # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
69406324dcfSchristos #endif
69506324dcfSchristos
696ed0d50c3Schristos
697ed0d50c3Schristos # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
698ed0d50c3Schristos do { \
699ed0d50c3Schristos if (yydebug) \
700ed0d50c3Schristos { \
701ed0d50c3Schristos YYFPRINTF (stderr, "%s ", Title); \
702ed0d50c3Schristos yy_symbol_print (stderr, \
703ed0d50c3Schristos Type, Value); \
704ed0d50c3Schristos YYFPRINTF (stderr, "\n"); \
705ed0d50c3Schristos } \
70606324dcfSchristos } while (0)
707ed0d50c3Schristos
708ed0d50c3Schristos
70906324dcfSchristos /*----------------------------------------.
71006324dcfSchristos | Print this symbol's value on YYOUTPUT. |
71106324dcfSchristos `----------------------------------------*/
712ed0d50c3Schristos
713ed0d50c3Schristos static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)714ed0d50c3Schristos yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
715ed0d50c3Schristos {
71606324dcfSchristos FILE *yyo = yyoutput;
71706324dcfSchristos YYUSE (yyo);
718ed0d50c3Schristos if (!yyvaluep)
719ed0d50c3Schristos return;
720ed0d50c3Schristos # ifdef YYPRINT
721ed0d50c3Schristos if (yytype < YYNTOKENS)
722ed0d50c3Schristos YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
723ed0d50c3Schristos # endif
72406324dcfSchristos YYUSE (yytype);
725ed0d50c3Schristos }
726ed0d50c3Schristos
727ed0d50c3Schristos
728ed0d50c3Schristos /*--------------------------------.
729ed0d50c3Schristos | Print this symbol on YYOUTPUT. |
730ed0d50c3Schristos `--------------------------------*/
731ed0d50c3Schristos
732ed0d50c3Schristos static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)733ed0d50c3Schristos yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
734ed0d50c3Schristos {
73506324dcfSchristos YYFPRINTF (yyoutput, "%s %s (",
73606324dcfSchristos yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
737ed0d50c3Schristos
738ed0d50c3Schristos yy_symbol_value_print (yyoutput, yytype, yyvaluep);
739ed0d50c3Schristos YYFPRINTF (yyoutput, ")");
740ed0d50c3Schristos }
741ed0d50c3Schristos
742ed0d50c3Schristos /*------------------------------------------------------------------.
743ed0d50c3Schristos | yy_stack_print -- Print the state stack from its BOTTOM up to its |
744ed0d50c3Schristos | TOP (included). |
745ed0d50c3Schristos `------------------------------------------------------------------*/
746ed0d50c3Schristos
747ed0d50c3Schristos static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)74806324dcfSchristos yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
749ed0d50c3Schristos {
750ed0d50c3Schristos YYFPRINTF (stderr, "Stack now");
75106324dcfSchristos for (; yybottom <= yytop; yybottom++)
75206324dcfSchristos {
75306324dcfSchristos int yybot = *yybottom;
75406324dcfSchristos YYFPRINTF (stderr, " %d", yybot);
75506324dcfSchristos }
756ed0d50c3Schristos YYFPRINTF (stderr, "\n");
757ed0d50c3Schristos }
758ed0d50c3Schristos
759ed0d50c3Schristos # define YY_STACK_PRINT(Bottom, Top) \
760ed0d50c3Schristos do { \
761ed0d50c3Schristos if (yydebug) \
762ed0d50c3Schristos yy_stack_print ((Bottom), (Top)); \
76306324dcfSchristos } while (0)
764ed0d50c3Schristos
765ed0d50c3Schristos
766ed0d50c3Schristos /*------------------------------------------------.
767ed0d50c3Schristos | Report that the YYRULE is going to be reduced. |
768ed0d50c3Schristos `------------------------------------------------*/
769ed0d50c3Schristos
770ed0d50c3Schristos static void
yy_reduce_print(yytype_int16 * yyssp,YYSTYPE * yyvsp,int yyrule)77106324dcfSchristos yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
772ed0d50c3Schristos {
77306324dcfSchristos unsigned long int yylno = yyrline[yyrule];
774ed0d50c3Schristos int yynrhs = yyr2[yyrule];
775ed0d50c3Schristos int yyi;
776ed0d50c3Schristos YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
777ed0d50c3Schristos yyrule - 1, yylno);
778ed0d50c3Schristos /* The symbols being reduced. */
779ed0d50c3Schristos for (yyi = 0; yyi < yynrhs; yyi++)
780ed0d50c3Schristos {
78106324dcfSchristos YYFPRINTF (stderr, " $%d = ", yyi + 1);
78206324dcfSchristos yy_symbol_print (stderr,
78306324dcfSchristos yystos[yyssp[yyi + 1 - yynrhs]],
784ed0d50c3Schristos &(yyvsp[(yyi + 1) - (yynrhs)])
785ed0d50c3Schristos );
78606324dcfSchristos YYFPRINTF (stderr, "\n");
787ed0d50c3Schristos }
788ed0d50c3Schristos }
789ed0d50c3Schristos
790ed0d50c3Schristos # define YY_REDUCE_PRINT(Rule) \
791ed0d50c3Schristos do { \
792ed0d50c3Schristos if (yydebug) \
79306324dcfSchristos yy_reduce_print (yyssp, yyvsp, Rule); \
79406324dcfSchristos } while (0)
795ed0d50c3Schristos
796ed0d50c3Schristos /* Nonzero means print parse trace. It is left uninitialized so that
797ed0d50c3Schristos multiple parsers can coexist. */
798ed0d50c3Schristos int yydebug;
799ed0d50c3Schristos #else /* !YYDEBUG */
800ed0d50c3Schristos # define YYDPRINTF(Args)
801ed0d50c3Schristos # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
802ed0d50c3Schristos # define YY_STACK_PRINT(Bottom, Top)
803ed0d50c3Schristos # define YY_REDUCE_PRINT(Rule)
804ed0d50c3Schristos #endif /* !YYDEBUG */
805ed0d50c3Schristos
806ed0d50c3Schristos
807ed0d50c3Schristos /* YYINITDEPTH -- initial size of the parser's stacks. */
808ed0d50c3Schristos #ifndef YYINITDEPTH
809ed0d50c3Schristos # define YYINITDEPTH 200
810ed0d50c3Schristos #endif
811ed0d50c3Schristos
812ed0d50c3Schristos /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
813ed0d50c3Schristos if the built-in stack extension method is used).
814ed0d50c3Schristos
815ed0d50c3Schristos Do not make this value too large; the results are undefined if
816ed0d50c3Schristos YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
817ed0d50c3Schristos evaluated with infinite-precision integer arithmetic. */
818ed0d50c3Schristos
819ed0d50c3Schristos #ifndef YYMAXDEPTH
820ed0d50c3Schristos # define YYMAXDEPTH 10000
821ed0d50c3Schristos #endif
822ed0d50c3Schristos
823ed0d50c3Schristos
824ed0d50c3Schristos #if YYERROR_VERBOSE
825ed0d50c3Schristos
826ed0d50c3Schristos # ifndef yystrlen
827ed0d50c3Schristos # if defined __GLIBC__ && defined _STRING_H
828ed0d50c3Schristos # define yystrlen strlen
829ed0d50c3Schristos # else
830ed0d50c3Schristos /* Return the length of YYSTR. */
831ed0d50c3Schristos static YYSIZE_T
yystrlen(const char * yystr)832ed0d50c3Schristos yystrlen (const char *yystr)
833ed0d50c3Schristos {
834ed0d50c3Schristos YYSIZE_T yylen;
835ed0d50c3Schristos for (yylen = 0; yystr[yylen]; yylen++)
836ed0d50c3Schristos continue;
837ed0d50c3Schristos return yylen;
838ed0d50c3Schristos }
839ed0d50c3Schristos # endif
840ed0d50c3Schristos # endif
841ed0d50c3Schristos
842ed0d50c3Schristos # ifndef yystpcpy
843ed0d50c3Schristos # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
844ed0d50c3Schristos # define yystpcpy stpcpy
845ed0d50c3Schristos # else
846ed0d50c3Schristos /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
847ed0d50c3Schristos YYDEST. */
848ed0d50c3Schristos static char *
yystpcpy(char * yydest,const char * yysrc)849ed0d50c3Schristos yystpcpy (char *yydest, const char *yysrc)
850ed0d50c3Schristos {
851ed0d50c3Schristos char *yyd = yydest;
852ed0d50c3Schristos const char *yys = yysrc;
853ed0d50c3Schristos
854ed0d50c3Schristos while ((*yyd++ = *yys++) != '\0')
855ed0d50c3Schristos continue;
856ed0d50c3Schristos
857ed0d50c3Schristos return yyd - 1;
858ed0d50c3Schristos }
859ed0d50c3Schristos # endif
860ed0d50c3Schristos # endif
861ed0d50c3Schristos
862ed0d50c3Schristos # ifndef yytnamerr
863ed0d50c3Schristos /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
864ed0d50c3Schristos quotes and backslashes, so that it's suitable for yyerror. The
865ed0d50c3Schristos heuristic is that double-quoting is unnecessary unless the string
866ed0d50c3Schristos contains an apostrophe, a comma, or backslash (other than
867ed0d50c3Schristos backslash-backslash). YYSTR is taken from yytname. If YYRES is
868ed0d50c3Schristos null, do not copy; instead, return the length of what the result
869ed0d50c3Schristos would have been. */
870ed0d50c3Schristos static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)871ed0d50c3Schristos yytnamerr (char *yyres, const char *yystr)
872ed0d50c3Schristos {
873ed0d50c3Schristos if (*yystr == '"')
874ed0d50c3Schristos {
875ed0d50c3Schristos YYSIZE_T yyn = 0;
876ed0d50c3Schristos char const *yyp = yystr;
877ed0d50c3Schristos
878ed0d50c3Schristos for (;;)
879ed0d50c3Schristos switch (*++yyp)
880ed0d50c3Schristos {
881ed0d50c3Schristos case '\'':
882ed0d50c3Schristos case ',':
883ed0d50c3Schristos goto do_not_strip_quotes;
884ed0d50c3Schristos
885ed0d50c3Schristos case '\\':
886ed0d50c3Schristos if (*++yyp != '\\')
887ed0d50c3Schristos goto do_not_strip_quotes;
888ed0d50c3Schristos /* Fall through. */
889ed0d50c3Schristos default:
890ed0d50c3Schristos if (yyres)
891ed0d50c3Schristos yyres[yyn] = *yyp;
892ed0d50c3Schristos yyn++;
893ed0d50c3Schristos break;
894ed0d50c3Schristos
895ed0d50c3Schristos case '"':
896ed0d50c3Schristos if (yyres)
897ed0d50c3Schristos yyres[yyn] = '\0';
898ed0d50c3Schristos return yyn;
899ed0d50c3Schristos }
900ed0d50c3Schristos do_not_strip_quotes: ;
901ed0d50c3Schristos }
902ed0d50c3Schristos
903ed0d50c3Schristos if (! yyres)
904ed0d50c3Schristos return yystrlen (yystr);
905ed0d50c3Schristos
906ed0d50c3Schristos return yystpcpy (yyres, yystr) - yyres;
907ed0d50c3Schristos }
908ed0d50c3Schristos # endif
909ed0d50c3Schristos
91006324dcfSchristos /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
91106324dcfSchristos about the unexpected token YYTOKEN for the state stack whose top is
91206324dcfSchristos YYSSP.
913ed0d50c3Schristos
91406324dcfSchristos Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
91506324dcfSchristos not large enough to hold the message. In that case, also set
91606324dcfSchristos *YYMSG_ALLOC to the required number of bytes. Return 2 if the
91706324dcfSchristos required number of bytes is too large to store. */
91806324dcfSchristos static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)91906324dcfSchristos yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
92006324dcfSchristos yytype_int16 *yyssp, int yytoken)
921ed0d50c3Schristos {
92206324dcfSchristos YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
923ed0d50c3Schristos YYSIZE_T yysize = yysize0;
924ed0d50c3Schristos enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
92506324dcfSchristos /* Internationalized format string. */
92606324dcfSchristos const char *yyformat = YY_NULLPTR;
92706324dcfSchristos /* Arguments of yyformat. */
928ed0d50c3Schristos char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
92906324dcfSchristos /* Number of reported tokens (one for the "unexpected", one per
93006324dcfSchristos "expected"). */
93106324dcfSchristos int yycount = 0;
932ed0d50c3Schristos
93306324dcfSchristos /* There are many possibilities here to consider:
93406324dcfSchristos - If this state is a consistent state with a default action, then
93506324dcfSchristos the only way this function was invoked is if the default action
93606324dcfSchristos is an error action. In that case, don't check for expected
93706324dcfSchristos tokens because there are none.
93806324dcfSchristos - The only way there can be no lookahead present (in yychar) is if
93906324dcfSchristos this state is a consistent state with a default action. Thus,
94006324dcfSchristos detecting the absence of a lookahead is sufficient to determine
94106324dcfSchristos that there is no unexpected or expected token to report. In that
94206324dcfSchristos case, just report a simple "syntax error".
94306324dcfSchristos - Don't assume there isn't a lookahead just because this state is a
94406324dcfSchristos consistent state with a default action. There might have been a
94506324dcfSchristos previous inconsistent state, consistent state with a non-default
94606324dcfSchristos action, or user semantic action that manipulated yychar.
94706324dcfSchristos - Of course, the expected token list depends on states to have
94806324dcfSchristos correct lookahead information, and it depends on the parser not
94906324dcfSchristos to perform extra reductions after fetching a lookahead from the
95006324dcfSchristos scanner and before detecting a syntax error. Thus, state merging
95106324dcfSchristos (from LALR or IELR) and default reductions corrupt the expected
95206324dcfSchristos token list. However, the list is correct for canonical LR with
95306324dcfSchristos one exception: it will still contain any token that will not be
95406324dcfSchristos accepted due to an error action in a later state.
95506324dcfSchristos */
95606324dcfSchristos if (yytoken != YYEMPTY)
95706324dcfSchristos {
95806324dcfSchristos int yyn = yypact[*yyssp];
95906324dcfSchristos yyarg[yycount++] = yytname[yytoken];
96006324dcfSchristos if (!yypact_value_is_default (yyn))
96106324dcfSchristos {
962ed0d50c3Schristos /* Start YYX at -YYN if negative to avoid negative indexes in
96306324dcfSchristos YYCHECK. In other words, skip the first -YYN actions for
96406324dcfSchristos this state because they are default actions. */
965ed0d50c3Schristos int yyxbegin = yyn < 0 ? -yyn : 0;
966ed0d50c3Schristos /* Stay within bounds of both yycheck and yytname. */
967ed0d50c3Schristos int yychecklim = YYLAST - yyn + 1;
968ed0d50c3Schristos int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
96906324dcfSchristos int yyx;
970ed0d50c3Schristos
971ed0d50c3Schristos for (yyx = yyxbegin; yyx < yyxend; ++yyx)
97206324dcfSchristos if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
97306324dcfSchristos && !yytable_value_is_error (yytable[yyx + yyn]))
974ed0d50c3Schristos {
975ed0d50c3Schristos if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
976ed0d50c3Schristos {
977ed0d50c3Schristos yycount = 1;
978ed0d50c3Schristos yysize = yysize0;
979ed0d50c3Schristos break;
980ed0d50c3Schristos }
981ed0d50c3Schristos yyarg[yycount++] = yytname[yyx];
98206324dcfSchristos {
98306324dcfSchristos YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
98406324dcfSchristos if (! (yysize <= yysize1
98506324dcfSchristos && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
98606324dcfSchristos return 2;
987ed0d50c3Schristos yysize = yysize1;
98806324dcfSchristos }
98906324dcfSchristos }
99006324dcfSchristos }
991ed0d50c3Schristos }
992ed0d50c3Schristos
99306324dcfSchristos switch (yycount)
994ed0d50c3Schristos {
99506324dcfSchristos # define YYCASE_(N, S) \
99606324dcfSchristos case N: \
99706324dcfSchristos yyformat = S; \
99806324dcfSchristos break
999*b88e3e88Schristos default: /* Avoid compiler warnings. */
100006324dcfSchristos YYCASE_(0, YY_("syntax error"));
100106324dcfSchristos YYCASE_(1, YY_("syntax error, unexpected %s"));
100206324dcfSchristos YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
100306324dcfSchristos YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
100406324dcfSchristos YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
100506324dcfSchristos YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
100606324dcfSchristos # undef YYCASE_
100706324dcfSchristos }
100806324dcfSchristos
100906324dcfSchristos {
101006324dcfSchristos YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
101106324dcfSchristos if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
101206324dcfSchristos return 2;
101306324dcfSchristos yysize = yysize1;
101406324dcfSchristos }
101506324dcfSchristos
101606324dcfSchristos if (*yymsg_alloc < yysize)
101706324dcfSchristos {
101806324dcfSchristos *yymsg_alloc = 2 * yysize;
101906324dcfSchristos if (! (yysize <= *yymsg_alloc
102006324dcfSchristos && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
102106324dcfSchristos *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
102206324dcfSchristos return 1;
102306324dcfSchristos }
102406324dcfSchristos
1025ed0d50c3Schristos /* Avoid sprintf, as that infringes on the user's name space.
1026ed0d50c3Schristos Don't have undefined behavior even if the translation
1027ed0d50c3Schristos produced a string with the wrong number of "%s"s. */
1028ed0d50c3Schristos {
102906324dcfSchristos char *yyp = *yymsg;
103006324dcfSchristos int yyi = 0;
103106324dcfSchristos while ((*yyp = *yyformat) != '\0')
103206324dcfSchristos if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1033ed0d50c3Schristos {
1034ed0d50c3Schristos yyp += yytnamerr (yyp, yyarg[yyi++]);
103506324dcfSchristos yyformat += 2;
1036ed0d50c3Schristos }
1037ed0d50c3Schristos else
1038ed0d50c3Schristos {
1039ed0d50c3Schristos yyp++;
104006324dcfSchristos yyformat++;
1041ed0d50c3Schristos }
1042ed0d50c3Schristos }
104306324dcfSchristos return 0;
1044ed0d50c3Schristos }
1045ed0d50c3Schristos #endif /* YYERROR_VERBOSE */
1046ed0d50c3Schristos
1047ed0d50c3Schristos /*-----------------------------------------------.
1048ed0d50c3Schristos | Release the memory associated to this symbol. |
1049ed0d50c3Schristos `-----------------------------------------------*/
1050ed0d50c3Schristos
1051ed0d50c3Schristos static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep)1052ed0d50c3Schristos yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1053ed0d50c3Schristos {
1054ed0d50c3Schristos YYUSE (yyvaluep);
1055ed0d50c3Schristos if (!yymsg)
1056ed0d50c3Schristos yymsg = "Deleting";
1057ed0d50c3Schristos YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1058ed0d50c3Schristos
105906324dcfSchristos YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
106006324dcfSchristos YYUSE (yytype);
106106324dcfSchristos YY_IGNORE_MAYBE_UNINITIALIZED_END
1062ed0d50c3Schristos }
1063ed0d50c3Schristos
1064ed0d50c3Schristos
1065ed0d50c3Schristos
106606324dcfSchristos
106706324dcfSchristos /* The lookahead symbol. */
1068ed0d50c3Schristos int yychar;
1069ed0d50c3Schristos
107006324dcfSchristos /* The semantic value of the lookahead symbol. */
1071ed0d50c3Schristos YYSTYPE yylval;
1072ed0d50c3Schristos /* Number of syntax errors so far. */
1073ed0d50c3Schristos int yynerrs;
1074ed0d50c3Schristos
1075ed0d50c3Schristos
1076ed0d50c3Schristos /*----------.
1077ed0d50c3Schristos | yyparse. |
1078ed0d50c3Schristos `----------*/
1079ed0d50c3Schristos
1080ed0d50c3Schristos int
yyparse(void)1081ed0d50c3Schristos yyparse (void)
1082ed0d50c3Schristos {
1083ed0d50c3Schristos int yystate;
1084ed0d50c3Schristos /* Number of tokens to shift before error messages enabled. */
1085ed0d50c3Schristos int yyerrstatus;
108606324dcfSchristos
108706324dcfSchristos /* The stacks and their tools:
108806324dcfSchristos 'yyss': related to states.
108906324dcfSchristos 'yyvs': related to semantic values.
109006324dcfSchristos
109106324dcfSchristos Refer to the stacks through separate pointers, to allow yyoverflow
109206324dcfSchristos to reallocate them elsewhere. */
109306324dcfSchristos
109406324dcfSchristos /* The state stack. */
109506324dcfSchristos yytype_int16 yyssa[YYINITDEPTH];
109606324dcfSchristos yytype_int16 *yyss;
109706324dcfSchristos yytype_int16 *yyssp;
109806324dcfSchristos
109906324dcfSchristos /* The semantic value stack. */
110006324dcfSchristos YYSTYPE yyvsa[YYINITDEPTH];
110106324dcfSchristos YYSTYPE *yyvs;
110206324dcfSchristos YYSTYPE *yyvsp;
110306324dcfSchristos
110406324dcfSchristos YYSIZE_T yystacksize;
110506324dcfSchristos
110606324dcfSchristos int yyn;
110706324dcfSchristos int yyresult;
110806324dcfSchristos /* Lookahead token as an internal (translated) token number. */
1109ed0d50c3Schristos int yytoken = 0;
111006324dcfSchristos /* The variables used to return semantic value and location from the
111106324dcfSchristos action routines. */
111206324dcfSchristos YYSTYPE yyval;
111306324dcfSchristos
1114ed0d50c3Schristos #if YYERROR_VERBOSE
1115ed0d50c3Schristos /* Buffer for error messages, and its allocated size. */
1116ed0d50c3Schristos char yymsgbuf[128];
1117ed0d50c3Schristos char *yymsg = yymsgbuf;
1118ed0d50c3Schristos YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1119ed0d50c3Schristos #endif
1120ed0d50c3Schristos
1121ed0d50c3Schristos #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1122ed0d50c3Schristos
1123ed0d50c3Schristos /* The number of symbols on the RHS of the reduced rule.
1124ed0d50c3Schristos Keep to zero when no symbol should be popped. */
1125ed0d50c3Schristos int yylen = 0;
1126ed0d50c3Schristos
112706324dcfSchristos yyssp = yyss = yyssa;
112806324dcfSchristos yyvsp = yyvs = yyvsa;
112906324dcfSchristos yystacksize = YYINITDEPTH;
113006324dcfSchristos
1131ed0d50c3Schristos YYDPRINTF ((stderr, "Starting parse\n"));
1132ed0d50c3Schristos
1133ed0d50c3Schristos yystate = 0;
1134ed0d50c3Schristos yyerrstatus = 0;
1135ed0d50c3Schristos yynerrs = 0;
1136ed0d50c3Schristos yychar = YYEMPTY; /* Cause a token to be read. */
1137ed0d50c3Schristos goto yysetstate;
1138ed0d50c3Schristos
1139ed0d50c3Schristos /*------------------------------------------------------------.
1140ed0d50c3Schristos | yynewstate -- Push a new state, which is found in yystate. |
1141ed0d50c3Schristos `------------------------------------------------------------*/
1142ed0d50c3Schristos yynewstate:
1143ed0d50c3Schristos /* In all cases, when you get here, the value and location stacks
1144ed0d50c3Schristos have just been pushed. So pushing a state here evens the stacks. */
1145ed0d50c3Schristos yyssp++;
1146ed0d50c3Schristos
1147ed0d50c3Schristos yysetstate:
1148ed0d50c3Schristos *yyssp = yystate;
1149ed0d50c3Schristos
1150ed0d50c3Schristos if (yyss + yystacksize - 1 <= yyssp)
1151ed0d50c3Schristos {
1152ed0d50c3Schristos /* Get the current used size of the three stacks, in elements. */
1153ed0d50c3Schristos YYSIZE_T yysize = yyssp - yyss + 1;
1154ed0d50c3Schristos
1155ed0d50c3Schristos #ifdef yyoverflow
1156ed0d50c3Schristos {
1157ed0d50c3Schristos /* Give user a chance to reallocate the stack. Use copies of
1158ed0d50c3Schristos these so that the &'s don't force the real ones into
1159ed0d50c3Schristos memory. */
1160ed0d50c3Schristos YYSTYPE *yyvs1 = yyvs;
1161ed0d50c3Schristos yytype_int16 *yyss1 = yyss;
1162ed0d50c3Schristos
1163ed0d50c3Schristos /* Each stack pointer address is followed by the size of the
1164ed0d50c3Schristos data in use in that stack, in bytes. This used to be a
1165ed0d50c3Schristos conditional around just the two extra args, but that might
1166ed0d50c3Schristos be undefined if yyoverflow is a macro. */
1167ed0d50c3Schristos yyoverflow (YY_("memory exhausted"),
1168ed0d50c3Schristos &yyss1, yysize * sizeof (*yyssp),
1169ed0d50c3Schristos &yyvs1, yysize * sizeof (*yyvsp),
1170ed0d50c3Schristos &yystacksize);
1171ed0d50c3Schristos
1172ed0d50c3Schristos yyss = yyss1;
1173ed0d50c3Schristos yyvs = yyvs1;
1174ed0d50c3Schristos }
1175ed0d50c3Schristos #else /* no yyoverflow */
1176ed0d50c3Schristos # ifndef YYSTACK_RELOCATE
1177ed0d50c3Schristos goto yyexhaustedlab;
1178ed0d50c3Schristos # else
1179ed0d50c3Schristos /* Extend the stack our own way. */
1180ed0d50c3Schristos if (YYMAXDEPTH <= yystacksize)
1181ed0d50c3Schristos goto yyexhaustedlab;
1182ed0d50c3Schristos yystacksize *= 2;
1183ed0d50c3Schristos if (YYMAXDEPTH < yystacksize)
1184ed0d50c3Schristos yystacksize = YYMAXDEPTH;
1185ed0d50c3Schristos
1186ed0d50c3Schristos {
1187ed0d50c3Schristos yytype_int16 *yyss1 = yyss;
1188ed0d50c3Schristos union yyalloc *yyptr =
1189ed0d50c3Schristos (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1190ed0d50c3Schristos if (! yyptr)
1191ed0d50c3Schristos goto yyexhaustedlab;
119206324dcfSchristos YYSTACK_RELOCATE (yyss_alloc, yyss);
119306324dcfSchristos YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1194ed0d50c3Schristos # undef YYSTACK_RELOCATE
1195ed0d50c3Schristos if (yyss1 != yyssa)
1196ed0d50c3Schristos YYSTACK_FREE (yyss1);
1197ed0d50c3Schristos }
1198ed0d50c3Schristos # endif
1199ed0d50c3Schristos #endif /* no yyoverflow */
1200ed0d50c3Schristos
1201ed0d50c3Schristos yyssp = yyss + yysize - 1;
1202ed0d50c3Schristos yyvsp = yyvs + yysize - 1;
1203ed0d50c3Schristos
1204ed0d50c3Schristos YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1205ed0d50c3Schristos (unsigned long int) yystacksize));
1206ed0d50c3Schristos
1207ed0d50c3Schristos if (yyss + yystacksize - 1 <= yyssp)
1208ed0d50c3Schristos YYABORT;
1209ed0d50c3Schristos }
1210ed0d50c3Schristos
1211ed0d50c3Schristos YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1212ed0d50c3Schristos
121306324dcfSchristos if (yystate == YYFINAL)
121406324dcfSchristos YYACCEPT;
121506324dcfSchristos
1216ed0d50c3Schristos goto yybackup;
1217ed0d50c3Schristos
1218ed0d50c3Schristos /*-----------.
1219ed0d50c3Schristos | yybackup. |
1220ed0d50c3Schristos `-----------*/
1221ed0d50c3Schristos yybackup:
1222ed0d50c3Schristos
1223ed0d50c3Schristos /* Do appropriate processing given the current state. Read a
122406324dcfSchristos lookahead token if we need one and don't already have one. */
1225ed0d50c3Schristos
122606324dcfSchristos /* First try to decide what to do without reference to lookahead token. */
1227ed0d50c3Schristos yyn = yypact[yystate];
122806324dcfSchristos if (yypact_value_is_default (yyn))
1229ed0d50c3Schristos goto yydefault;
1230ed0d50c3Schristos
123106324dcfSchristos /* Not known => get a lookahead token if don't already have one. */
1232ed0d50c3Schristos
123306324dcfSchristos /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1234ed0d50c3Schristos if (yychar == YYEMPTY)
1235ed0d50c3Schristos {
1236ed0d50c3Schristos YYDPRINTF ((stderr, "Reading a token: "));
123706324dcfSchristos yychar = yylex ();
1238ed0d50c3Schristos }
1239ed0d50c3Schristos
1240ed0d50c3Schristos if (yychar <= YYEOF)
1241ed0d50c3Schristos {
1242ed0d50c3Schristos yychar = yytoken = YYEOF;
1243ed0d50c3Schristos YYDPRINTF ((stderr, "Now at end of input.\n"));
1244ed0d50c3Schristos }
1245ed0d50c3Schristos else
1246ed0d50c3Schristos {
1247ed0d50c3Schristos yytoken = YYTRANSLATE (yychar);
1248ed0d50c3Schristos YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1249ed0d50c3Schristos }
1250ed0d50c3Schristos
1251ed0d50c3Schristos /* If the proper action on seeing token YYTOKEN is to reduce or to
1252ed0d50c3Schristos detect an error, take that action. */
1253ed0d50c3Schristos yyn += yytoken;
1254ed0d50c3Schristos if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1255ed0d50c3Schristos goto yydefault;
1256ed0d50c3Schristos yyn = yytable[yyn];
1257ed0d50c3Schristos if (yyn <= 0)
1258ed0d50c3Schristos {
125906324dcfSchristos if (yytable_value_is_error (yyn))
1260ed0d50c3Schristos goto yyerrlab;
1261ed0d50c3Schristos yyn = -yyn;
1262ed0d50c3Schristos goto yyreduce;
1263ed0d50c3Schristos }
1264ed0d50c3Schristos
1265ed0d50c3Schristos /* Count tokens shifted since error; after three, turn off error
1266ed0d50c3Schristos status. */
1267ed0d50c3Schristos if (yyerrstatus)
1268ed0d50c3Schristos yyerrstatus--;
1269ed0d50c3Schristos
127006324dcfSchristos /* Shift the lookahead token. */
1271ed0d50c3Schristos YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1272ed0d50c3Schristos
127306324dcfSchristos /* Discard the shifted token. */
1274ed0d50c3Schristos yychar = YYEMPTY;
1275ed0d50c3Schristos
1276ed0d50c3Schristos yystate = yyn;
127706324dcfSchristos YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1278ed0d50c3Schristos *++yyvsp = yylval;
127906324dcfSchristos YY_IGNORE_MAYBE_UNINITIALIZED_END
1280ed0d50c3Schristos
1281ed0d50c3Schristos goto yynewstate;
1282ed0d50c3Schristos
1283ed0d50c3Schristos
1284ed0d50c3Schristos /*-----------------------------------------------------------.
1285ed0d50c3Schristos | yydefault -- do the default action for the current state. |
1286ed0d50c3Schristos `-----------------------------------------------------------*/
1287ed0d50c3Schristos yydefault:
1288ed0d50c3Schristos yyn = yydefact[yystate];
1289ed0d50c3Schristos if (yyn == 0)
1290ed0d50c3Schristos goto yyerrlab;
1291ed0d50c3Schristos goto yyreduce;
1292ed0d50c3Schristos
1293ed0d50c3Schristos
1294ed0d50c3Schristos /*-----------------------------.
1295ed0d50c3Schristos | yyreduce -- Do a reduction. |
1296ed0d50c3Schristos `-----------------------------*/
1297ed0d50c3Schristos yyreduce:
1298ed0d50c3Schristos /* yyn is the number of a rule to reduce with. */
1299ed0d50c3Schristos yylen = yyr2[yyn];
1300ed0d50c3Schristos
1301ed0d50c3Schristos /* If YYLEN is nonzero, implement the default value of the action:
130206324dcfSchristos '$$ = $1'.
1303ed0d50c3Schristos
1304ed0d50c3Schristos Otherwise, the following line sets YYVAL to garbage.
1305ed0d50c3Schristos This behavior is undocumented and Bison
1306ed0d50c3Schristos users should not rely upon it. Assigning to YYVAL
1307ed0d50c3Schristos unconditionally makes the parser a bit smaller, and it avoids a
1308ed0d50c3Schristos GCC warning that YYVAL may be used uninitialized. */
1309ed0d50c3Schristos yyval = yyvsp[1-yylen];
1310ed0d50c3Schristos
1311ed0d50c3Schristos
1312ed0d50c3Schristos YY_REDUCE_PRINT (yyn);
1313ed0d50c3Schristos switch (yyn)
1314ed0d50c3Schristos {
1315ed0d50c3Schristos case 2:
1316*b88e3e88Schristos #line 68 "arparse.y" /* yacc.c:1648 */
1317ed0d50c3Schristos { prompt(); }
1318*b88e3e88Schristos #line 1319 "arparse.c" /* yacc.c:1648 */
1319ed0d50c3Schristos break;
1320ed0d50c3Schristos
1321ed0d50c3Schristos case 6:
1322*b88e3e88Schristos #line 77 "arparse.y" /* yacc.c:1648 */
1323ed0d50c3Schristos { prompt(); }
1324*b88e3e88Schristos #line 1325 "arparse.c" /* yacc.c:1648 */
1325ed0d50c3Schristos break;
1326ed0d50c3Schristos
1327ed0d50c3Schristos case 19:
1328*b88e3e88Schristos #line 93 "arparse.y" /* yacc.c:1648 */
1329ed0d50c3Schristos { ar_end(); return 0; }
1330*b88e3e88Schristos #line 1331 "arparse.c" /* yacc.c:1648 */
1331ed0d50c3Schristos break;
1332ed0d50c3Schristos
1333ed0d50c3Schristos case 21:
1334*b88e3e88Schristos #line 95 "arparse.y" /* yacc.c:1648 */
1335ed0d50c3Schristos { yyerror("foo"); }
1336*b88e3e88Schristos #line 1337 "arparse.c" /* yacc.c:1648 */
1337ed0d50c3Schristos break;
1338ed0d50c3Schristos
1339ed0d50c3Schristos case 23:
1340*b88e3e88Schristos #line 102 "arparse.y" /* yacc.c:1648 */
134106324dcfSchristos { ar_extract((yyvsp[0].list)); }
1342*b88e3e88Schristos #line 1343 "arparse.c" /* yacc.c:1648 */
1343ed0d50c3Schristos break;
1344ed0d50c3Schristos
1345ed0d50c3Schristos case 24:
1346*b88e3e88Schristos #line 107 "arparse.y" /* yacc.c:1648 */
134706324dcfSchristos { ar_replace((yyvsp[0].list)); }
1348*b88e3e88Schristos #line 1349 "arparse.c" /* yacc.c:1648 */
1349ed0d50c3Schristos break;
1350ed0d50c3Schristos
1351ed0d50c3Schristos case 25:
1352*b88e3e88Schristos #line 112 "arparse.y" /* yacc.c:1648 */
1353ed0d50c3Schristos { ar_clear(); }
1354*b88e3e88Schristos #line 1355 "arparse.c" /* yacc.c:1648 */
1355ed0d50c3Schristos break;
1356ed0d50c3Schristos
1357ed0d50c3Schristos case 26:
1358*b88e3e88Schristos #line 117 "arparse.y" /* yacc.c:1648 */
135906324dcfSchristos { ar_delete((yyvsp[0].list)); }
1360*b88e3e88Schristos #line 1361 "arparse.c" /* yacc.c:1648 */
1361ed0d50c3Schristos break;
1362ed0d50c3Schristos
1363ed0d50c3Schristos case 27:
1364*b88e3e88Schristos #line 121 "arparse.y" /* yacc.c:1648 */
136506324dcfSchristos { ar_addmod((yyvsp[0].list)); }
1366*b88e3e88Schristos #line 1367 "arparse.c" /* yacc.c:1648 */
1367ed0d50c3Schristos break;
1368ed0d50c3Schristos
1369ed0d50c3Schristos case 28:
1370*b88e3e88Schristos #line 126 "arparse.y" /* yacc.c:1648 */
1371ed0d50c3Schristos { ar_list(); }
1372*b88e3e88Schristos #line 1373 "arparse.c" /* yacc.c:1648 */
1373ed0d50c3Schristos break;
1374ed0d50c3Schristos
1375ed0d50c3Schristos case 29:
1376*b88e3e88Schristos #line 131 "arparse.y" /* yacc.c:1648 */
1377ed0d50c3Schristos { ar_save(); }
1378*b88e3e88Schristos #line 1379 "arparse.c" /* yacc.c:1648 */
1379ed0d50c3Schristos break;
1380ed0d50c3Schristos
1381ed0d50c3Schristos case 30:
1382*b88e3e88Schristos #line 138 "arparse.y" /* yacc.c:1648 */
138306324dcfSchristos { ar_open((yyvsp[0].name),0); }
1384*b88e3e88Schristos #line 1385 "arparse.c" /* yacc.c:1648 */
1385ed0d50c3Schristos break;
1386ed0d50c3Schristos
1387ed0d50c3Schristos case 31:
1388*b88e3e88Schristos #line 143 "arparse.y" /* yacc.c:1648 */
138906324dcfSchristos { ar_open((yyvsp[0].name),1); }
1390*b88e3e88Schristos #line 1391 "arparse.c" /* yacc.c:1648 */
1391ed0d50c3Schristos break;
1392ed0d50c3Schristos
1393ed0d50c3Schristos case 32:
1394*b88e3e88Schristos #line 149 "arparse.y" /* yacc.c:1648 */
139506324dcfSchristos { ar_addlib((yyvsp[-1].name),(yyvsp[0].list)); }
1396*b88e3e88Schristos #line 1397 "arparse.c" /* yacc.c:1648 */
1397ed0d50c3Schristos break;
1398ed0d50c3Schristos
1399ed0d50c3Schristos case 33:
1400*b88e3e88Schristos #line 153 "arparse.y" /* yacc.c:1648 */
140106324dcfSchristos { ar_directory((yyvsp[-2].name), (yyvsp[-1].list), (yyvsp[0].name)); }
1402*b88e3e88Schristos #line 1403 "arparse.c" /* yacc.c:1648 */
1403ed0d50c3Schristos break;
1404ed0d50c3Schristos
1405ed0d50c3Schristos case 34:
1406*b88e3e88Schristos #line 160 "arparse.y" /* yacc.c:1648 */
140706324dcfSchristos { (yyval.name) = (yyvsp[0].name); }
1408*b88e3e88Schristos #line 1409 "arparse.c" /* yacc.c:1648 */
1409ed0d50c3Schristos break;
1410ed0d50c3Schristos
1411ed0d50c3Schristos case 35:
1412*b88e3e88Schristos #line 161 "arparse.y" /* yacc.c:1648 */
1413ed0d50c3Schristos { (yyval.name) = 0; }
1414*b88e3e88Schristos #line 1415 "arparse.c" /* yacc.c:1648 */
1415ed0d50c3Schristos break;
1416ed0d50c3Schristos
1417ed0d50c3Schristos case 36:
1418*b88e3e88Schristos #line 166 "arparse.y" /* yacc.c:1648 */
141906324dcfSchristos { (yyval.list) = (yyvsp[-1].list); }
1420*b88e3e88Schristos #line 1421 "arparse.c" /* yacc.c:1648 */
1421ed0d50c3Schristos break;
1422ed0d50c3Schristos
1423ed0d50c3Schristos case 37:
1424*b88e3e88Schristos #line 168 "arparse.y" /* yacc.c:1648 */
1425ed0d50c3Schristos { (yyval.list) = 0; }
1426*b88e3e88Schristos #line 1427 "arparse.c" /* yacc.c:1648 */
1427ed0d50c3Schristos break;
1428ed0d50c3Schristos
1429ed0d50c3Schristos case 38:
1430*b88e3e88Schristos #line 173 "arparse.y" /* yacc.c:1648 */
1431ed0d50c3Schristos { struct list *n = (struct list *) malloc(sizeof(struct list));
143206324dcfSchristos n->next = (yyvsp[-2].list);
143306324dcfSchristos n->name = (yyvsp[0].name);
1434ed0d50c3Schristos (yyval.list) = n;
1435ed0d50c3Schristos }
1436*b88e3e88Schristos #line 1437 "arparse.c" /* yacc.c:1648 */
1437ed0d50c3Schristos break;
1438ed0d50c3Schristos
1439ed0d50c3Schristos case 39:
1440*b88e3e88Schristos #line 178 "arparse.y" /* yacc.c:1648 */
1441ed0d50c3Schristos { (yyval.list) = 0; }
1442*b88e3e88Schristos #line 1443 "arparse.c" /* yacc.c:1648 */
1443ed0d50c3Schristos break;
1444ed0d50c3Schristos
1445ed0d50c3Schristos case 42:
1446*b88e3e88Schristos #line 190 "arparse.y" /* yacc.c:1648 */
1447ed0d50c3Schristos { verbose = !verbose; }
1448*b88e3e88Schristos #line 1449 "arparse.c" /* yacc.c:1648 */
1449ed0d50c3Schristos break;
1450ed0d50c3Schristos
1451ed0d50c3Schristos
1452*b88e3e88Schristos #line 1453 "arparse.c" /* yacc.c:1648 */
1453ed0d50c3Schristos default: break;
1454ed0d50c3Schristos }
145506324dcfSchristos /* User semantic actions sometimes alter yychar, and that requires
145606324dcfSchristos that yytoken be updated with the new translation. We take the
145706324dcfSchristos approach of translating immediately before every use of yytoken.
145806324dcfSchristos One alternative is translating here after every semantic action,
145906324dcfSchristos but that translation would be missed if the semantic action invokes
146006324dcfSchristos YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
146106324dcfSchristos if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
146206324dcfSchristos incorrect destructor might then be invoked immediately. In the
146306324dcfSchristos case of YYERROR or YYBACKUP, subsequent parser actions might lead
146406324dcfSchristos to an incorrect destructor call or verbose syntax error message
146506324dcfSchristos before the lookahead is translated. */
1466ed0d50c3Schristos YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1467ed0d50c3Schristos
1468ed0d50c3Schristos YYPOPSTACK (yylen);
1469ed0d50c3Schristos yylen = 0;
1470ed0d50c3Schristos YY_STACK_PRINT (yyss, yyssp);
1471ed0d50c3Schristos
1472ed0d50c3Schristos *++yyvsp = yyval;
1473ed0d50c3Schristos
147406324dcfSchristos /* Now 'shift' the result of the reduction. Determine what state
1475ed0d50c3Schristos that goes to, based on the state we popped back to and the rule
1476ed0d50c3Schristos number reduced by. */
1477ed0d50c3Schristos
1478ed0d50c3Schristos yyn = yyr1[yyn];
1479ed0d50c3Schristos
1480ed0d50c3Schristos yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1481ed0d50c3Schristos if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1482ed0d50c3Schristos yystate = yytable[yystate];
1483ed0d50c3Schristos else
1484ed0d50c3Schristos yystate = yydefgoto[yyn - YYNTOKENS];
1485ed0d50c3Schristos
1486ed0d50c3Schristos goto yynewstate;
1487ed0d50c3Schristos
1488ed0d50c3Schristos
148906324dcfSchristos /*--------------------------------------.
149006324dcfSchristos | yyerrlab -- here on detecting error. |
149106324dcfSchristos `--------------------------------------*/
1492ed0d50c3Schristos yyerrlab:
149306324dcfSchristos /* Make sure we have latest lookahead translation. See comments at
149406324dcfSchristos user semantic actions for why this is necessary. */
149506324dcfSchristos yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
149606324dcfSchristos
1497ed0d50c3Schristos /* If not already recovering from an error, report this error. */
1498ed0d50c3Schristos if (!yyerrstatus)
1499ed0d50c3Schristos {
1500ed0d50c3Schristos ++yynerrs;
1501ed0d50c3Schristos #if ! YYERROR_VERBOSE
1502ed0d50c3Schristos yyerror (YY_("syntax error"));
1503ed0d50c3Schristos #else
150406324dcfSchristos # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
150506324dcfSchristos yyssp, yytoken)
1506ed0d50c3Schristos {
150706324dcfSchristos char const *yymsgp = YY_("syntax error");
150806324dcfSchristos int yysyntax_error_status;
150906324dcfSchristos yysyntax_error_status = YYSYNTAX_ERROR;
151006324dcfSchristos if (yysyntax_error_status == 0)
151106324dcfSchristos yymsgp = yymsg;
151206324dcfSchristos else if (yysyntax_error_status == 1)
1513ed0d50c3Schristos {
1514ed0d50c3Schristos if (yymsg != yymsgbuf)
1515ed0d50c3Schristos YYSTACK_FREE (yymsg);
151606324dcfSchristos yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
151706324dcfSchristos if (!yymsg)
1518ed0d50c3Schristos {
1519ed0d50c3Schristos yymsg = yymsgbuf;
1520ed0d50c3Schristos yymsg_alloc = sizeof yymsgbuf;
152106324dcfSchristos yysyntax_error_status = 2;
1522ed0d50c3Schristos }
1523ed0d50c3Schristos else
1524ed0d50c3Schristos {
152506324dcfSchristos yysyntax_error_status = YYSYNTAX_ERROR;
152606324dcfSchristos yymsgp = yymsg;
152706324dcfSchristos }
152806324dcfSchristos }
152906324dcfSchristos yyerror (yymsgp);
153006324dcfSchristos if (yysyntax_error_status == 2)
1531ed0d50c3Schristos goto yyexhaustedlab;
1532ed0d50c3Schristos }
153306324dcfSchristos # undef YYSYNTAX_ERROR
1534ed0d50c3Schristos #endif
1535ed0d50c3Schristos }
1536ed0d50c3Schristos
1537ed0d50c3Schristos
1538ed0d50c3Schristos
1539ed0d50c3Schristos if (yyerrstatus == 3)
1540ed0d50c3Schristos {
154106324dcfSchristos /* If just tried and failed to reuse lookahead token after an
1542ed0d50c3Schristos error, discard it. */
1543ed0d50c3Schristos
1544ed0d50c3Schristos if (yychar <= YYEOF)
1545ed0d50c3Schristos {
1546ed0d50c3Schristos /* Return failure if at end of input. */
1547ed0d50c3Schristos if (yychar == YYEOF)
1548ed0d50c3Schristos YYABORT;
1549ed0d50c3Schristos }
1550ed0d50c3Schristos else
1551ed0d50c3Schristos {
1552ed0d50c3Schristos yydestruct ("Error: discarding",
1553ed0d50c3Schristos yytoken, &yylval);
1554ed0d50c3Schristos yychar = YYEMPTY;
1555ed0d50c3Schristos }
1556ed0d50c3Schristos }
1557ed0d50c3Schristos
155806324dcfSchristos /* Else will try to reuse lookahead token after shifting the error
1559ed0d50c3Schristos token. */
1560ed0d50c3Schristos goto yyerrlab1;
1561ed0d50c3Schristos
1562ed0d50c3Schristos
1563ed0d50c3Schristos /*---------------------------------------------------.
1564ed0d50c3Schristos | yyerrorlab -- error raised explicitly by YYERROR. |
1565ed0d50c3Schristos `---------------------------------------------------*/
1566ed0d50c3Schristos yyerrorlab:
1567ed0d50c3Schristos
1568ed0d50c3Schristos /* Pacify compilers like GCC when the user code never invokes
1569ed0d50c3Schristos YYERROR and the label yyerrorlab therefore never appears in user
1570ed0d50c3Schristos code. */
1571ed0d50c3Schristos if (/*CONSTCOND*/ 0)
1572ed0d50c3Schristos goto yyerrorlab;
1573ed0d50c3Schristos
157406324dcfSchristos /* Do not reclaim the symbols of the rule whose action triggered
1575ed0d50c3Schristos this YYERROR. */
1576ed0d50c3Schristos YYPOPSTACK (yylen);
1577ed0d50c3Schristos yylen = 0;
1578ed0d50c3Schristos YY_STACK_PRINT (yyss, yyssp);
1579ed0d50c3Schristos yystate = *yyssp;
1580ed0d50c3Schristos goto yyerrlab1;
1581ed0d50c3Schristos
1582ed0d50c3Schristos
1583ed0d50c3Schristos /*-------------------------------------------------------------.
1584ed0d50c3Schristos | yyerrlab1 -- common code for both syntax error and YYERROR. |
1585ed0d50c3Schristos `-------------------------------------------------------------*/
1586ed0d50c3Schristos yyerrlab1:
1587ed0d50c3Schristos yyerrstatus = 3; /* Each real token shifted decrements this. */
1588ed0d50c3Schristos
1589ed0d50c3Schristos for (;;)
1590ed0d50c3Schristos {
1591ed0d50c3Schristos yyn = yypact[yystate];
159206324dcfSchristos if (!yypact_value_is_default (yyn))
1593ed0d50c3Schristos {
1594ed0d50c3Schristos yyn += YYTERROR;
1595ed0d50c3Schristos if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1596ed0d50c3Schristos {
1597ed0d50c3Schristos yyn = yytable[yyn];
1598ed0d50c3Schristos if (0 < yyn)
1599ed0d50c3Schristos break;
1600ed0d50c3Schristos }
1601ed0d50c3Schristos }
1602ed0d50c3Schristos
1603ed0d50c3Schristos /* Pop the current state because it cannot handle the error token. */
1604ed0d50c3Schristos if (yyssp == yyss)
1605ed0d50c3Schristos YYABORT;
1606ed0d50c3Schristos
1607ed0d50c3Schristos
1608ed0d50c3Schristos yydestruct ("Error: popping",
1609ed0d50c3Schristos yystos[yystate], yyvsp);
1610ed0d50c3Schristos YYPOPSTACK (1);
1611ed0d50c3Schristos yystate = *yyssp;
1612ed0d50c3Schristos YY_STACK_PRINT (yyss, yyssp);
1613ed0d50c3Schristos }
1614ed0d50c3Schristos
161506324dcfSchristos YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1616ed0d50c3Schristos *++yyvsp = yylval;
161706324dcfSchristos YY_IGNORE_MAYBE_UNINITIALIZED_END
1618ed0d50c3Schristos
1619ed0d50c3Schristos
1620ed0d50c3Schristos /* Shift the error token. */
1621ed0d50c3Schristos YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1622ed0d50c3Schristos
1623ed0d50c3Schristos yystate = yyn;
1624ed0d50c3Schristos goto yynewstate;
1625ed0d50c3Schristos
1626ed0d50c3Schristos
1627ed0d50c3Schristos /*-------------------------------------.
1628ed0d50c3Schristos | yyacceptlab -- YYACCEPT comes here. |
1629ed0d50c3Schristos `-------------------------------------*/
1630ed0d50c3Schristos yyacceptlab:
1631ed0d50c3Schristos yyresult = 0;
1632ed0d50c3Schristos goto yyreturn;
1633ed0d50c3Schristos
1634ed0d50c3Schristos /*-----------------------------------.
1635ed0d50c3Schristos | yyabortlab -- YYABORT comes here. |
1636ed0d50c3Schristos `-----------------------------------*/
1637ed0d50c3Schristos yyabortlab:
1638ed0d50c3Schristos yyresult = 1;
1639ed0d50c3Schristos goto yyreturn;
1640ed0d50c3Schristos
164106324dcfSchristos #if !defined yyoverflow || YYERROR_VERBOSE
1642ed0d50c3Schristos /*-------------------------------------------------.
1643ed0d50c3Schristos | yyexhaustedlab -- memory exhaustion comes here. |
1644ed0d50c3Schristos `-------------------------------------------------*/
1645ed0d50c3Schristos yyexhaustedlab:
1646ed0d50c3Schristos yyerror (YY_("memory exhausted"));
1647ed0d50c3Schristos yyresult = 2;
1648ed0d50c3Schristos /* Fall through. */
1649ed0d50c3Schristos #endif
1650ed0d50c3Schristos
1651ed0d50c3Schristos yyreturn:
165206324dcfSchristos if (yychar != YYEMPTY)
165306324dcfSchristos {
165406324dcfSchristos /* Make sure we have latest lookahead translation. See comments at
165506324dcfSchristos user semantic actions for why this is necessary. */
165606324dcfSchristos yytoken = YYTRANSLATE (yychar);
1657ed0d50c3Schristos yydestruct ("Cleanup: discarding lookahead",
1658ed0d50c3Schristos yytoken, &yylval);
165906324dcfSchristos }
166006324dcfSchristos /* Do not reclaim the symbols of the rule whose action triggered
1661ed0d50c3Schristos this YYABORT or YYACCEPT. */
1662ed0d50c3Schristos YYPOPSTACK (yylen);
1663ed0d50c3Schristos YY_STACK_PRINT (yyss, yyssp);
1664ed0d50c3Schristos while (yyssp != yyss)
1665ed0d50c3Schristos {
1666ed0d50c3Schristos yydestruct ("Cleanup: popping",
1667ed0d50c3Schristos yystos[*yyssp], yyvsp);
1668ed0d50c3Schristos YYPOPSTACK (1);
1669ed0d50c3Schristos }
1670ed0d50c3Schristos #ifndef yyoverflow
1671ed0d50c3Schristos if (yyss != yyssa)
1672ed0d50c3Schristos YYSTACK_FREE (yyss);
1673ed0d50c3Schristos #endif
1674ed0d50c3Schristos #if YYERROR_VERBOSE
1675ed0d50c3Schristos if (yymsg != yymsgbuf)
1676ed0d50c3Schristos YYSTACK_FREE (yymsg);
1677ed0d50c3Schristos #endif
167806324dcfSchristos return yyresult;
1679ed0d50c3Schristos }
1680*b88e3e88Schristos #line 194 "arparse.y" /* yacc.c:1907 */
1681ed0d50c3Schristos
1682ed0d50c3Schristos
1683ed0d50c3Schristos static int
yyerror(const char * x ATTRIBUTE_UNUSED)1684ed0d50c3Schristos yyerror (const char *x ATTRIBUTE_UNUSED)
1685ed0d50c3Schristos {
1686ed0d50c3Schristos extern int linenumber;
1687ed0d50c3Schristos
1688ed0d50c3Schristos printf (_("Syntax error in archive script, line %d\n"), linenumber + 1);
1689ed0d50c3Schristos return 0;
1690ed0d50c3Schristos }
1691