1 /* A Bison parser, made by GNU Bison 3.0.2. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2013 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.0.2"
48
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51
52 /* Pure parsers. */
53 #define YYPURE 0
54
55 /* Push parsers. */
56 #define YYPUSH 0
57
58 /* Pull parsers. */
59 #define YYPULL 1
60
61
62
63
64 /* Copy the first part of user declarations. */
65 #line 32 "uparse.y" /* yacc.c:339 */
66
67 #include "amanda.h"
68 #include "amrecover.h"
69
70 #define DATE_ALLOC_SIZE sizeof("YYYY-MM-DD-HH-MM-SS") /* includes null */
71
72 void yyerror(char *s);
73 extern int yylex(void);
74 extern char * yytext;
75
76 #line 77 "uparse.c" /* yacc.c:339 */
77
78 # ifndef YY_NULLPTR
79 # if defined __cplusplus && 201103L <= __cplusplus
80 # define YY_NULLPTR nullptr
81 # else
82 # define YY_NULLPTR 0
83 # endif
84 # endif
85
86 /* Enabling verbose error messages. */
87 #ifdef YYERROR_VERBOSE
88 # undef YYERROR_VERBOSE
89 # define YYERROR_VERBOSE 1
90 #else
91 # define YYERROR_VERBOSE 0
92 #endif
93
94 /* In a future release of Bison, this section will be replaced
95 by #include "y.tab.h". */
96 #ifndef YY_YY_UPARSE_H_INCLUDED
97 # define YY_YY_UPARSE_H_INCLUDED
98 /* Debug traces. */
99 #ifndef YYDEBUG
100 # define YYDEBUG 0
101 #endif
102 #if YYDEBUG
103 extern int yydebug;
104 #endif
105
106 /* Token type. */
107 #ifndef YYTOKENTYPE
108 # define YYTOKENTYPE
109 enum yytokentype
110 {
111 LISTHOST = 258,
112 LISTDISK = 259,
113 LISTPROPERTY = 260,
114 SETHOST = 261,
115 SETDISK = 262,
116 SETDATE = 263,
117 SETTAPE = 264,
118 SETMODE = 265,
119 SETDEVICE = 266,
120 SETPROPERTY = 267,
121 CD = 268,
122 CDX = 269,
123 QUIT = 270,
124 DHIST = 271,
125 LS = 272,
126 ADD = 273,
127 ADDX = 274,
128 EXTRACT = 275,
129 DASH_H = 276,
130 LIST = 277,
131 DELETE = 278,
132 DELETEX = 279,
133 PWD = 280,
134 CLEAR = 281,
135 HELP = 282,
136 LCD = 283,
137 LPWD = 284,
138 MODE = 285,
139 SMB = 286,
140 TAR = 287,
141 APPEND = 288,
142 PRIORITY = 289,
143 SETTRANSLATE = 290,
144 NL = 291,
145 STRING = 292
146 };
147 #endif
148 /* Tokens. */
149 #define LISTHOST 258
150 #define LISTDISK 259
151 #define LISTPROPERTY 260
152 #define SETHOST 261
153 #define SETDISK 262
154 #define SETDATE 263
155 #define SETTAPE 264
156 #define SETMODE 265
157 #define SETDEVICE 266
158 #define SETPROPERTY 267
159 #define CD 268
160 #define CDX 269
161 #define QUIT 270
162 #define DHIST 271
163 #define LS 272
164 #define ADD 273
165 #define ADDX 274
166 #define EXTRACT 275
167 #define DASH_H 276
168 #define LIST 277
169 #define DELETE 278
170 #define DELETEX 279
171 #define PWD 280
172 #define CLEAR 281
173 #define HELP 282
174 #define LCD 283
175 #define LPWD 284
176 #define MODE 285
177 #define SMB 286
178 #define TAR 287
179 #define APPEND 288
180 #define PRIORITY 289
181 #define SETTRANSLATE 290
182 #define NL 291
183 #define STRING 292
184
185 /* Value type. */
186 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
187 typedef union YYSTYPE YYSTYPE;
188 union YYSTYPE
189 {
190 #line 44 "uparse.y" /* yacc.c:355 */
191
192 int intval;
193 double floatval;
194 char * strval;
195 int subtok;
196
197 #line 198 "uparse.c" /* yacc.c:355 */
198 };
199 # define YYSTYPE_IS_TRIVIAL 1
200 # define YYSTYPE_IS_DECLARED 1
201 #endif
202
203
204 extern YYSTYPE yylval;
205
206 int yyparse (void);
207
208 #endif /* !YY_YY_UPARSE_H_INCLUDED */
209
210 /* Copy the second part of user declarations. */
211
212 #line 213 "uparse.c" /* yacc.c:358 */
213
214 #ifdef short
215 # undef short
216 #endif
217
218 #ifdef YYTYPE_UINT8
219 typedef YYTYPE_UINT8 yytype_uint8;
220 #else
221 typedef unsigned char yytype_uint8;
222 #endif
223
224 #ifdef YYTYPE_INT8
225 typedef YYTYPE_INT8 yytype_int8;
226 #else
227 typedef signed char yytype_int8;
228 #endif
229
230 #ifdef YYTYPE_UINT16
231 typedef YYTYPE_UINT16 yytype_uint16;
232 #else
233 typedef unsigned short int yytype_uint16;
234 #endif
235
236 #ifdef YYTYPE_INT16
237 typedef YYTYPE_INT16 yytype_int16;
238 #else
239 typedef short int yytype_int16;
240 #endif
241
242 #ifndef YYSIZE_T
243 # ifdef __SIZE_TYPE__
244 # define YYSIZE_T __SIZE_TYPE__
245 # elif defined size_t
246 # define YYSIZE_T size_t
247 # elif ! defined YYSIZE_T
248 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
249 # define YYSIZE_T size_t
250 # else
251 # define YYSIZE_T unsigned int
252 # endif
253 #endif
254
255 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
256
257 #ifndef YY_
258 # if defined YYENABLE_NLS && YYENABLE_NLS
259 # if ENABLE_NLS
260 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
261 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
262 # endif
263 # endif
264 # ifndef YY_
265 # define YY_(Msgid) Msgid
266 # endif
267 #endif
268
269 #ifndef YY_ATTRIBUTE
270 # if (defined __GNUC__ \
271 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
272 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
273 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
274 # else
275 # define YY_ATTRIBUTE(Spec) /* empty */
276 # endif
277 #endif
278
279 #ifndef YY_ATTRIBUTE_PURE
280 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
281 #endif
282
283 #ifndef YY_ATTRIBUTE_UNUSED
284 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
285 #endif
286
287 #if !defined _Noreturn \
288 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
289 # if defined _MSC_VER && 1200 <= _MSC_VER
290 # define _Noreturn __declspec (noreturn)
291 # else
292 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
293 # endif
294 #endif
295
296 /* Suppress unused-variable warnings by "using" E. */
297 #if ! defined lint || defined __GNUC__
298 # define YYUSE(E) ((void) (E))
299 #else
300 # define YYUSE(E) /* empty */
301 #endif
302
303 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
304 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
305 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
306 _Pragma ("GCC diagnostic push") \
307 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
308 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
309 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
310 _Pragma ("GCC diagnostic pop")
311 #else
312 # define YY_INITIAL_VALUE(Value) Value
313 #endif
314 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
315 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
316 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
317 #endif
318 #ifndef YY_INITIAL_VALUE
319 # define YY_INITIAL_VALUE(Value) /* Nothing. */
320 #endif
321
322
323 #if ! defined yyoverflow || YYERROR_VERBOSE
324
325 /* The parser invokes alloca or malloc; define the necessary symbols. */
326
327 # ifdef YYSTACK_USE_ALLOCA
328 # if YYSTACK_USE_ALLOCA
329 # ifdef __GNUC__
330 # define YYSTACK_ALLOC __builtin_alloca
331 # elif defined __BUILTIN_VA_ARG_INCR
332 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
333 # elif defined _AIX
334 # define YYSTACK_ALLOC __alloca
335 # elif defined _MSC_VER
336 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
337 # define alloca _alloca
338 # else
339 # define YYSTACK_ALLOC alloca
340 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
341 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
342 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
343 # ifndef EXIT_SUCCESS
344 # define EXIT_SUCCESS 0
345 # endif
346 # endif
347 # endif
348 # endif
349 # endif
350
351 # ifdef YYSTACK_ALLOC
352 /* Pacify GCC's 'empty if-body' warning. */
353 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
354 # ifndef YYSTACK_ALLOC_MAXIMUM
355 /* The OS might guarantee only one guard page at the bottom of the stack,
356 and a page size can be as small as 4096 bytes. So we cannot safely
357 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
358 to allow for a few compiler-allocated temporary stack slots. */
359 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
360 # endif
361 # else
362 # define YYSTACK_ALLOC YYMALLOC
363 # define YYSTACK_FREE YYFREE
364 # ifndef YYSTACK_ALLOC_MAXIMUM
365 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
366 # endif
367 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
368 && ! ((defined YYMALLOC || defined malloc) \
369 && (defined YYFREE || defined free)))
370 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
371 # ifndef EXIT_SUCCESS
372 # define EXIT_SUCCESS 0
373 # endif
374 # endif
375 # ifndef YYMALLOC
376 # define YYMALLOC malloc
377 # if ! defined malloc && ! defined EXIT_SUCCESS
378 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
379 # endif
380 # endif
381 # ifndef YYFREE
382 # define YYFREE free
383 # if ! defined free && ! defined EXIT_SUCCESS
384 void free (void *); /* INFRINGES ON USER NAME SPACE */
385 # endif
386 # endif
387 # endif
388 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
389
390
391 #if (! defined yyoverflow \
392 && (! defined __cplusplus \
393 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
394
395 /* A type that is properly aligned for any stack member. */
396 union yyalloc
397 {
398 yytype_int16 yyss_alloc;
399 YYSTYPE yyvs_alloc;
400 };
401
402 /* The size of the maximum gap between one aligned stack and the next. */
403 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
404
405 /* The size of an array large to enough to hold all stacks, each with
406 N elements. */
407 # define YYSTACK_BYTES(N) \
408 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
409 + YYSTACK_GAP_MAXIMUM)
410
411 # define YYCOPY_NEEDED 1
412
413 /* Relocate STACK from its old location to the new one. The
414 local variables YYSIZE and YYSTACKSIZE give the old and new number of
415 elements in the stack, and YYPTR gives the new location of the
416 stack. Advance YYPTR to a properly aligned location for the next
417 stack. */
418 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
419 do \
420 { \
421 YYSIZE_T yynewbytes; \
422 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
423 Stack = &yyptr->Stack_alloc; \
424 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
425 yyptr += yynewbytes / sizeof (*yyptr); \
426 } \
427 while (0)
428
429 #endif
430
431 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
432 /* Copy COUNT objects from SRC to DST. The source and destination do
433 not overlap. */
434 # ifndef YYCOPY
435 # if defined __GNUC__ && 1 < __GNUC__
436 # define YYCOPY(Dst, Src, Count) \
437 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
438 # else
439 # define YYCOPY(Dst, Src, Count) \
440 do \
441 { \
442 YYSIZE_T yyi; \
443 for (yyi = 0; yyi < (Count); yyi++) \
444 (Dst)[yyi] = (Src)[yyi]; \
445 } \
446 while (0)
447 # endif
448 # endif
449 #endif /* !YYCOPY_NEEDED */
450
451 /* YYFINAL -- State number of the termination state. */
452 #define YYFINAL 107
453 /* YYLAST -- Last index in YYTABLE. */
454 #define YYLAST 177
455
456 /* YYNTOKENS -- Number of terminals. */
457 #define YYNTOKENS 38
458 /* YYNNTS -- Number of nonterminals. */
459 #define YYNNTS 21
460 /* YYNRULES -- Number of rules. */
461 #define YYNRULES 104
462 /* YYNSTATES -- Number of states. */
463 #define YYNSTATES 166
464
465 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
466 by yylex, with out-of-bounds checking. */
467 #define YYUNDEFTOK 2
468 #define YYMAXUTOK 292
469
470 #define YYTRANSLATE(YYX) \
471 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
472
473 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
474 as returned by yylex, without out-of-bounds checking. */
475 static const yytype_uint8 yytranslate[] =
476 {
477 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
478 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
479 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
480 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
481 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
482 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
483 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
484 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
485 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
486 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
487 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
488 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
489 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
490 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
491 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
492 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
493 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
494 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
495 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
496 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
498 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
499 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
500 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
501 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
502 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
503 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
504 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
505 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
506 35, 36, 37
507 };
508
509 #if YYDEBUG
510 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
511 static const yytype_uint16 yyrline[] =
512 {
513 0, 69, 69, 70, 71, 72, 73, 74, 75, 76,
514 77, 78, 79, 80, 84, 85, 86, 87, 88, 89,
515 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
516 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
517 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
518 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
519 133, 178, 179, 183, 184, 185, 186, 187, 188, 189,
520 190, 191, 192, 193, 194, 195, 199, 200, 204, 208,
521 209, 213, 217, 218, 222, 226, 227, 231, 235, 236,
522 240, 241, 242, 246, 247, 251, 252, 256, 257, 261,
523 270, 271, 275, 279, 280
524 };
525 #endif
526
527 #if YYDEBUG || YYERROR_VERBOSE || 0
528 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
529 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
530 static const char *const yytname[] =
531 {
532 "$end", "error", "$undefined", "LISTHOST", "LISTDISK", "LISTPROPERTY",
533 "SETHOST", "SETDISK", "SETDATE", "SETTAPE", "SETMODE", "SETDEVICE",
534 "SETPROPERTY", "CD", "CDX", "QUIT", "DHIST", "LS", "ADD", "ADDX",
535 "EXTRACT", "DASH_H", "LIST", "DELETE", "DELETEX", "PWD", "CLEAR", "HELP",
536 "LCD", "LPWD", "MODE", "SMB", "TAR", "APPEND", "PRIORITY",
537 "SETTRANSLATE", "NL", "STRING", "$accept", "ucommand", "set_command",
538 "setdate_command", "display_command", "quit_command", "add_command",
539 "add_path", "addx_command", "addx_path", "delete_command", "delete_path",
540 "deletex_command", "deletex_path", "local_command", "help_command",
541 "extract_command", "invalid_command", "property_value", "invalid_string",
542 "bogus_string", YY_NULLPTR
543 };
544 #endif
545
546 # ifdef YYPRINT
547 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
548 (internal) symbol number NUM (which must be that of a token). */
549 static const yytype_uint16 yytoknum[] =
550 {
551 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
552 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
553 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
554 285, 286, 287, 288, 289, 290, 291, 292
555 };
556 # endif
557
558 #define YYPACT_NINF -127
559
560 #define yypact_value_is_default(Yystate) \
561 (!!((Yystate) == (-127)))
562
563 #define YYTABLE_NINF -1
564
565 #define yytable_value_is_error(Yytable_value) \
566 0
567
568 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
569 STATE-NUM. */
570 static const yytype_int16 yypact[] =
571 {
572 109, -29, 2, 4, 6, -34, 9, 13, -6, -8,
573 0, 20, 22, 27, 33, 35, -28, -19, 37, 39,
574 -15, -10, 41, 43, 47, 49, 51, 53, 55, 59,
575 52, -127, -127, -127, -127, -127, -127, -127, -127, -127,
576 -127, -127, -127, -127, 59, -127, -127, 61, -127, -127,
577 -127, 65, 67, -127, 69, -127, 71, 73, 104, -127,
578 -127, -2, -127, 106, -20, 111, -127, 113, -127, 115,
579 -127, 118, -127, -127, -127, -127, -127, -127, -127, 120,
580 -127, 122, -127, -127, -127, 124, -127, 126, -127, 128,
581 -127, -127, -127, -127, -127, -127, -127, 130, -127, -127,
582 -127, -127, -127, 132, -127, 59, -127, -127, -127, -127,
583 -127, -127, -127, -127, 134, -127, -127, -127, -127, -127,
584 -127, -127, -127, 136, -127, -127, 138, -127, 113, -127,
585 113, -127, 113, -127, -127, -127, -127, -127, -127, -127,
586 -127, -127, -127, -127, -127, -127, -127, -127, -127, -127,
587 -127, 11, -127, -127, -127, -127, 140, -127, 113, -127,
588 -127, -127, -127, -127, -127, -127
589 };
590
591 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
592 Performed when YYTABLE does not specify something else to do. Zero
593 means the default is an error. */
594 static const yytype_uint8 yydefact[] =
595 {
596 0, 0, 0, 0, 0, 30, 0, 0, 0, 0,
597 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
598 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
599 0, 2, 3, 4, 5, 6, 7, 8, 9, 10,
600 11, 12, 13, 14, 0, 15, 17, 0, 19, 20,
601 26, 0, 0, 61, 0, 32, 0, 0, 0, 59,
602 58, 0, 36, 0, 0, 0, 44, 0, 50, 0,
603 53, 0, 76, 77, 63, 64, 65, 66, 80, 0,
604 83, 0, 97, 98, 68, 0, 86, 0, 89, 0,
605 70, 71, 72, 73, 95, 96, 94, 0, 90, 91,
606 74, 75, 21, 0, 104, 0, 99, 1, 102, 16,
607 18, 24, 25, 28, 0, 60, 62, 31, 33, 54,
608 56, 55, 57, 0, 34, 37, 0, 45, 0, 46,
609 0, 101, 0, 40, 48, 49, 51, 52, 78, 79,
610 81, 82, 67, 69, 84, 85, 87, 88, 92, 93,
611 23, 0, 103, 27, 29, 38, 0, 47, 0, 41,
612 42, 100, 22, 35, 39, 43
613 };
614
615 /* YYPGOTO[NTERM-NUM]. */
616 static const yytype_int8 yypgoto[] =
617 {
618 -127, -127, -127, -127, -127, -127, -127, -127, -127, -127,
619 -127, -127, -127, -127, -127, -127, -127, -127, -126, -3,
620 -43
621 };
622
623 /* YYDEFGOTO[NTERM-NUM]. */
624 static const yytype_int16 yydefgoto[] =
625 {
626 -1, 30, 31, 32, 33, 34, 35, 79, 36, 81,
627 37, 87, 38, 89, 39, 40, 41, 42, 133, 45,
628 106
629 };
630
631 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
632 positive, shift that token. If negative, reduce the rule whose
633 number is the opposite. If YYTABLE_NINF, syntax error. */
634 static const yytype_uint8 yytable[] =
635 {
636 49, 108, 159, 52, 160, 60, 161, 43, 44, 78,
637 73, 75, 77, 61, 126, 83, 127, 128, 80, 91,
638 93, 95, 86, 99, 101, 57, 58, 88, 62, 63,
639 59, 44, 165, 64, 65, 123, 66, 67, 46, 47,
640 48, 44, 50, 51, 110, 53, 54, 162, 112, 55,
641 56, 116, 107, 118, 120, 122, 68, 69, 70, 71,
642 125, 0, 152, 72, 44, 0, 135, 0, 137, 74,
643 44, 76, 44, 82, 44, 84, 85, 90, 44, 92,
644 44, 0, 143, 94, 44, 96, 97, 98, 44, 100,
645 44, 102, 103, 0, 149, 104, 105, 109, 44, 0,
646 151, 111, 44, 113, 114, 115, 44, 117, 44, 119,
647 44, 154, 1, 2, 3, 4, 5, 6, 7, 8,
648 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
649 0, 19, 20, 21, 22, 23, 24, 25, 26, 27,
650 121, 44, 124, 44, 28, 0, 29, 129, 130, 131,
651 132, 134, 44, 164, 136, 44, 138, 139, 140, 141,
652 142, 44, 144, 145, 146, 147, 148, 44, 150, 44,
653 153, 44, 155, 156, 157, 158, 163, 44
654 };
655
656 static const yytype_int16 yycheck[] =
657 {
658 3, 44, 128, 37, 130, 8, 132, 36, 37, 37,
659 13, 14, 15, 21, 34, 18, 36, 37, 37, 22,
660 23, 24, 37, 26, 27, 31, 32, 37, 36, 37,
661 36, 37, 158, 33, 34, 37, 36, 37, 36, 37,
662 36, 37, 36, 37, 47, 36, 37, 36, 51, 36,
663 37, 54, 0, 56, 57, 58, 36, 37, 36, 37,
664 63, -1, 105, 36, 37, -1, 69, -1, 71, 36,
665 37, 36, 37, 36, 37, 36, 37, 36, 37, 36,
666 37, -1, 85, 36, 37, 36, 37, 36, 37, 36,
667 37, 36, 37, -1, 97, 36, 37, 36, 37, -1,
668 103, 36, 37, 36, 37, 36, 37, 36, 37, 36,
669 37, 114, 3, 4, 5, 6, 7, 8, 9, 10,
670 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
671 -1, 22, 23, 24, 25, 26, 27, 28, 29, 30,
672 36, 37, 36, 37, 35, -1, 37, 36, 37, 36,
673 37, 36, 37, 156, 36, 37, 36, 37, 36, 37,
674 36, 37, 36, 37, 36, 37, 36, 37, 36, 37,
675 36, 37, 36, 37, 36, 37, 36, 37
676 };
677
678 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
679 symbol of state STATE-NUM. */
680 static const yytype_uint8 yystos[] =
681 {
682 0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
683 12, 13, 14, 15, 16, 17, 18, 19, 20, 22,
684 23, 24, 25, 26, 27, 28, 29, 30, 35, 37,
685 39, 40, 41, 42, 43, 44, 46, 48, 50, 52,
686 53, 54, 55, 36, 37, 57, 36, 37, 36, 57,
687 36, 37, 37, 36, 37, 36, 37, 31, 32, 36,
688 57, 21, 36, 37, 33, 34, 36, 37, 36, 37,
689 36, 37, 36, 57, 36, 57, 36, 57, 37, 45,
690 37, 47, 36, 57, 36, 37, 37, 49, 37, 51,
691 36, 57, 36, 57, 36, 57, 36, 37, 36, 57,
692 36, 57, 36, 37, 36, 37, 58, 0, 58, 36,
693 57, 36, 57, 36, 37, 36, 57, 36, 57, 36,
694 57, 36, 57, 37, 36, 57, 34, 36, 37, 36,
695 37, 36, 37, 56, 36, 57, 36, 57, 36, 37,
696 36, 37, 36, 57, 36, 37, 36, 37, 36, 57,
697 36, 57, 58, 36, 57, 36, 37, 36, 37, 56,
698 56, 56, 36, 36, 57, 56
699 };
700
701 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
702 static const yytype_uint8 yyr1[] =
703 {
704 0, 38, 39, 39, 39, 39, 39, 39, 39, 39,
705 39, 39, 39, 39, 40, 40, 40, 40, 40, 40,
706 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
707 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
708 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
709 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
710 41, 41, 41, 42, 42, 42, 42, 42, 42, 42,
711 42, 42, 42, 42, 42, 42, 43, 43, 44, 45,
712 45, 46, 47, 47, 48, 49, 49, 50, 51, 51,
713 52, 52, 52, 52, 52, 53, 53, 54, 54, 55,
714 56, 56, 57, 58, 58
715 };
716
717 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
718 static const yytype_uint8 yyr2[] =
719 {
720 0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
721 1, 1, 1, 1, 2, 2, 3, 2, 3, 2,
722 2, 2, 4, 3, 3, 3, 2, 4, 3, 4,
723 1, 3, 2, 3, 3, 5, 2, 3, 4, 5,
724 3, 4, 4, 5, 2, 3, 3, 4, 3, 3,
725 2, 3, 3, 2, 3, 3, 3, 3, 2, 2,
726 3, 2, 3, 2, 2, 2, 2, 3, 2, 3,
727 2, 2, 2, 2, 2, 2, 2, 2, 3, 2,
728 1, 3, 2, 1, 3, 2, 1, 3, 2, 1,
729 2, 2, 3, 3, 2, 2, 2, 2, 2, 2,
730 2, 1, 2, 2, 1
731 };
732
733
734 #define yyerrok (yyerrstatus = 0)
735 #define yyclearin (yychar = YYEMPTY)
736 #define YYEMPTY (-2)
737 #define YYEOF 0
738
739 #define YYACCEPT goto yyacceptlab
740 #define YYABORT goto yyabortlab
741 #define YYERROR goto yyerrorlab
742
743
744 #define YYRECOVERING() (!!yyerrstatus)
745
746 #define YYBACKUP(Token, Value) \
747 do \
748 if (yychar == YYEMPTY) \
749 { \
750 yychar = (Token); \
751 yylval = (Value); \
752 YYPOPSTACK (yylen); \
753 yystate = *yyssp; \
754 goto yybackup; \
755 } \
756 else \
757 { \
758 yyerror (YY_("syntax error: cannot back up")); \
759 YYERROR; \
760 } \
761 while (0)
762
763 /* Error token number */
764 #define YYTERROR 1
765 #define YYERRCODE 256
766
767
768
769 /* Enable debugging if requested. */
770 #if YYDEBUG
771
772 # ifndef YYFPRINTF
773 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
774 # define YYFPRINTF fprintf
775 # endif
776
777 # define YYDPRINTF(Args) \
778 do { \
779 if (yydebug) \
780 YYFPRINTF Args; \
781 } while (0)
782
783 /* This macro is provided for backward compatibility. */
784 #ifndef YY_LOCATION_PRINT
785 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
786 #endif
787
788
789 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
790 do { \
791 if (yydebug) \
792 { \
793 YYFPRINTF (stderr, "%s ", Title); \
794 yy_symbol_print (stderr, \
795 Type, Value); \
796 YYFPRINTF (stderr, "\n"); \
797 } \
798 } while (0)
799
800
801 /*----------------------------------------.
802 | Print this symbol's value on YYOUTPUT. |
803 `----------------------------------------*/
804
805 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)806 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
807 {
808 FILE *yyo = yyoutput;
809 YYUSE (yyo);
810 if (!yyvaluep)
811 return;
812 # ifdef YYPRINT
813 if (yytype < YYNTOKENS)
814 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
815 # endif
816 YYUSE (yytype);
817 }
818
819
820 /*--------------------------------.
821 | Print this symbol on YYOUTPUT. |
822 `--------------------------------*/
823
824 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)825 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
826 {
827 YYFPRINTF (yyoutput, "%s %s (",
828 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
829
830 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
831 YYFPRINTF (yyoutput, ")");
832 }
833
834 /*------------------------------------------------------------------.
835 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
836 | TOP (included). |
837 `------------------------------------------------------------------*/
838
839 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)840 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
841 {
842 YYFPRINTF (stderr, "Stack now");
843 for (; yybottom <= yytop; yybottom++)
844 {
845 int yybot = *yybottom;
846 YYFPRINTF (stderr, " %d", yybot);
847 }
848 YYFPRINTF (stderr, "\n");
849 }
850
851 # define YY_STACK_PRINT(Bottom, Top) \
852 do { \
853 if (yydebug) \
854 yy_stack_print ((Bottom), (Top)); \
855 } while (0)
856
857
858 /*------------------------------------------------.
859 | Report that the YYRULE is going to be reduced. |
860 `------------------------------------------------*/
861
862 static void
yy_reduce_print(yytype_int16 * yyssp,YYSTYPE * yyvsp,int yyrule)863 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
864 {
865 unsigned long int yylno = yyrline[yyrule];
866 int yynrhs = yyr2[yyrule];
867 int yyi;
868 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
869 yyrule - 1, yylno);
870 /* The symbols being reduced. */
871 for (yyi = 0; yyi < yynrhs; yyi++)
872 {
873 YYFPRINTF (stderr, " $%d = ", yyi + 1);
874 yy_symbol_print (stderr,
875 yystos[yyssp[yyi + 1 - yynrhs]],
876 &(yyvsp[(yyi + 1) - (yynrhs)])
877 );
878 YYFPRINTF (stderr, "\n");
879 }
880 }
881
882 # define YY_REDUCE_PRINT(Rule) \
883 do { \
884 if (yydebug) \
885 yy_reduce_print (yyssp, yyvsp, Rule); \
886 } while (0)
887
888 /* Nonzero means print parse trace. It is left uninitialized so that
889 multiple parsers can coexist. */
890 int yydebug;
891 #else /* !YYDEBUG */
892 # define YYDPRINTF(Args)
893 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
894 # define YY_STACK_PRINT(Bottom, Top)
895 # define YY_REDUCE_PRINT(Rule)
896 #endif /* !YYDEBUG */
897
898
899 /* YYINITDEPTH -- initial size of the parser's stacks. */
900 #ifndef YYINITDEPTH
901 # define YYINITDEPTH 200
902 #endif
903
904 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
905 if the built-in stack extension method is used).
906
907 Do not make this value too large; the results are undefined if
908 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
909 evaluated with infinite-precision integer arithmetic. */
910
911 #ifndef YYMAXDEPTH
912 # define YYMAXDEPTH 10000
913 #endif
914
915
916 #if YYERROR_VERBOSE
917
918 # ifndef yystrlen
919 # if defined __GLIBC__ && defined _STRING_H
920 # define yystrlen strlen
921 # else
922 /* Return the length of YYSTR. */
923 static YYSIZE_T
yystrlen(const char * yystr)924 yystrlen (const char *yystr)
925 {
926 YYSIZE_T yylen;
927 for (yylen = 0; yystr[yylen]; yylen++)
928 continue;
929 return yylen;
930 }
931 # endif
932 # endif
933
934 # ifndef yystpcpy
935 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
936 # define yystpcpy stpcpy
937 # else
938 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
939 YYDEST. */
940 static char *
yystpcpy(char * yydest,const char * yysrc)941 yystpcpy (char *yydest, const char *yysrc)
942 {
943 char *yyd = yydest;
944 const char *yys = yysrc;
945
946 while ((*yyd++ = *yys++) != '\0')
947 continue;
948
949 return yyd - 1;
950 }
951 # endif
952 # endif
953
954 # ifndef yytnamerr
955 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
956 quotes and backslashes, so that it's suitable for yyerror. The
957 heuristic is that double-quoting is unnecessary unless the string
958 contains an apostrophe, a comma, or backslash (other than
959 backslash-backslash). YYSTR is taken from yytname. If YYRES is
960 null, do not copy; instead, return the length of what the result
961 would have been. */
962 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)963 yytnamerr (char *yyres, const char *yystr)
964 {
965 if (*yystr == '"')
966 {
967 YYSIZE_T yyn = 0;
968 char const *yyp = yystr;
969
970 for (;;)
971 switch (*++yyp)
972 {
973 case '\'':
974 case ',':
975 goto do_not_strip_quotes;
976
977 case '\\':
978 if (*++yyp != '\\')
979 goto do_not_strip_quotes;
980 /* Fall through. */
981 default:
982 if (yyres)
983 yyres[yyn] = *yyp;
984 yyn++;
985 break;
986
987 case '"':
988 if (yyres)
989 yyres[yyn] = '\0';
990 return yyn;
991 }
992 do_not_strip_quotes: ;
993 }
994
995 if (! yyres)
996 return yystrlen (yystr);
997
998 return yystpcpy (yyres, yystr) - yyres;
999 }
1000 # endif
1001
1002 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1003 about the unexpected token YYTOKEN for the state stack whose top is
1004 YYSSP.
1005
1006 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1007 not large enough to hold the message. In that case, also set
1008 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1009 required number of bytes is too large to store. */
1010 static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)1011 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1012 yytype_int16 *yyssp, int yytoken)
1013 {
1014 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1015 YYSIZE_T yysize = yysize0;
1016 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1017 /* Internationalized format string. */
1018 const char *yyformat = YY_NULLPTR;
1019 /* Arguments of yyformat. */
1020 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1021 /* Number of reported tokens (one for the "unexpected", one per
1022 "expected"). */
1023 int yycount = 0;
1024
1025 /* There are many possibilities here to consider:
1026 - If this state is a consistent state with a default action, then
1027 the only way this function was invoked is if the default action
1028 is an error action. In that case, don't check for expected
1029 tokens because there are none.
1030 - The only way there can be no lookahead present (in yychar) is if
1031 this state is a consistent state with a default action. Thus,
1032 detecting the absence of a lookahead is sufficient to determine
1033 that there is no unexpected or expected token to report. In that
1034 case, just report a simple "syntax error".
1035 - Don't assume there isn't a lookahead just because this state is a
1036 consistent state with a default action. There might have been a
1037 previous inconsistent state, consistent state with a non-default
1038 action, or user semantic action that manipulated yychar.
1039 - Of course, the expected token list depends on states to have
1040 correct lookahead information, and it depends on the parser not
1041 to perform extra reductions after fetching a lookahead from the
1042 scanner and before detecting a syntax error. Thus, state merging
1043 (from LALR or IELR) and default reductions corrupt the expected
1044 token list. However, the list is correct for canonical LR with
1045 one exception: it will still contain any token that will not be
1046 accepted due to an error action in a later state.
1047 */
1048 if (yytoken != YYEMPTY)
1049 {
1050 int yyn = yypact[*yyssp];
1051 yyarg[yycount++] = yytname[yytoken];
1052 if (!yypact_value_is_default (yyn))
1053 {
1054 /* Start YYX at -YYN if negative to avoid negative indexes in
1055 YYCHECK. In other words, skip the first -YYN actions for
1056 this state because they are default actions. */
1057 int yyxbegin = yyn < 0 ? -yyn : 0;
1058 /* Stay within bounds of both yycheck and yytname. */
1059 int yychecklim = YYLAST - yyn + 1;
1060 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1061 int yyx;
1062
1063 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1064 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1065 && !yytable_value_is_error (yytable[yyx + yyn]))
1066 {
1067 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1068 {
1069 yycount = 1;
1070 yysize = yysize0;
1071 break;
1072 }
1073 yyarg[yycount++] = yytname[yyx];
1074 {
1075 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1076 if (! (yysize <= yysize1
1077 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1078 return 2;
1079 yysize = yysize1;
1080 }
1081 }
1082 }
1083 }
1084
1085 switch (yycount)
1086 {
1087 # define YYCASE_(N, S) \
1088 case N: \
1089 yyformat = S; \
1090 break
1091 YYCASE_(0, YY_("syntax error"));
1092 YYCASE_(1, YY_("syntax error, unexpected %s"));
1093 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1094 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1095 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1096 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1097 # undef YYCASE_
1098 }
1099
1100 {
1101 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1102 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1103 return 2;
1104 yysize = yysize1;
1105 }
1106
1107 if (*yymsg_alloc < yysize)
1108 {
1109 *yymsg_alloc = 2 * yysize;
1110 if (! (yysize <= *yymsg_alloc
1111 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1112 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1113 return 1;
1114 }
1115
1116 /* Avoid sprintf, as that infringes on the user's name space.
1117 Don't have undefined behavior even if the translation
1118 produced a string with the wrong number of "%s"s. */
1119 {
1120 char *yyp = *yymsg;
1121 int yyi = 0;
1122 while ((*yyp = *yyformat) != '\0')
1123 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1124 {
1125 yyp += yytnamerr (yyp, yyarg[yyi++]);
1126 yyformat += 2;
1127 }
1128 else
1129 {
1130 yyp++;
1131 yyformat++;
1132 }
1133 }
1134 return 0;
1135 }
1136 #endif /* YYERROR_VERBOSE */
1137
1138 /*-----------------------------------------------.
1139 | Release the memory associated to this symbol. |
1140 `-----------------------------------------------*/
1141
1142 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep)1143 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1144 {
1145 YYUSE (yyvaluep);
1146 if (!yymsg)
1147 yymsg = "Deleting";
1148 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1149
1150 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1151 YYUSE (yytype);
1152 YY_IGNORE_MAYBE_UNINITIALIZED_END
1153 }
1154
1155
1156
1157
1158 /* The lookahead symbol. */
1159 int yychar;
1160
1161 /* The semantic value of the lookahead symbol. */
1162 YYSTYPE yylval;
1163 /* Number of syntax errors so far. */
1164 int yynerrs;
1165
1166
1167 /*----------.
1168 | yyparse. |
1169 `----------*/
1170
1171 int
yyparse(void)1172 yyparse (void)
1173 {
1174 int yystate;
1175 /* Number of tokens to shift before error messages enabled. */
1176 int yyerrstatus;
1177
1178 /* The stacks and their tools:
1179 'yyss': related to states.
1180 'yyvs': related to semantic values.
1181
1182 Refer to the stacks through separate pointers, to allow yyoverflow
1183 to reallocate them elsewhere. */
1184
1185 /* The state stack. */
1186 yytype_int16 yyssa[YYINITDEPTH];
1187 yytype_int16 *yyss;
1188 yytype_int16 *yyssp;
1189
1190 /* The semantic value stack. */
1191 YYSTYPE yyvsa[YYINITDEPTH];
1192 YYSTYPE *yyvs;
1193 YYSTYPE *yyvsp;
1194
1195 YYSIZE_T yystacksize;
1196
1197 int yyn;
1198 int yyresult;
1199 /* Lookahead token as an internal (translated) token number. */
1200 int yytoken = 0;
1201 /* The variables used to return semantic value and location from the
1202 action routines. */
1203 YYSTYPE yyval;
1204
1205 #if YYERROR_VERBOSE
1206 /* Buffer for error messages, and its allocated size. */
1207 char yymsgbuf[128];
1208 char *yymsg = yymsgbuf;
1209 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1210 #endif
1211
1212 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1213
1214 /* The number of symbols on the RHS of the reduced rule.
1215 Keep to zero when no symbol should be popped. */
1216 int yylen = 0;
1217
1218 yyssp = yyss = yyssa;
1219 yyvsp = yyvs = yyvsa;
1220 yystacksize = YYINITDEPTH;
1221
1222 YYDPRINTF ((stderr, "Starting parse\n"));
1223
1224 yystate = 0;
1225 yyerrstatus = 0;
1226 yynerrs = 0;
1227 yychar = YYEMPTY; /* Cause a token to be read. */
1228 goto yysetstate;
1229
1230 /*------------------------------------------------------------.
1231 | yynewstate -- Push a new state, which is found in yystate. |
1232 `------------------------------------------------------------*/
1233 yynewstate:
1234 /* In all cases, when you get here, the value and location stacks
1235 have just been pushed. So pushing a state here evens the stacks. */
1236 yyssp++;
1237
1238 yysetstate:
1239 *yyssp = yystate;
1240
1241 if (yyss + yystacksize - 1 <= yyssp)
1242 {
1243 /* Get the current used size of the three stacks, in elements. */
1244 YYSIZE_T yysize = yyssp - yyss + 1;
1245
1246 #ifdef yyoverflow
1247 {
1248 /* Give user a chance to reallocate the stack. Use copies of
1249 these so that the &'s don't force the real ones into
1250 memory. */
1251 YYSTYPE *yyvs1 = yyvs;
1252 yytype_int16 *yyss1 = yyss;
1253
1254 /* Each stack pointer address is followed by the size of the
1255 data in use in that stack, in bytes. This used to be a
1256 conditional around just the two extra args, but that might
1257 be undefined if yyoverflow is a macro. */
1258 yyoverflow (YY_("memory exhausted"),
1259 &yyss1, yysize * sizeof (*yyssp),
1260 &yyvs1, yysize * sizeof (*yyvsp),
1261 &yystacksize);
1262
1263 yyss = yyss1;
1264 yyvs = yyvs1;
1265 }
1266 #else /* no yyoverflow */
1267 # ifndef YYSTACK_RELOCATE
1268 goto yyexhaustedlab;
1269 # else
1270 /* Extend the stack our own way. */
1271 if (YYMAXDEPTH <= yystacksize)
1272 goto yyexhaustedlab;
1273 yystacksize *= 2;
1274 if (YYMAXDEPTH < yystacksize)
1275 yystacksize = YYMAXDEPTH;
1276
1277 {
1278 yytype_int16 *yyss1 = yyss;
1279 union yyalloc *yyptr =
1280 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1281 if (! yyptr)
1282 goto yyexhaustedlab;
1283 YYSTACK_RELOCATE (yyss_alloc, yyss);
1284 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1285 # undef YYSTACK_RELOCATE
1286 if (yyss1 != yyssa)
1287 YYSTACK_FREE (yyss1);
1288 }
1289 # endif
1290 #endif /* no yyoverflow */
1291
1292 yyssp = yyss + yysize - 1;
1293 yyvsp = yyvs + yysize - 1;
1294
1295 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1296 (unsigned long int) yystacksize));
1297
1298 if (yyss + yystacksize - 1 <= yyssp)
1299 YYABORT;
1300 }
1301
1302 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1303
1304 if (yystate == YYFINAL)
1305 YYACCEPT;
1306
1307 goto yybackup;
1308
1309 /*-----------.
1310 | yybackup. |
1311 `-----------*/
1312 yybackup:
1313
1314 /* Do appropriate processing given the current state. Read a
1315 lookahead token if we need one and don't already have one. */
1316
1317 /* First try to decide what to do without reference to lookahead token. */
1318 yyn = yypact[yystate];
1319 if (yypact_value_is_default (yyn))
1320 goto yydefault;
1321
1322 /* Not known => get a lookahead token if don't already have one. */
1323
1324 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1325 if (yychar == YYEMPTY)
1326 {
1327 YYDPRINTF ((stderr, "Reading a token: "));
1328 yychar = yylex ();
1329 }
1330
1331 if (yychar <= YYEOF)
1332 {
1333 yychar = yytoken = YYEOF;
1334 YYDPRINTF ((stderr, "Now at end of input.\n"));
1335 }
1336 else
1337 {
1338 yytoken = YYTRANSLATE (yychar);
1339 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1340 }
1341
1342 /* If the proper action on seeing token YYTOKEN is to reduce or to
1343 detect an error, take that action. */
1344 yyn += yytoken;
1345 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1346 goto yydefault;
1347 yyn = yytable[yyn];
1348 if (yyn <= 0)
1349 {
1350 if (yytable_value_is_error (yyn))
1351 goto yyerrlab;
1352 yyn = -yyn;
1353 goto yyreduce;
1354 }
1355
1356 /* Count tokens shifted since error; after three, turn off error
1357 status. */
1358 if (yyerrstatus)
1359 yyerrstatus--;
1360
1361 /* Shift the lookahead token. */
1362 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1363
1364 /* Discard the shifted token. */
1365 yychar = YYEMPTY;
1366
1367 yystate = yyn;
1368 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1369 *++yyvsp = yylval;
1370 YY_IGNORE_MAYBE_UNINITIALIZED_END
1371
1372 goto yynewstate;
1373
1374
1375 /*-----------------------------------------------------------.
1376 | yydefault -- do the default action for the current state. |
1377 `-----------------------------------------------------------*/
1378 yydefault:
1379 yyn = yydefact[yystate];
1380 if (yyn == 0)
1381 goto yyerrlab;
1382 goto yyreduce;
1383
1384
1385 /*-----------------------------.
1386 | yyreduce -- Do a reduction. |
1387 `-----------------------------*/
1388 yyreduce:
1389 /* yyn is the number of a rule to reduce with. */
1390 yylen = yyr2[yyn];
1391
1392 /* If YYLEN is nonzero, implement the default value of the action:
1393 '$$ = $1'.
1394
1395 Otherwise, the following line sets YYVAL to garbage.
1396 This behavior is undocumented and Bison
1397 users should not rely upon it. Assigning to YYVAL
1398 unconditionally makes the parser a bit smaller, and it avoids a
1399 GCC warning that YYVAL may be used uninitialized. */
1400 yyval = yyvsp[1-yylen];
1401
1402
1403 YY_REDUCE_PRINT (yyn);
1404 switch (yyn)
1405 {
1406 case 14:
1407 #line 84 "uparse.y" /* yacc.c:1646 */
1408 { list_host(); }
1409 #line 1410 "uparse.c" /* yacc.c:1646 */
1410 break;
1411
1412 case 15:
1413 #line 85 "uparse.y" /* yacc.c:1646 */
1414 { yyerror("Invalid argument"); }
1415 #line 1416 "uparse.c" /* yacc.c:1646 */
1416 break;
1417
1418 case 16:
1419 #line 86 "uparse.y" /* yacc.c:1646 */
1420 { list_disk((yyvsp[-1].strval)); amfree((yyvsp[-1].strval)); }
1421 #line 1422 "uparse.c" /* yacc.c:1646 */
1422 break;
1423
1424 case 17:
1425 #line 87 "uparse.y" /* yacc.c:1646 */
1426 { list_disk(NULL); }
1427 #line 1428 "uparse.c" /* yacc.c:1646 */
1428 break;
1429
1430 case 18:
1431 #line 88 "uparse.y" /* yacc.c:1646 */
1432 { yyerror("Invalid argument"); amfree((yyvsp[-1].strval)); }
1433 #line 1434 "uparse.c" /* yacc.c:1646 */
1434 break;
1435
1436 case 19:
1437 #line 89 "uparse.y" /* yacc.c:1646 */
1438 { list_property(); }
1439 #line 1440 "uparse.c" /* yacc.c:1646 */
1440 break;
1441
1442 case 20:
1443 #line 90 "uparse.y" /* yacc.c:1646 */
1444 { yyerror("Invalid argument"); }
1445 #line 1446 "uparse.c" /* yacc.c:1646 */
1446 break;
1447
1448 case 21:
1449 #line 91 "uparse.y" /* yacc.c:1646 */
1450 { set_translate(NULL); }
1451 #line 1452 "uparse.c" /* yacc.c:1646 */
1452 break;
1453
1454 case 22:
1455 #line 92 "uparse.y" /* yacc.c:1646 */
1456 { yyerror("Invalid argument"); }
1457 #line 1458 "uparse.c" /* yacc.c:1646 */
1458 break;
1459
1460 case 23:
1461 #line 93 "uparse.y" /* yacc.c:1646 */
1462 { set_translate((yyvsp[-1].strval)); amfree((yyvsp[-1].strval)); }
1463 #line 1464 "uparse.c" /* yacc.c:1646 */
1464 break;
1465
1466 case 24:
1467 #line 94 "uparse.y" /* yacc.c:1646 */
1468 { set_host((yyvsp[-1].strval)); amfree((yyvsp[-1].strval)); }
1469 #line 1470 "uparse.c" /* yacc.c:1646 */
1470 break;
1471
1472 case 25:
1473 #line 95 "uparse.y" /* yacc.c:1646 */
1474 { yyerror("Invalid argument"); amfree((yyvsp[-1].strval)); }
1475 #line 1476 "uparse.c" /* yacc.c:1646 */
1476 break;
1477
1478 case 26:
1479 #line 96 "uparse.y" /* yacc.c:1646 */
1480 { yyerror("Argument required"); }
1481 #line 1482 "uparse.c" /* yacc.c:1646 */
1482 break;
1483
1484 case 27:
1485 #line 97 "uparse.y" /* yacc.c:1646 */
1486 { set_disk((yyvsp[-2].strval), (yyvsp[-1].strval)); amfree((yyvsp[-2].strval)); amfree((yyvsp[-1].strval)); }
1487 #line 1488 "uparse.c" /* yacc.c:1646 */
1488 break;
1489
1490 case 28:
1491 #line 98 "uparse.y" /* yacc.c:1646 */
1492 { set_disk((yyvsp[-1].strval), NULL); amfree((yyvsp[-1].strval)); }
1493 #line 1494 "uparse.c" /* yacc.c:1646 */
1494 break;
1495
1496 case 29:
1497 #line 99 "uparse.y" /* yacc.c:1646 */
1498 { yyerror("Invalid argument"); amfree((yyvsp[-2].strval)); amfree((yyvsp[-1].strval)); }
1499 #line 1500 "uparse.c" /* yacc.c:1646 */
1500 break;
1501
1502 case 30:
1503 #line 100 "uparse.y" /* yacc.c:1646 */
1504 { yyerror("Argument required"); }
1505 #line 1506 "uparse.c" /* yacc.c:1646 */
1506 break;
1507
1508 case 31:
1509 #line 101 "uparse.y" /* yacc.c:1646 */
1510 { set_tape((yyvsp[-1].strval)); amfree((yyvsp[-1].strval)); }
1511 #line 1512 "uparse.c" /* yacc.c:1646 */
1512 break;
1513
1514 case 32:
1515 #line 102 "uparse.y" /* yacc.c:1646 */
1516 { set_tape("default"); }
1517 #line 1518 "uparse.c" /* yacc.c:1646 */
1518 break;
1519
1520 case 33:
1521 #line 103 "uparse.y" /* yacc.c:1646 */
1522 { yyerror("Invalid argument"); amfree((yyvsp[-1].strval)); }
1523 #line 1524 "uparse.c" /* yacc.c:1646 */
1524 break;
1525
1526 case 34:
1527 #line 104 "uparse.y" /* yacc.c:1646 */
1528 { set_device(NULL, (yyvsp[-1].strval)); amfree((yyvsp[-1].strval)); }
1529 #line 1530 "uparse.c" /* yacc.c:1646 */
1530 break;
1531
1532 case 35:
1533 #line 105 "uparse.y" /* yacc.c:1646 */
1534 { set_device((yyvsp[-2].strval), (yyvsp[-1].strval)); amfree((yyvsp[-2].strval)); amfree((yyvsp[-1].strval)); }
1535 #line 1536 "uparse.c" /* yacc.c:1646 */
1536 break;
1537
1538 case 36:
1539 #line 106 "uparse.y" /* yacc.c:1646 */
1540 { set_device(NULL, NULL); }
1541 #line 1542 "uparse.c" /* yacc.c:1646 */
1542 break;
1543
1544 case 37:
1545 #line 107 "uparse.y" /* yacc.c:1646 */
1546 { yyerror("Invalid argument"); amfree((yyvsp[-1].strval)); }
1547 #line 1548 "uparse.c" /* yacc.c:1646 */
1548 break;
1549
1550 case 38:
1551 #line 108 "uparse.y" /* yacc.c:1646 */
1552 { yyerror("Invalid argument"); amfree((yyvsp[-1].strval)); }
1553 #line 1554 "uparse.c" /* yacc.c:1646 */
1554 break;
1555
1556 case 39:
1557 #line 109 "uparse.y" /* yacc.c:1646 */
1558 { yyerror("Invalid argument"); amfree((yyvsp[-2].strval)); amfree((yyvsp[-1].strval)); }
1559 #line 1560 "uparse.c" /* yacc.c:1646 */
1560 break;
1561
1562 case 40:
1563 #line 110 "uparse.y" /* yacc.c:1646 */
1564 { set_property_name((yyvsp[-1].strval), 0); amfree((yyvsp[-1].strval)); }
1565 #line 1566 "uparse.c" /* yacc.c:1646 */
1566 break;
1567
1568 case 41:
1569 #line 111 "uparse.y" /* yacc.c:1646 */
1570 { set_property_name((yyvsp[-1].strval), 1); amfree((yyvsp[-1].strval)); }
1571 #line 1572 "uparse.c" /* yacc.c:1646 */
1572 break;
1573
1574 case 42:
1575 #line 112 "uparse.y" /* yacc.c:1646 */
1576 { set_property_name((yyvsp[-1].strval), 0); amfree((yyvsp[-1].strval)); }
1577 #line 1578 "uparse.c" /* yacc.c:1646 */
1578 break;
1579
1580 case 43:
1581 #line 113 "uparse.y" /* yacc.c:1646 */
1582 { set_property_name((yyvsp[-1].strval), 1); amfree((yyvsp[-1].strval)); }
1583 #line 1584 "uparse.c" /* yacc.c:1646 */
1584 break;
1585
1586 case 44:
1587 #line 114 "uparse.y" /* yacc.c:1646 */
1588 { yyerror("Invalid argument"); }
1589 #line 1590 "uparse.c" /* yacc.c:1646 */
1590 break;
1591
1592 case 45:
1593 #line 115 "uparse.y" /* yacc.c:1646 */
1594 { yyerror("Invalid argument"); }
1595 #line 1596 "uparse.c" /* yacc.c:1646 */
1596 break;
1597
1598 case 46:
1599 #line 116 "uparse.y" /* yacc.c:1646 */
1600 { yyerror("Invalid argument"); }
1601 #line 1602 "uparse.c" /* yacc.c:1646 */
1602 break;
1603
1604 case 47:
1605 #line 117 "uparse.y" /* yacc.c:1646 */
1606 { yyerror("Invalid argument"); }
1607 #line 1608 "uparse.c" /* yacc.c:1646 */
1608 break;
1609
1610 case 48:
1611 #line 118 "uparse.y" /* yacc.c:1646 */
1612 { cd_glob((yyvsp[-1].strval), 1); amfree((yyvsp[-1].strval)); }
1613 #line 1614 "uparse.c" /* yacc.c:1646 */
1614 break;
1615
1616 case 49:
1617 #line 119 "uparse.y" /* yacc.c:1646 */
1618 { yyerror("Invalid argument"); }
1619 #line 1620 "uparse.c" /* yacc.c:1646 */
1620 break;
1621
1622 case 50:
1623 #line 120 "uparse.y" /* yacc.c:1646 */
1624 { yyerror("Argument required"); }
1625 #line 1626 "uparse.c" /* yacc.c:1646 */
1626 break;
1627
1628 case 51:
1629 #line 121 "uparse.y" /* yacc.c:1646 */
1630 { cd_regex((yyvsp[-1].strval), 1); amfree((yyvsp[-1].strval)); }
1631 #line 1632 "uparse.c" /* yacc.c:1646 */
1632 break;
1633
1634 case 52:
1635 #line 122 "uparse.y" /* yacc.c:1646 */
1636 { yyerror("Invalid argument"); amfree((yyvsp[-1].strval)); }
1637 #line 1638 "uparse.c" /* yacc.c:1646 */
1638 break;
1639
1640 case 53:
1641 #line 123 "uparse.y" /* yacc.c:1646 */
1642 { yyerror("Argument required"); }
1643 #line 1644 "uparse.c" /* yacc.c:1646 */
1644 break;
1645
1646 case 54:
1647 #line 124 "uparse.y" /* yacc.c:1646 */
1648 { set_mode(SAMBA_SMBCLIENT); }
1649 #line 1650 "uparse.c" /* yacc.c:1646 */
1650 break;
1651
1652 case 55:
1653 #line 125 "uparse.y" /* yacc.c:1646 */
1654 { set_mode(SAMBA_TAR); }
1655 #line 1656 "uparse.c" /* yacc.c:1646 */
1656 break;
1657
1658 case 56:
1659 #line 126 "uparse.y" /* yacc.c:1646 */
1660 { yyerror("Invalid argument"); }
1661 #line 1662 "uparse.c" /* yacc.c:1646 */
1662 break;
1663
1664 case 57:
1665 #line 127 "uparse.y" /* yacc.c:1646 */
1666 { yyerror("Invalid argument"); }
1667 #line 1668 "uparse.c" /* yacc.c:1646 */
1668 break;
1669
1670 case 58:
1671 #line 128 "uparse.y" /* yacc.c:1646 */
1672 { yyerror("Invalid argument"); }
1673 #line 1674 "uparse.c" /* yacc.c:1646 */
1674 break;
1675
1676 case 59:
1677 #line 129 "uparse.y" /* yacc.c:1646 */
1678 { yyerror("Argument required"); }
1679 #line 1680 "uparse.c" /* yacc.c:1646 */
1680 break;
1681
1682 case 60:
1683 #line 133 "uparse.y" /* yacc.c:1646 */
1684 {
1685 time_t now;
1686 struct tm *t;
1687 int y=2000, m=0, d=1, h=0, mi=0, s=0;
1688 char *mydate = (yyvsp[-1].strval);
1689
1690 now = time((time_t *)NULL);
1691 t = localtime(&now);
1692 if (t) {
1693 y = 1900+t->tm_year;
1694 m = t->tm_mon+1;
1695 d = t->tm_mday;
1696 }
1697 if (sscanf(mydate, "---%d", &d) == 1 ||
1698 sscanf(mydate, "--%d-%d", &m, &d) == 2 ||
1699 sscanf(mydate, "%d-%d-%d-%d-%d-%d", &y, &m, &d, &h, &mi, &s) >= 3) {
1700 if (y < 70) {
1701 y += 2000;
1702 } else if (y < 100) {
1703 y += 1900;
1704 }
1705 if(y < 1000 || y > 9999) {
1706 printf("invalid year");
1707 } else if(m < 1 || m > 12) {
1708 printf("invalid month");
1709 } else if(d < 1 || d > 31) {
1710 printf("invalid day");
1711 } else if(h < 0 || h > 24) {
1712 printf("invalid hour");
1713 } else if(mi < 0 || mi > 59) {
1714 printf("invalid minute");
1715 } else if(s < 0 || s > 59) {
1716 printf("invalid second");
1717 } else {
1718 char result[DATE_ALLOC_SIZE];
1719 if (h == 0 && mi == 0 && s == 0)
1720 g_snprintf(result, DATE_ALLOC_SIZE, "%04d-%02d-%02d", y, m, d);
1721 else
1722 g_snprintf(result, DATE_ALLOC_SIZE, "%04d-%02d-%02d-%02d-%02d-%02d", y, m, d, h, mi, s);
1723 set_date(result);
1724 }
1725 } else {
1726 printf("Invalid date: %s\n", mydate);
1727 }
1728 }
1729 #line 1730 "uparse.c" /* yacc.c:1646 */
1730 break;
1731
1732 case 61:
1733 #line 178 "uparse.y" /* yacc.c:1646 */
1734 { yyerror("Argument required"); }
1735 #line 1736 "uparse.c" /* yacc.c:1646 */
1736 break;
1737
1738 case 62:
1739 #line 179 "uparse.y" /* yacc.c:1646 */
1740 { yyerror("Invalid argument"); }
1741 #line 1742 "uparse.c" /* yacc.c:1646 */
1742 break;
1743
1744 case 63:
1745 #line 183 "uparse.y" /* yacc.c:1646 */
1746 { list_disk_history(); }
1747 #line 1748 "uparse.c" /* yacc.c:1646 */
1748 break;
1749
1750 case 64:
1751 #line 184 "uparse.y" /* yacc.c:1646 */
1752 { yyerror("Invalid argument"); }
1753 #line 1754 "uparse.c" /* yacc.c:1646 */
1754 break;
1755
1756 case 65:
1757 #line 185 "uparse.y" /* yacc.c:1646 */
1758 { list_directory(); }
1759 #line 1760 "uparse.c" /* yacc.c:1646 */
1760 break;
1761
1762 case 66:
1763 #line 186 "uparse.y" /* yacc.c:1646 */
1764 { yyerror("Invalid argument"); }
1765 #line 1766 "uparse.c" /* yacc.c:1646 */
1766 break;
1767
1768 case 67:
1769 #line 187 "uparse.y" /* yacc.c:1646 */
1770 { display_extract_list((yyvsp[-1].strval)); amfree((yyvsp[-1].strval)); }
1771 #line 1772 "uparse.c" /* yacc.c:1646 */
1772 break;
1773
1774 case 68:
1775 #line 188 "uparse.y" /* yacc.c:1646 */
1776 { display_extract_list(NULL); }
1777 #line 1778 "uparse.c" /* yacc.c:1646 */
1778 break;
1779
1780 case 69:
1781 #line 189 "uparse.y" /* yacc.c:1646 */
1782 { yyerror("Invalid argument"); }
1783 #line 1784 "uparse.c" /* yacc.c:1646 */
1784 break;
1785
1786 case 70:
1787 #line 190 "uparse.y" /* yacc.c:1646 */
1788 { show_directory(); }
1789 #line 1790 "uparse.c" /* yacc.c:1646 */
1790 break;
1791
1792 case 71:
1793 #line 191 "uparse.y" /* yacc.c:1646 */
1794 { yyerror("Invalid argument"); }
1795 #line 1796 "uparse.c" /* yacc.c:1646 */
1796 break;
1797
1798 case 72:
1799 #line 192 "uparse.y" /* yacc.c:1646 */
1800 { clear_extract_list(); }
1801 #line 1802 "uparse.c" /* yacc.c:1646 */
1802 break;
1803
1804 case 73:
1805 #line 193 "uparse.y" /* yacc.c:1646 */
1806 { yyerror("Invalid argument"); }
1807 #line 1808 "uparse.c" /* yacc.c:1646 */
1808 break;
1809
1810 case 74:
1811 #line 194 "uparse.y" /* yacc.c:1646 */
1812 { show_mode (); }
1813 #line 1814 "uparse.c" /* yacc.c:1646 */
1814 break;
1815
1816 case 75:
1817 #line 195 "uparse.y" /* yacc.c:1646 */
1818 { yyerror("Invalid argument"); }
1819 #line 1820 "uparse.c" /* yacc.c:1646 */
1820 break;
1821
1822 case 76:
1823 #line 199 "uparse.y" /* yacc.c:1646 */
1824 { quit(); }
1825 #line 1826 "uparse.c" /* yacc.c:1646 */
1826 break;
1827
1828 case 77:
1829 #line 200 "uparse.y" /* yacc.c:1646 */
1830 { yyerror("Invalid argument"); }
1831 #line 1832 "uparse.c" /* yacc.c:1646 */
1832 break;
1833
1834 case 79:
1835 #line 208 "uparse.y" /* yacc.c:1646 */
1836 { add_glob((yyvsp[0].strval)); amfree((yyvsp[0].strval)); }
1837 #line 1838 "uparse.c" /* yacc.c:1646 */
1838 break;
1839
1840 case 80:
1841 #line 209 "uparse.y" /* yacc.c:1646 */
1842 { add_glob((yyvsp[0].strval)); amfree((yyvsp[0].strval)); }
1843 #line 1844 "uparse.c" /* yacc.c:1646 */
1844 break;
1845
1846 case 82:
1847 #line 217 "uparse.y" /* yacc.c:1646 */
1848 { add_regex((yyvsp[0].strval)); amfree((yyvsp[0].strval)); }
1849 #line 1850 "uparse.c" /* yacc.c:1646 */
1850 break;
1851
1852 case 83:
1853 #line 218 "uparse.y" /* yacc.c:1646 */
1854 { add_regex((yyvsp[0].strval)); amfree((yyvsp[0].strval)); }
1855 #line 1856 "uparse.c" /* yacc.c:1646 */
1856 break;
1857
1858 case 85:
1859 #line 226 "uparse.y" /* yacc.c:1646 */
1860 { delete_glob((yyvsp[0].strval)); amfree((yyvsp[0].strval)); }
1861 #line 1862 "uparse.c" /* yacc.c:1646 */
1862 break;
1863
1864 case 86:
1865 #line 227 "uparse.y" /* yacc.c:1646 */
1866 { delete_glob((yyvsp[0].strval)); amfree((yyvsp[0].strval)); }
1867 #line 1868 "uparse.c" /* yacc.c:1646 */
1868 break;
1869
1870 case 88:
1871 #line 235 "uparse.y" /* yacc.c:1646 */
1872 { delete_regex((yyvsp[0].strval)); amfree((yyvsp[0].strval)); }
1873 #line 1874 "uparse.c" /* yacc.c:1646 */
1874 break;
1875
1876 case 89:
1877 #line 236 "uparse.y" /* yacc.c:1646 */
1878 { delete_regex((yyvsp[0].strval)); amfree((yyvsp[0].strval)); }
1879 #line 1880 "uparse.c" /* yacc.c:1646 */
1880 break;
1881
1882 case 90:
1883 #line 240 "uparse.y" /* yacc.c:1646 */
1884 { char * buf= g_get_current_dir(); puts(buf); free(buf); }
1885 #line 1886 "uparse.c" /* yacc.c:1646 */
1886 break;
1887
1888 case 91:
1889 #line 241 "uparse.y" /* yacc.c:1646 */
1890 { yyerror("Invalid argument"); }
1891 #line 1892 "uparse.c" /* yacc.c:1646 */
1892 break;
1893
1894 case 92:
1895 #line 242 "uparse.y" /* yacc.c:1646 */
1896 {
1897 local_cd((yyvsp[-1].strval));
1898 amfree((yyvsp[-1].strval));
1899 }
1900 #line 1901 "uparse.c" /* yacc.c:1646 */
1901 break;
1902
1903 case 93:
1904 #line 246 "uparse.y" /* yacc.c:1646 */
1905 { yyerror("Invalid argument"); }
1906 #line 1907 "uparse.c" /* yacc.c:1646 */
1907 break;
1908
1909 case 94:
1910 #line 247 "uparse.y" /* yacc.c:1646 */
1911 { yyerror("Argument required"); }
1912 #line 1913 "uparse.c" /* yacc.c:1646 */
1913 break;
1914
1915 case 95:
1916 #line 251 "uparse.y" /* yacc.c:1646 */
1917 { help_list(); }
1918 #line 1919 "uparse.c" /* yacc.c:1646 */
1919 break;
1920
1921 case 96:
1922 #line 252 "uparse.y" /* yacc.c:1646 */
1923 { yyerror("Invalid argument"); }
1924 #line 1925 "uparse.c" /* yacc.c:1646 */
1925 break;
1926
1927 case 97:
1928 #line 256 "uparse.y" /* yacc.c:1646 */
1929 { extract_files(); }
1930 #line 1931 "uparse.c" /* yacc.c:1646 */
1931 break;
1932
1933 case 98:
1934 #line 257 "uparse.y" /* yacc.c:1646 */
1935 { yyerror("Invalid argument"); }
1936 #line 1937 "uparse.c" /* yacc.c:1646 */
1937 break;
1938
1939 case 99:
1940 #line 261 "uparse.y" /* yacc.c:1646 */
1941 {
1942 char * errstr = vstralloc("Invalid command: ", (yyvsp[-1].strval), NULL);
1943 yyerror(errstr);
1944 amfree(errstr);
1945 YYERROR;
1946 }
1947 #line 1948 "uparse.c" /* yacc.c:1646 */
1948 break;
1949
1950 case 100:
1951 #line 270 "uparse.y" /* yacc.c:1646 */
1952 { add_property_value((yyvsp[-1].strval)); amfree( (yyvsp[-1].strval)); }
1953 #line 1954 "uparse.c" /* yacc.c:1646 */
1954 break;
1955
1956 case 101:
1957 #line 271 "uparse.y" /* yacc.c:1646 */
1958 { ; }
1959 #line 1960 "uparse.c" /* yacc.c:1646 */
1960 break;
1961
1962 case 102:
1963 #line 275 "uparse.y" /* yacc.c:1646 */
1964 { amfree((yyvsp[-1].strval)); }
1965 #line 1966 "uparse.c" /* yacc.c:1646 */
1966 break;
1967
1968 case 103:
1969 #line 279 "uparse.y" /* yacc.c:1646 */
1970 { amfree((yyvsp[-1].strval)); }
1971 #line 1972 "uparse.c" /* yacc.c:1646 */
1972 break;
1973
1974 case 104:
1975 #line 280 "uparse.y" /* yacc.c:1646 */
1976 { ; }
1977 #line 1978 "uparse.c" /* yacc.c:1646 */
1978 break;
1979
1980
1981 #line 1982 "uparse.c" /* yacc.c:1646 */
1982 default: break;
1983 }
1984 /* User semantic actions sometimes alter yychar, and that requires
1985 that yytoken be updated with the new translation. We take the
1986 approach of translating immediately before every use of yytoken.
1987 One alternative is translating here after every semantic action,
1988 but that translation would be missed if the semantic action invokes
1989 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1990 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1991 incorrect destructor might then be invoked immediately. In the
1992 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1993 to an incorrect destructor call or verbose syntax error message
1994 before the lookahead is translated. */
1995 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1996
1997 YYPOPSTACK (yylen);
1998 yylen = 0;
1999 YY_STACK_PRINT (yyss, yyssp);
2000
2001 *++yyvsp = yyval;
2002
2003 /* Now 'shift' the result of the reduction. Determine what state
2004 that goes to, based on the state we popped back to and the rule
2005 number reduced by. */
2006
2007 yyn = yyr1[yyn];
2008
2009 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2010 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2011 yystate = yytable[yystate];
2012 else
2013 yystate = yydefgoto[yyn - YYNTOKENS];
2014
2015 goto yynewstate;
2016
2017
2018 /*--------------------------------------.
2019 | yyerrlab -- here on detecting error. |
2020 `--------------------------------------*/
2021 yyerrlab:
2022 /* Make sure we have latest lookahead translation. See comments at
2023 user semantic actions for why this is necessary. */
2024 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2025
2026 /* If not already recovering from an error, report this error. */
2027 if (!yyerrstatus)
2028 {
2029 ++yynerrs;
2030 #if ! YYERROR_VERBOSE
2031 yyerror (YY_("syntax error"));
2032 #else
2033 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2034 yyssp, yytoken)
2035 {
2036 char const *yymsgp = YY_("syntax error");
2037 int yysyntax_error_status;
2038 yysyntax_error_status = YYSYNTAX_ERROR;
2039 if (yysyntax_error_status == 0)
2040 yymsgp = yymsg;
2041 else if (yysyntax_error_status == 1)
2042 {
2043 if (yymsg != yymsgbuf)
2044 YYSTACK_FREE (yymsg);
2045 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2046 if (!yymsg)
2047 {
2048 yymsg = yymsgbuf;
2049 yymsg_alloc = sizeof yymsgbuf;
2050 yysyntax_error_status = 2;
2051 }
2052 else
2053 {
2054 yysyntax_error_status = YYSYNTAX_ERROR;
2055 yymsgp = yymsg;
2056 }
2057 }
2058 yyerror (yymsgp);
2059 if (yysyntax_error_status == 2)
2060 goto yyexhaustedlab;
2061 }
2062 # undef YYSYNTAX_ERROR
2063 #endif
2064 }
2065
2066
2067
2068 if (yyerrstatus == 3)
2069 {
2070 /* If just tried and failed to reuse lookahead token after an
2071 error, discard it. */
2072
2073 if (yychar <= YYEOF)
2074 {
2075 /* Return failure if at end of input. */
2076 if (yychar == YYEOF)
2077 YYABORT;
2078 }
2079 else
2080 {
2081 yydestruct ("Error: discarding",
2082 yytoken, &yylval);
2083 yychar = YYEMPTY;
2084 }
2085 }
2086
2087 /* Else will try to reuse lookahead token after shifting the error
2088 token. */
2089 goto yyerrlab1;
2090
2091
2092 /*---------------------------------------------------.
2093 | yyerrorlab -- error raised explicitly by YYERROR. |
2094 `---------------------------------------------------*/
2095 yyerrorlab:
2096
2097 /* Pacify compilers like GCC when the user code never invokes
2098 YYERROR and the label yyerrorlab therefore never appears in user
2099 code. */
2100 if (/*CONSTCOND*/ 0)
2101 goto yyerrorlab;
2102
2103 /* Do not reclaim the symbols of the rule whose action triggered
2104 this YYERROR. */
2105 YYPOPSTACK (yylen);
2106 yylen = 0;
2107 YY_STACK_PRINT (yyss, yyssp);
2108 yystate = *yyssp;
2109 goto yyerrlab1;
2110
2111
2112 /*-------------------------------------------------------------.
2113 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2114 `-------------------------------------------------------------*/
2115 yyerrlab1:
2116 yyerrstatus = 3; /* Each real token shifted decrements this. */
2117
2118 for (;;)
2119 {
2120 yyn = yypact[yystate];
2121 if (!yypact_value_is_default (yyn))
2122 {
2123 yyn += YYTERROR;
2124 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2125 {
2126 yyn = yytable[yyn];
2127 if (0 < yyn)
2128 break;
2129 }
2130 }
2131
2132 /* Pop the current state because it cannot handle the error token. */
2133 if (yyssp == yyss)
2134 YYABORT;
2135
2136
2137 yydestruct ("Error: popping",
2138 yystos[yystate], yyvsp);
2139 YYPOPSTACK (1);
2140 yystate = *yyssp;
2141 YY_STACK_PRINT (yyss, yyssp);
2142 }
2143
2144 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2145 *++yyvsp = yylval;
2146 YY_IGNORE_MAYBE_UNINITIALIZED_END
2147
2148
2149 /* Shift the error token. */
2150 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2151
2152 yystate = yyn;
2153 goto yynewstate;
2154
2155
2156 /*-------------------------------------.
2157 | yyacceptlab -- YYACCEPT comes here. |
2158 `-------------------------------------*/
2159 yyacceptlab:
2160 yyresult = 0;
2161 goto yyreturn;
2162
2163 /*-----------------------------------.
2164 | yyabortlab -- YYABORT comes here. |
2165 `-----------------------------------*/
2166 yyabortlab:
2167 yyresult = 1;
2168 goto yyreturn;
2169
2170 #if !defined yyoverflow || YYERROR_VERBOSE
2171 /*-------------------------------------------------.
2172 | yyexhaustedlab -- memory exhaustion comes here. |
2173 `-------------------------------------------------*/
2174 yyexhaustedlab:
2175 yyerror (YY_("memory exhausted"));
2176 yyresult = 2;
2177 /* Fall through. */
2178 #endif
2179
2180 yyreturn:
2181 if (yychar != YYEMPTY)
2182 {
2183 /* Make sure we have latest lookahead translation. See comments at
2184 user semantic actions for why this is necessary. */
2185 yytoken = YYTRANSLATE (yychar);
2186 yydestruct ("Cleanup: discarding lookahead",
2187 yytoken, &yylval);
2188 }
2189 /* Do not reclaim the symbols of the rule whose action triggered
2190 this YYABORT or YYACCEPT. */
2191 YYPOPSTACK (yylen);
2192 YY_STACK_PRINT (yyss, yyssp);
2193 while (yyssp != yyss)
2194 {
2195 yydestruct ("Cleanup: popping",
2196 yystos[*yyssp], yyvsp);
2197 YYPOPSTACK (1);
2198 }
2199 #ifndef yyoverflow
2200 if (yyss != yyssa)
2201 YYSTACK_FREE (yyss);
2202 #endif
2203 #if YYERROR_VERBOSE
2204 if (yymsg != yymsgbuf)
2205 YYSTACK_FREE (yymsg);
2206 #endif
2207 return yyresult;
2208 }
2209 #line 283 "uparse.y" /* yacc.c:1906 */
2210
2211
2212 void
yyerror(char * s)2213 yyerror(
2214 char * s)
2215 {
2216 g_printf("%s\n", s);
2217 }
2218