Line data Source code
1 : /* A Bison parser, made by GNU Bison 3.0.4. */
2 :
3 : /* Bison implementation for Yacc-like parsers in C
4 :
5 : Copyright (C) 1984, 1989-1990, 2000-2015 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.4"
48 :
49 : /* Skeleton name. */
50 : #define YYSKELETON_NAME "yacc.c"
51 :
52 : /* Pure parsers. */
53 : #define YYPURE 1
54 :
55 : /* Push parsers. */
56 : #define YYPUSH 0
57 :
58 : /* Pull parsers. */
59 : #define YYPULL 1
60 :
61 :
62 :
63 :
64 : /* Copy the first part of user declarations. */
65 : #line 1 "source3/modules/getdate.y" /* yacc.c:339 */
66 :
67 : /* Parse a string into an internal time stamp.
68 : Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
69 :
70 : This program is free software; you can redistribute it and/or modify
71 : it under the terms of the GNU General Public License as published by
72 : the Free Software Foundation; either version 2, or (at your option)
73 : any later version.
74 :
75 : This program is distributed in the hope that it will be useful,
76 : but WITHOUT ANY WARRANTY; without even the implied warranty of
77 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
78 : GNU General Public License for more details.
79 :
80 : You should have received a copy of the GNU General Public License
81 : along with this program; if not, see <http://www.gnu.org/licenses/>. */
82 :
83 : /* Originally written by Steven M. Bellovin <smb@research.att.com> while
84 : at the University of North Carolina at Chapel Hill. Later tweaked by
85 : a couple of people on Usenet. Completely overhauled by Rich $alz
86 : <rsalz@bbn.com> and Jim Berets <jberets@bbn.com> in August, 1990.
87 :
88 : Modified by Paul Eggert <eggert@twinsun.com> in August 1999 to do
89 : the right thing about local DST. Unlike previous versions, this
90 : version is reentrant. */
91 :
92 : #ifdef HAVE_CONFIG_H
93 : # include <config.h>
94 : # ifdef HAVE_ALLOCA_H
95 : # include <alloca.h>
96 : # endif
97 : #endif
98 :
99 : /* Since the code of getdate.y is not included in the Emacs executable
100 : itself, there is no need to #define static in this file. Even if
101 : the code were included in the Emacs executable, it probably
102 : wouldn't do any harm to #undef it here; this will only cause
103 : problems if we try to write to a static variable, which I don't
104 : think this code needs to do. */
105 : #ifdef emacs
106 : # undef static
107 : #endif
108 :
109 : #include <ctype.h>
110 : #include <string.h>
111 :
112 : #ifdef HAVE_STDLIB_H
113 : # include <stdlib.h> /* for `free'; used by Bison 1.27 */
114 : #endif
115 :
116 : #if STDC_HEADERS || (! defined isascii && ! HAVE_ISASCII)
117 : # define IN_CTYPE_DOMAIN(c) 1
118 : #else
119 : # define IN_CTYPE_DOMAIN(c) isascii (c)
120 : #endif
121 :
122 : #define ISSPACE(c) (IN_CTYPE_DOMAIN (c) && isspace (c))
123 : #define ISALPHA(c) (IN_CTYPE_DOMAIN (c) && isalpha (c))
124 : #define ISLOWER(c) (IN_CTYPE_DOMAIN (c) && islower (c))
125 : #define ISDIGIT_LOCALE(c) (IN_CTYPE_DOMAIN (c) && isdigit (c))
126 :
127 : /* ISDIGIT differs from ISDIGIT_LOCALE, as follows:
128 : - Its arg may be any int or unsigned int; it need not be an unsigned char.
129 : - It's guaranteed to evaluate its argument exactly once.
130 : - It's typically faster.
131 : POSIX says that only '0' through '9' are digits. Prefer ISDIGIT to
132 : ISDIGIT_LOCALE unless it's important to use the locale's definition
133 : of `digit' even when the host does not conform to POSIX. */
134 : #define ISDIGIT(c) ((unsigned) (c) - '0' <= 9)
135 :
136 : #if STDC_HEADERS || HAVE_STRING_H
137 : # include <string.h>
138 : #endif
139 :
140 : #ifndef HAVE___ATTRIBUTE__
141 : # define __attribute__(x)
142 : #endif
143 :
144 : #ifndef ATTRIBUTE_UNUSED
145 : # define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
146 : #endif
147 :
148 : #define EPOCH_YEAR 1970
149 : #define TM_YEAR_BASE 1900
150 :
151 : #define HOUR(x) ((x) * 60)
152 :
153 : /* An integer value, and the number of digits in its textual
154 : representation. */
155 : typedef struct
156 : {
157 : int value;
158 : int digits;
159 : } textint;
160 :
161 : /* An entry in the lexical lookup table. */
162 : typedef struct
163 : {
164 : char const *name;
165 : int type;
166 : int value;
167 : } table;
168 :
169 : /* Meridian: am, pm, or 24-hour style. */
170 : enum { MERam, MERpm, MER24 };
171 :
172 : /* Information passed to and from the parser. */
173 : struct parser_control
174 : {
175 : /* The input string remaining to be parsed. */
176 : const char *input;
177 :
178 : /* N, if this is the Nth Tuesday. */
179 : int day_ordinal;
180 :
181 : /* Day of week; Sunday is 0. */
182 : int day_number;
183 :
184 : /* tm_isdst flag for the local zone. */
185 : int local_isdst;
186 :
187 : /* Time zone, in minutes east of UTC. */
188 : int time_zone;
189 :
190 : /* Style used for time. */
191 : int meridian;
192 :
193 : /* Gregorian year, month, day, hour, minutes, and seconds. */
194 : textint year;
195 : int month;
196 : int day;
197 : int hour;
198 : int minutes;
199 : int seconds;
200 :
201 : /* Relative year, month, day, hour, minutes, and seconds. */
202 : int rel_year;
203 : int rel_month;
204 : int rel_day;
205 : int rel_hour;
206 : int rel_minutes;
207 : int rel_seconds;
208 :
209 : /* Counts of nonterminals of various flavors parsed so far. */
210 : int dates_seen;
211 : int days_seen;
212 : int local_zones_seen;
213 : int rels_seen;
214 : int times_seen;
215 : int zones_seen;
216 :
217 : /* Table of local time zone abbrevations, terminated by a null entry. */
218 : table local_time_zone_table[3];
219 : };
220 :
221 :
222 : #line 223 "source3/modules/getdate.c" /* yacc.c:339 */
223 :
224 : # ifndef YY_NULLPTR
225 : # if defined __cplusplus && 201103L <= __cplusplus
226 : # define YY_NULLPTR nullptr
227 : # else
228 : # define YY_NULLPTR 0
229 : # endif
230 : # endif
231 :
232 : /* Enabling verbose error messages. */
233 : #ifdef YYERROR_VERBOSE
234 : # undef YYERROR_VERBOSE
235 : # define YYERROR_VERBOSE 1
236 : #else
237 : # define YYERROR_VERBOSE 0
238 : #endif
239 :
240 :
241 : /* Debug traces. */
242 : #ifndef YYDEBUG
243 : # define YYDEBUG 0
244 : #endif
245 : #if YYDEBUG
246 : extern int yydebug;
247 : #endif
248 :
249 : /* Token type. */
250 : #ifndef YYTOKENTYPE
251 : # define YYTOKENTYPE
252 : enum yytokentype
253 : {
254 : tAGO = 258,
255 : tDST = 259,
256 : tDAY = 260,
257 : tDAY_UNIT = 261,
258 : tDAYZONE = 262,
259 : tHOUR_UNIT = 263,
260 : tLOCAL_ZONE = 264,
261 : tMERIDIAN = 265,
262 : tMINUTE_UNIT = 266,
263 : tMONTH = 267,
264 : tMONTH_UNIT = 268,
265 : tSEC_UNIT = 269,
266 : tYEAR_UNIT = 270,
267 : tZONE = 271,
268 : tSNUMBER = 272,
269 : tUNUMBER = 273
270 : };
271 : #endif
272 :
273 : /* Value type. */
274 : #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
275 :
276 : union YYSTYPE
277 : {
278 : #line 168 "source3/modules/getdate.y" /* yacc.c:355 */
279 :
280 : int intval;
281 : textint textintval;
282 :
283 : #line 284 "source3/modules/getdate.c" /* yacc.c:355 */
284 : };
285 :
286 : typedef union YYSTYPE YYSTYPE;
287 : # define YYSTYPE_IS_TRIVIAL 1
288 : # define YYSTYPE_IS_DECLARED 1
289 : #endif
290 :
291 :
292 :
293 : int yyparse (struct parser_control *pc);
294 :
295 :
296 :
297 : /* Copy the second part of user declarations. */
298 : #line 173 "source3/modules/getdate.y" /* yacc.c:358 */
299 :
300 :
301 : static int yyerror(struct parser_control *, const char *);
302 : static int yylex(YYSTYPE *, struct parser_control *);
303 :
304 :
305 : #line 306 "source3/modules/getdate.c" /* yacc.c:358 */
306 :
307 : #ifdef short
308 : # undef short
309 : #endif
310 :
311 : #ifdef YYTYPE_UINT8
312 : typedef YYTYPE_UINT8 yytype_uint8;
313 : #else
314 : typedef unsigned char yytype_uint8;
315 : #endif
316 :
317 : #ifdef YYTYPE_INT8
318 : typedef YYTYPE_INT8 yytype_int8;
319 : #else
320 : typedef signed char yytype_int8;
321 : #endif
322 :
323 : #ifdef YYTYPE_UINT16
324 : typedef YYTYPE_UINT16 yytype_uint16;
325 : #else
326 : typedef unsigned short int yytype_uint16;
327 : #endif
328 :
329 : #ifdef YYTYPE_INT16
330 : typedef YYTYPE_INT16 yytype_int16;
331 : #else
332 : typedef short int yytype_int16;
333 : #endif
334 :
335 : #ifndef YYSIZE_T
336 : # ifdef __SIZE_TYPE__
337 : # define YYSIZE_T __SIZE_TYPE__
338 : # elif defined size_t
339 : # define YYSIZE_T size_t
340 : # elif ! defined YYSIZE_T
341 : # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
342 : # define YYSIZE_T size_t
343 : # else
344 : # define YYSIZE_T unsigned int
345 : # endif
346 : #endif
347 :
348 : #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
349 :
350 : #ifndef YY_
351 : # if defined YYENABLE_NLS && YYENABLE_NLS
352 : # if ENABLE_NLS
353 : # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
354 : # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
355 : # endif
356 : # endif
357 : # ifndef YY_
358 : # define YY_(Msgid) Msgid
359 : # endif
360 : #endif
361 :
362 : #ifndef YY_ATTRIBUTE
363 : # if (defined __GNUC__ \
364 : && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
365 : || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
366 : # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
367 : # else
368 : # define YY_ATTRIBUTE(Spec) /* empty */
369 : # endif
370 : #endif
371 :
372 : #ifndef YY_ATTRIBUTE_PURE
373 : # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
374 : #endif
375 :
376 : #ifndef YY_ATTRIBUTE_UNUSED
377 : # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
378 : #endif
379 :
380 : #if !defined _Noreturn \
381 : && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
382 : # if defined _MSC_VER && 1200 <= _MSC_VER
383 : # define _Noreturn __declspec (noreturn)
384 : # else
385 : # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
386 : # endif
387 : #endif
388 :
389 : /* Suppress unused-variable warnings by "using" E. */
390 : #if ! defined lint || defined __GNUC__
391 : # define YYUSE(E) ((void) (E))
392 : #else
393 : # define YYUSE(E) /* empty */
394 : #endif
395 :
396 : #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
397 : /* Suppress an incorrect diagnostic about yylval being uninitialized. */
398 : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
399 : _Pragma ("GCC diagnostic push") \
400 : _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
401 : _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
402 : # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
403 : _Pragma ("GCC diagnostic pop")
404 : #else
405 : # define YY_INITIAL_VALUE(Value) Value
406 : #endif
407 : #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
408 : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
409 : # define YY_IGNORE_MAYBE_UNINITIALIZED_END
410 : #endif
411 : #ifndef YY_INITIAL_VALUE
412 : # define YY_INITIAL_VALUE(Value) /* Nothing. */
413 : #endif
414 :
415 :
416 : #if ! defined yyoverflow || YYERROR_VERBOSE
417 :
418 : /* The parser invokes alloca or malloc; define the necessary symbols. */
419 :
420 : # ifdef YYSTACK_USE_ALLOCA
421 : # if YYSTACK_USE_ALLOCA
422 : # ifdef __GNUC__
423 : # define YYSTACK_ALLOC __builtin_alloca
424 : # elif defined __BUILTIN_VA_ARG_INCR
425 : # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
426 : # elif defined _AIX
427 : # define YYSTACK_ALLOC __alloca
428 : # elif defined _MSC_VER
429 : # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
430 : # define alloca _alloca
431 : # else
432 : # define YYSTACK_ALLOC alloca
433 : # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
434 : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
435 : /* Use EXIT_SUCCESS as a witness for stdlib.h. */
436 : # ifndef EXIT_SUCCESS
437 : # define EXIT_SUCCESS 0
438 : # endif
439 : # endif
440 : # endif
441 : # endif
442 : # endif
443 :
444 : # ifdef YYSTACK_ALLOC
445 : /* Pacify GCC's 'empty if-body' warning. */
446 : # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
447 : # ifndef YYSTACK_ALLOC_MAXIMUM
448 : /* The OS might guarantee only one guard page at the bottom of the stack,
449 : and a page size can be as small as 4096 bytes. So we cannot safely
450 : invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
451 : to allow for a few compiler-allocated temporary stack slots. */
452 : # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
453 : # endif
454 : # else
455 : # define YYSTACK_ALLOC YYMALLOC
456 : # define YYSTACK_FREE YYFREE
457 : # ifndef YYSTACK_ALLOC_MAXIMUM
458 : # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
459 : # endif
460 : # if (defined __cplusplus && ! defined EXIT_SUCCESS \
461 : && ! ((defined YYMALLOC || defined malloc) \
462 : && (defined YYFREE || defined free)))
463 : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
464 : # ifndef EXIT_SUCCESS
465 : # define EXIT_SUCCESS 0
466 : # endif
467 : # endif
468 : # ifndef YYMALLOC
469 : # define YYMALLOC malloc
470 : # if ! defined malloc && ! defined EXIT_SUCCESS
471 : void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
472 : # endif
473 : # endif
474 : # ifndef YYFREE
475 : # define YYFREE free
476 : # if ! defined free && ! defined EXIT_SUCCESS
477 : void free (void *); /* INFRINGES ON USER NAME SPACE */
478 : # endif
479 : # endif
480 : # endif
481 : #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
482 :
483 :
484 : #if (! defined yyoverflow \
485 : && (! defined __cplusplus \
486 : || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
487 :
488 : /* A type that is properly aligned for any stack member. */
489 : union yyalloc
490 : {
491 : yytype_int16 yyss_alloc;
492 : YYSTYPE yyvs_alloc;
493 : };
494 :
495 : /* The size of the maximum gap between one aligned stack and the next. */
496 : # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
497 :
498 : /* The size of an array large to enough to hold all stacks, each with
499 : N elements. */
500 : # define YYSTACK_BYTES(N) \
501 : ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
502 : + YYSTACK_GAP_MAXIMUM)
503 :
504 : # define YYCOPY_NEEDED 1
505 :
506 : /* Relocate STACK from its old location to the new one. The
507 : local variables YYSIZE and YYSTACKSIZE give the old and new number of
508 : elements in the stack, and YYPTR gives the new location of the
509 : stack. Advance YYPTR to a properly aligned location for the next
510 : stack. */
511 : # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
512 : do \
513 : { \
514 : YYSIZE_T yynewbytes; \
515 : YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
516 : Stack = &yyptr->Stack_alloc; \
517 : yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
518 : yyptr += yynewbytes / sizeof (*yyptr); \
519 : } \
520 : while (0)
521 :
522 : #endif
523 :
524 : #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
525 : /* Copy COUNT objects from SRC to DST. The source and destination do
526 : not overlap. */
527 : # ifndef YYCOPY
528 : # if defined __GNUC__ && 1 < __GNUC__
529 : # define YYCOPY(Dst, Src, Count) \
530 : __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
531 : # else
532 : # define YYCOPY(Dst, Src, Count) \
533 : do \
534 : { \
535 : YYSIZE_T yyi; \
536 : for (yyi = 0; yyi < (Count); yyi++) \
537 : (Dst)[yyi] = (Src)[yyi]; \
538 : } \
539 : while (0)
540 : # endif
541 : # endif
542 : #endif /* !YYCOPY_NEEDED */
543 :
544 : /* YYFINAL -- State number of the termination state. */
545 : #define YYFINAL 2
546 : /* YYLAST -- Last index in YYTABLE. */
547 : #define YYLAST 52
548 :
549 : /* YYNTOKENS -- Number of terminals. */
550 : #define YYNTOKENS 22
551 : /* YYNNTS -- Number of nonterminals. */
552 : #define YYNNTS 12
553 : /* YYNRULES -- Number of rules. */
554 : #define YYNRULES 54
555 : /* YYNSTATES -- Number of states. */
556 : #define YYNSTATES 64
557 :
558 : /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
559 : by yylex, with out-of-bounds checking. */
560 : #define YYUNDEFTOK 2
561 : #define YYMAXUTOK 273
562 :
563 : #define YYTRANSLATE(YYX) \
564 : ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
565 :
566 : /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
567 : as returned by yylex, without out-of-bounds checking. */
568 : static const yytype_uint8 yytranslate[] =
569 : {
570 : 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
571 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
572 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
573 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
574 : 2, 2, 2, 2, 20, 2, 2, 21, 2, 2,
575 : 2, 2, 2, 2, 2, 2, 2, 2, 19, 2,
576 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
577 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
578 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
579 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
580 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
581 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
582 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
583 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
584 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
585 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
586 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
587 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
588 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
589 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
590 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
591 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
592 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
593 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
594 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
595 : 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
596 : 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
597 : 15, 16, 17, 18
598 : };
599 :
600 : #if YYDEBUG
601 : /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
602 : static const yytype_uint16 yyrline[] =
603 : {
604 : 0, 191, 191, 193, 197, 199, 201, 203, 205, 207,
605 : 209, 213, 220, 227, 235, 242, 254, 256, 261, 263,
606 : 265, 270, 275, 280, 288, 293, 313, 320, 328, 333,
607 : 339, 344, 353, 362, 366, 368, 370, 372, 374, 376,
608 : 378, 380, 382, 384, 386, 388, 390, 392, 394, 396,
609 : 398, 400, 405, 442, 443
610 : };
611 : #endif
612 :
613 : #if YYDEBUG || YYERROR_VERBOSE || 0
614 : /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
615 : First, the terminals, then, starting at YYNTOKENS, nonterminals. */
616 : static const char *const yytname[] =
617 : {
618 : "$end", "error", "$undefined", "tAGO", "tDST", "tDAY", "tDAY_UNIT",
619 : "tDAYZONE", "tHOUR_UNIT", "tLOCAL_ZONE", "tMERIDIAN", "tMINUTE_UNIT",
620 : "tMONTH", "tMONTH_UNIT", "tSEC_UNIT", "tYEAR_UNIT", "tZONE", "tSNUMBER",
621 : "tUNUMBER", "':'", "','", "'/'", "$accept", "spec", "item", "time",
622 : "local_zone", "zone", "day", "date", "rel", "relunit", "number",
623 : "o_merid", YY_NULLPTR
624 : };
625 : #endif
626 :
627 : # ifdef YYPRINT
628 : /* YYTOKNUM[NUM] -- (External) token number corresponding to the
629 : (internal) symbol number NUM (which must be that of a token). */
630 : static const yytype_uint16 yytoknum[] =
631 : {
632 : 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
633 : 265, 266, 267, 268, 269, 270, 271, 272, 273, 58,
634 : 44, 47
635 : };
636 : # endif
637 :
638 : #define YYPACT_NINF -17
639 :
640 : #define yypact_value_is_default(Yystate) \
641 : (!!((Yystate) == (-17)))
642 :
643 : #define YYTABLE_NINF -1
644 :
645 : #define yytable_value_is_error(Yytable_value) \
646 : 0
647 :
648 : /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
649 : STATE-NUM. */
650 : static const yytype_int8 yypact[] =
651 : {
652 : -17, 0, -17, 1, -17, -17, -17, 19, -17, -14,
653 : -17, -17, -17, 32, 26, 14, -17, -17, -17, -17,
654 : -17, -17, -17, 27, -17, -17, -17, 22, -17, -17,
655 : -17, -17, -17, -17, -17, -17, -17, -17, -17, -17,
656 : -16, -17, -17, -17, 29, 25, 30, -17, 31, -17,
657 : -17, -17, 28, 23, -17, -17, -17, 33, -17, 34,
658 : -7, -17, -17, -17
659 : };
660 :
661 : /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
662 : Performed when YYTABLE does not specify something else to do. Zero
663 : means the default is an error. */
664 : static const yytype_uint8 yydefact[] =
665 : {
666 : 2, 0, 1, 21, 42, 19, 45, 16, 48, 0,
667 : 39, 51, 36, 18, 0, 52, 3, 4, 5, 6,
668 : 8, 7, 9, 33, 10, 22, 17, 28, 20, 41,
669 : 44, 47, 38, 50, 35, 23, 40, 43, 11, 46,
670 : 30, 37, 49, 34, 0, 0, 0, 32, 0, 27,
671 : 31, 26, 53, 24, 29, 54, 13, 0, 12, 0,
672 : 53, 25, 15, 14
673 : };
674 :
675 : /* YYPGOTO[NTERM-NUM]. */
676 : static const yytype_int8 yypgoto[] =
677 : {
678 : -17, -17, -17, -17, -17, -17, -17, -17, -17, -17,
679 : -17, -10
680 : };
681 :
682 : /* YYDEFGOTO[NTERM-NUM]. */
683 : static const yytype_int8 yydefgoto[] =
684 : {
685 : -1, 1, 16, 17, 18, 19, 20, 21, 22, 23,
686 : 24, 58
687 : };
688 :
689 : /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
690 : positive, shift that token. If negative, reduce the rule whose
691 : number is the opposite. If YYTABLE_NINF, syntax error. */
692 : static const yytype_uint8 yytable[] =
693 : {
694 : 2, 49, 50, 55, 27, 3, 4, 5, 6, 7,
695 : 62, 8, 9, 10, 11, 12, 13, 14, 15, 35,
696 : 36, 25, 37, 26, 38, 39, 40, 41, 42, 43,
697 : 47, 44, 29, 45, 30, 46, 28, 31, 55, 32,
698 : 33, 34, 48, 52, 59, 56, 51, 57, 53, 54,
699 : 63, 60, 61
700 : };
701 :
702 : static const yytype_uint8 yycheck[] =
703 : {
704 : 0, 17, 18, 10, 18, 5, 6, 7, 8, 9,
705 : 17, 11, 12, 13, 14, 15, 16, 17, 18, 5,
706 : 6, 20, 8, 4, 10, 11, 12, 13, 14, 15,
707 : 3, 17, 6, 19, 8, 21, 4, 11, 10, 13,
708 : 14, 15, 20, 18, 21, 17, 17, 19, 18, 18,
709 : 60, 18, 18
710 : };
711 :
712 : /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
713 : symbol of state STATE-NUM. */
714 : static const yytype_uint8 yystos[] =
715 : {
716 : 0, 23, 0, 5, 6, 7, 8, 9, 11, 12,
717 : 13, 14, 15, 16, 17, 18, 24, 25, 26, 27,
718 : 28, 29, 30, 31, 32, 20, 4, 18, 4, 6,
719 : 8, 11, 13, 14, 15, 5, 6, 8, 10, 11,
720 : 12, 13, 14, 15, 17, 19, 21, 3, 20, 17,
721 : 18, 17, 18, 18, 18, 10, 17, 19, 33, 21,
722 : 18, 18, 17, 33
723 : };
724 :
725 : /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
726 : static const yytype_uint8 yyr1[] =
727 : {
728 : 0, 22, 23, 23, 24, 24, 24, 24, 24, 24,
729 : 24, 25, 25, 25, 25, 25, 26, 26, 27, 27,
730 : 27, 28, 28, 28, 29, 29, 29, 29, 29, 29,
731 : 29, 29, 30, 30, 31, 31, 31, 31, 31, 31,
732 : 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
733 : 31, 31, 32, 33, 33
734 : };
735 :
736 : /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
737 : static const yytype_uint8 yyr2[] =
738 : {
739 : 0, 2, 0, 2, 1, 1, 1, 1, 1, 1,
740 : 1, 2, 4, 4, 6, 6, 1, 2, 1, 1,
741 : 2, 1, 2, 2, 3, 5, 3, 3, 2, 4,
742 : 2, 3, 2, 1, 2, 2, 1, 2, 2, 1,
743 : 2, 2, 1, 2, 2, 1, 2, 2, 1, 2,
744 : 2, 1, 1, 0, 1
745 : };
746 :
747 :
748 : #define yyerrok (yyerrstatus = 0)
749 : #define yyclearin (yychar = YYEMPTY)
750 : #define YYEMPTY (-2)
751 : #define YYEOF 0
752 :
753 : #define YYACCEPT goto yyacceptlab
754 : #define YYABORT goto yyabortlab
755 : #define YYERROR goto yyerrorlab
756 :
757 :
758 : #define YYRECOVERING() (!!yyerrstatus)
759 :
760 : #define YYBACKUP(Token, Value) \
761 : do \
762 : if (yychar == YYEMPTY) \
763 : { \
764 : yychar = (Token); \
765 : yylval = (Value); \
766 : YYPOPSTACK (yylen); \
767 : yystate = *yyssp; \
768 : goto yybackup; \
769 : } \
770 : else \
771 : { \
772 : yyerror (pc, YY_("syntax error: cannot back up")); \
773 : YYERROR; \
774 : } \
775 : while (0)
776 :
777 : /* Error token number */
778 : #define YYTERROR 1
779 : #define YYERRCODE 256
780 :
781 :
782 :
783 : /* Enable debugging if requested. */
784 : #if YYDEBUG
785 :
786 : # ifndef YYFPRINTF
787 : # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
788 : # define YYFPRINTF fprintf
789 : # endif
790 :
791 : # define YYDPRINTF(Args) \
792 : do { \
793 : if (yydebug) \
794 : YYFPRINTF Args; \
795 : } while (0)
796 :
797 : /* This macro is provided for backward compatibility. */
798 : #ifndef YY_LOCATION_PRINT
799 : # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
800 : #endif
801 :
802 :
803 : # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
804 : do { \
805 : if (yydebug) \
806 : { \
807 : YYFPRINTF (stderr, "%s ", Title); \
808 : yy_symbol_print (stderr, \
809 : Type, Value, pc); \
810 : YYFPRINTF (stderr, "\n"); \
811 : } \
812 : } while (0)
813 :
814 :
815 : /*----------------------------------------.
816 : | Print this symbol's value on YYOUTPUT. |
817 : `----------------------------------------*/
818 :
819 : static void
820 : yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_control *pc)
821 : {
822 : FILE *yyo = yyoutput;
823 : YYUSE (yyo);
824 : YYUSE (pc);
825 : if (!yyvaluep)
826 : return;
827 : # ifdef YYPRINT
828 : if (yytype < YYNTOKENS)
829 : YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
830 : # endif
831 : YYUSE (yytype);
832 : }
833 :
834 :
835 : /*--------------------------------.
836 : | Print this symbol on YYOUTPUT. |
837 : `--------------------------------*/
838 :
839 : static void
840 : yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_control *pc)
841 : {
842 : YYFPRINTF (yyoutput, "%s %s (",
843 : yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
844 :
845 : yy_symbol_value_print (yyoutput, yytype, yyvaluep, pc);
846 : YYFPRINTF (yyoutput, ")");
847 : }
848 :
849 : /*------------------------------------------------------------------.
850 : | yy_stack_print -- Print the state stack from its BOTTOM up to its |
851 : | TOP (included). |
852 : `------------------------------------------------------------------*/
853 :
854 : static void
855 : yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
856 : {
857 : YYFPRINTF (stderr, "Stack now");
858 : for (; yybottom <= yytop; yybottom++)
859 : {
860 : int yybot = *yybottom;
861 : YYFPRINTF (stderr, " %d", yybot);
862 : }
863 : YYFPRINTF (stderr, "\n");
864 : }
865 :
866 : # define YY_STACK_PRINT(Bottom, Top) \
867 : do { \
868 : if (yydebug) \
869 : yy_stack_print ((Bottom), (Top)); \
870 : } while (0)
871 :
872 :
873 : /*------------------------------------------------.
874 : | Report that the YYRULE is going to be reduced. |
875 : `------------------------------------------------*/
876 :
877 : static void
878 : yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, struct parser_control *pc)
879 : {
880 : unsigned long int yylno = yyrline[yyrule];
881 : int yynrhs = yyr2[yyrule];
882 : int yyi;
883 : YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
884 : yyrule - 1, yylno);
885 : /* The symbols being reduced. */
886 : for (yyi = 0; yyi < yynrhs; yyi++)
887 : {
888 : YYFPRINTF (stderr, " $%d = ", yyi + 1);
889 : yy_symbol_print (stderr,
890 : yystos[yyssp[yyi + 1 - yynrhs]],
891 : &(yyvsp[(yyi + 1) - (yynrhs)])
892 : , pc);
893 : YYFPRINTF (stderr, "\n");
894 : }
895 : }
896 :
897 : # define YY_REDUCE_PRINT(Rule) \
898 : do { \
899 : if (yydebug) \
900 : yy_reduce_print (yyssp, yyvsp, Rule, pc); \
901 : } while (0)
902 :
903 : /* Nonzero means print parse trace. It is left uninitialized so that
904 : multiple parsers can coexist. */
905 : int yydebug;
906 : #else /* !YYDEBUG */
907 : # define YYDPRINTF(Args)
908 : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
909 : # define YY_STACK_PRINT(Bottom, Top)
910 : # define YY_REDUCE_PRINT(Rule)
911 : #endif /* !YYDEBUG */
912 :
913 :
914 : /* YYINITDEPTH -- initial size of the parser's stacks. */
915 : #ifndef YYINITDEPTH
916 : # define YYINITDEPTH 200
917 : #endif
918 :
919 : /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
920 : if the built-in stack extension method is used).
921 :
922 : Do not make this value too large; the results are undefined if
923 : YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
924 : evaluated with infinite-precision integer arithmetic. */
925 :
926 : #ifndef YYMAXDEPTH
927 : # define YYMAXDEPTH 10000
928 : #endif
929 :
930 :
931 : #if YYERROR_VERBOSE
932 :
933 : # ifndef yystrlen
934 : # if defined __GLIBC__ && defined _STRING_H
935 : # define yystrlen strlen
936 : # else
937 : /* Return the length of YYSTR. */
938 : static YYSIZE_T
939 : yystrlen (const char *yystr)
940 : {
941 : YYSIZE_T yylen;
942 : for (yylen = 0; yystr[yylen]; yylen++)
943 : continue;
944 : return yylen;
945 : }
946 : # endif
947 : # endif
948 :
949 : # ifndef yystpcpy
950 : # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
951 : # define yystpcpy stpcpy
952 : # else
953 : /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
954 : YYDEST. */
955 : static char *
956 : yystpcpy (char *yydest, const char *yysrc)
957 : {
958 : char *yyd = yydest;
959 : const char *yys = yysrc;
960 :
961 : while ((*yyd++ = *yys++) != '\0')
962 : continue;
963 :
964 : return yyd - 1;
965 : }
966 : # endif
967 : # endif
968 :
969 : # ifndef yytnamerr
970 : /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
971 : quotes and backslashes, so that it's suitable for yyerror. The
972 : heuristic is that double-quoting is unnecessary unless the string
973 : contains an apostrophe, a comma, or backslash (other than
974 : backslash-backslash). YYSTR is taken from yytname. If YYRES is
975 : null, do not copy; instead, return the length of what the result
976 : would have been. */
977 : static YYSIZE_T
978 : yytnamerr (char *yyres, const char *yystr)
979 : {
980 : if (*yystr == '"')
981 : {
982 : YYSIZE_T yyn = 0;
983 : char const *yyp = yystr;
984 :
985 : for (;;)
986 : switch (*++yyp)
987 : {
988 : case '\'':
989 : case ',':
990 : goto do_not_strip_quotes;
991 :
992 : case '\\':
993 : if (*++yyp != '\\')
994 : goto do_not_strip_quotes;
995 : /* Fall through. */
996 : default:
997 : if (yyres)
998 : yyres[yyn] = *yyp;
999 : yyn++;
1000 : break;
1001 :
1002 : case '"':
1003 : if (yyres)
1004 : yyres[yyn] = '\0';
1005 : return yyn;
1006 : }
1007 : do_not_strip_quotes: ;
1008 : }
1009 :
1010 : if (! yyres)
1011 : return yystrlen (yystr);
1012 :
1013 : return yystpcpy (yyres, yystr) - yyres;
1014 : }
1015 : # endif
1016 :
1017 : /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1018 : about the unexpected token YYTOKEN for the state stack whose top is
1019 : YYSSP.
1020 :
1021 : Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1022 : not large enough to hold the message. In that case, also set
1023 : *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1024 : required number of bytes is too large to store. */
1025 : static int
1026 : yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1027 : yytype_int16 *yyssp, int yytoken)
1028 : {
1029 : YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1030 : YYSIZE_T yysize = yysize0;
1031 : enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1032 : /* Internationalized format string. */
1033 : const char *yyformat = YY_NULLPTR;
1034 : /* Arguments of yyformat. */
1035 : char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1036 : /* Number of reported tokens (one for the "unexpected", one per
1037 : "expected"). */
1038 : int yycount = 0;
1039 :
1040 : /* There are many possibilities here to consider:
1041 : - If this state is a consistent state with a default action, then
1042 : the only way this function was invoked is if the default action
1043 : is an error action. In that case, don't check for expected
1044 : tokens because there are none.
1045 : - The only way there can be no lookahead present (in yychar) is if
1046 : this state is a consistent state with a default action. Thus,
1047 : detecting the absence of a lookahead is sufficient to determine
1048 : that there is no unexpected or expected token to report. In that
1049 : case, just report a simple "syntax error".
1050 : - Don't assume there isn't a lookahead just because this state is a
1051 : consistent state with a default action. There might have been a
1052 : previous inconsistent state, consistent state with a non-default
1053 : action, or user semantic action that manipulated yychar.
1054 : - Of course, the expected token list depends on states to have
1055 : correct lookahead information, and it depends on the parser not
1056 : to perform extra reductions after fetching a lookahead from the
1057 : scanner and before detecting a syntax error. Thus, state merging
1058 : (from LALR or IELR) and default reductions corrupt the expected
1059 : token list. However, the list is correct for canonical LR with
1060 : one exception: it will still contain any token that will not be
1061 : accepted due to an error action in a later state.
1062 : */
1063 : if (yytoken != YYEMPTY)
1064 : {
1065 : int yyn = yypact[*yyssp];
1066 : yyarg[yycount++] = yytname[yytoken];
1067 : if (!yypact_value_is_default (yyn))
1068 : {
1069 : /* Start YYX at -YYN if negative to avoid negative indexes in
1070 : YYCHECK. In other words, skip the first -YYN actions for
1071 : this state because they are default actions. */
1072 : int yyxbegin = yyn < 0 ? -yyn : 0;
1073 : /* Stay within bounds of both yycheck and yytname. */
1074 : int yychecklim = YYLAST - yyn + 1;
1075 : int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1076 : int yyx;
1077 :
1078 : for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1079 : if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1080 : && !yytable_value_is_error (yytable[yyx + yyn]))
1081 : {
1082 : if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1083 : {
1084 : yycount = 1;
1085 : yysize = yysize0;
1086 : break;
1087 : }
1088 : yyarg[yycount++] = yytname[yyx];
1089 : {
1090 : YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1091 : if (! (yysize <= yysize1
1092 : && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1093 : return 2;
1094 : yysize = yysize1;
1095 : }
1096 : }
1097 : }
1098 : }
1099 :
1100 : switch (yycount)
1101 : {
1102 : # define YYCASE_(N, S) \
1103 : case N: \
1104 : yyformat = S; \
1105 : break
1106 : YYCASE_(0, YY_("syntax error"));
1107 : YYCASE_(1, YY_("syntax error, unexpected %s"));
1108 : YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1109 : YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1110 : YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1111 : YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1112 : # undef YYCASE_
1113 : }
1114 :
1115 : {
1116 : YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1117 : if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1118 : return 2;
1119 : yysize = yysize1;
1120 : }
1121 :
1122 : if (*yymsg_alloc < yysize)
1123 : {
1124 : *yymsg_alloc = 2 * yysize;
1125 : if (! (yysize <= *yymsg_alloc
1126 : && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1127 : *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1128 : return 1;
1129 : }
1130 :
1131 : /* Avoid sprintf, as that infringes on the user's name space.
1132 : Don't have undefined behavior even if the translation
1133 : produced a string with the wrong number of "%s"s. */
1134 : {
1135 : char *yyp = *yymsg;
1136 : int yyi = 0;
1137 : while ((*yyp = *yyformat) != '\0')
1138 : if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1139 : {
1140 : yyp += yytnamerr (yyp, yyarg[yyi++]);
1141 : yyformat += 2;
1142 : }
1143 : else
1144 : {
1145 : yyp++;
1146 : yyformat++;
1147 : }
1148 : }
1149 : return 0;
1150 : }
1151 : #endif /* YYERROR_VERBOSE */
1152 :
1153 : /*-----------------------------------------------.
1154 : | Release the memory associated to this symbol. |
1155 : `-----------------------------------------------*/
1156 :
1157 : static void
1158 0 : yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_control *pc)
1159 : {
1160 : YYUSE (yyvaluep);
1161 : YYUSE (pc);
1162 0 : if (!yymsg)
1163 0 : yymsg = "Deleting";
1164 : YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1165 :
1166 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1167 : YYUSE (yytype);
1168 : YY_IGNORE_MAYBE_UNINITIALIZED_END
1169 0 : }
1170 :
1171 :
1172 :
1173 :
1174 : /*----------.
1175 : | yyparse. |
1176 : `----------*/
1177 :
1178 : int
1179 0 : yyparse (struct parser_control *pc)
1180 : {
1181 : /* The lookahead symbol. */
1182 : int yychar;
1183 :
1184 :
1185 : /* The semantic value of the lookahead symbol. */
1186 : /* Default value used for initialization, for pacifying older GCCs
1187 : or non-GCC compilers. */
1188 : YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1189 : YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1190 :
1191 : /* Number of syntax errors so far. */
1192 : int yynerrs;
1193 :
1194 : int yystate;
1195 : /* Number of tokens to shift before error messages enabled. */
1196 : int yyerrstatus;
1197 :
1198 : /* The stacks and their tools:
1199 : 'yyss': related to states.
1200 : 'yyvs': related to semantic values.
1201 :
1202 : Refer to the stacks through separate pointers, to allow yyoverflow
1203 : to reallocate them elsewhere. */
1204 :
1205 : /* The state stack. */
1206 : yytype_int16 yyssa[YYINITDEPTH];
1207 : yytype_int16 *yyss;
1208 : yytype_int16 *yyssp;
1209 :
1210 : /* The semantic value stack. */
1211 : YYSTYPE yyvsa[YYINITDEPTH];
1212 : YYSTYPE *yyvs;
1213 : YYSTYPE *yyvsp;
1214 :
1215 : YYSIZE_T yystacksize;
1216 :
1217 : int yyn;
1218 : int yyresult;
1219 : /* Lookahead token as an internal (translated) token number. */
1220 0 : int yytoken = 0;
1221 : /* The variables used to return semantic value and location from the
1222 : action routines. */
1223 : YYSTYPE yyval;
1224 :
1225 : #if YYERROR_VERBOSE
1226 : /* Buffer for error messages, and its allocated size. */
1227 : char yymsgbuf[128];
1228 : char *yymsg = yymsgbuf;
1229 : YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1230 : #endif
1231 :
1232 : #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1233 :
1234 : /* The number of symbols on the RHS of the reduced rule.
1235 : Keep to zero when no symbol should be popped. */
1236 0 : int yylen = 0;
1237 :
1238 0 : yyssp = yyss = yyssa;
1239 0 : yyvsp = yyvs = yyvsa;
1240 0 : yystacksize = YYINITDEPTH;
1241 :
1242 : YYDPRINTF ((stderr, "Starting parse\n"));
1243 :
1244 0 : yystate = 0;
1245 0 : yyerrstatus = 0;
1246 0 : yynerrs = 0;
1247 0 : yychar = YYEMPTY; /* Cause a token to be read. */
1248 0 : goto yysetstate;
1249 :
1250 : /*------------------------------------------------------------.
1251 : | yynewstate -- Push a new state, which is found in yystate. |
1252 : `------------------------------------------------------------*/
1253 0 : yynewstate:
1254 : /* In all cases, when you get here, the value and location stacks
1255 : have just been pushed. So pushing a state here evens the stacks. */
1256 0 : yyssp++;
1257 :
1258 0 : yysetstate:
1259 0 : *yyssp = yystate;
1260 :
1261 0 : if (yyss + yystacksize - 1 <= yyssp)
1262 : {
1263 : /* Get the current used size of the three stacks, in elements. */
1264 0 : YYSIZE_T yysize = yyssp - yyss + 1;
1265 :
1266 : #ifdef yyoverflow
1267 : {
1268 : /* Give user a chance to reallocate the stack. Use copies of
1269 : these so that the &'s don't force the real ones into
1270 : memory. */
1271 : YYSTYPE *yyvs1 = yyvs;
1272 : yytype_int16 *yyss1 = yyss;
1273 :
1274 : /* Each stack pointer address is followed by the size of the
1275 : data in use in that stack, in bytes. This used to be a
1276 : conditional around just the two extra args, but that might
1277 : be undefined if yyoverflow is a macro. */
1278 : yyoverflow (YY_("memory exhausted"),
1279 : &yyss1, yysize * sizeof (*yyssp),
1280 : &yyvs1, yysize * sizeof (*yyvsp),
1281 : &yystacksize);
1282 :
1283 : yyss = yyss1;
1284 : yyvs = yyvs1;
1285 : }
1286 : #else /* no yyoverflow */
1287 : # ifndef YYSTACK_RELOCATE
1288 : goto yyexhaustedlab;
1289 : # else
1290 : /* Extend the stack our own way. */
1291 0 : if (YYMAXDEPTH <= yystacksize)
1292 0 : goto yyexhaustedlab;
1293 0 : yystacksize *= 2;
1294 0 : if (YYMAXDEPTH < yystacksize)
1295 0 : yystacksize = YYMAXDEPTH;
1296 :
1297 : {
1298 0 : yytype_int16 *yyss1 = yyss;
1299 0 : union yyalloc *yyptr =
1300 0 : (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1301 0 : if (! yyptr)
1302 0 : goto yyexhaustedlab;
1303 0 : YYSTACK_RELOCATE (yyss_alloc, yyss);
1304 0 : YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1305 : # undef YYSTACK_RELOCATE
1306 0 : if (yyss1 != yyssa)
1307 0 : YYSTACK_FREE (yyss1);
1308 : }
1309 : # endif
1310 : #endif /* no yyoverflow */
1311 :
1312 0 : yyssp = yyss + yysize - 1;
1313 0 : yyvsp = yyvs + yysize - 1;
1314 :
1315 : YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1316 : (unsigned long int) yystacksize));
1317 :
1318 0 : if (yyss + yystacksize - 1 <= yyssp)
1319 0 : YYABORT;
1320 : }
1321 :
1322 : YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1323 :
1324 0 : if (yystate == YYFINAL)
1325 0 : YYACCEPT;
1326 :
1327 0 : goto yybackup;
1328 :
1329 : /*-----------.
1330 : | yybackup. |
1331 : `-----------*/
1332 0 : yybackup:
1333 :
1334 : /* Do appropriate processing given the current state. Read a
1335 : lookahead token if we need one and don't already have one. */
1336 :
1337 : /* First try to decide what to do without reference to lookahead token. */
1338 0 : yyn = yypact[yystate];
1339 0 : if (yypact_value_is_default (yyn))
1340 0 : goto yydefault;
1341 :
1342 : /* Not known => get a lookahead token if don't already have one. */
1343 :
1344 : /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1345 0 : if (yychar == YYEMPTY)
1346 : {
1347 : YYDPRINTF ((stderr, "Reading a token: "));
1348 0 : yychar = yylex (&yylval, pc);
1349 : }
1350 :
1351 0 : if (yychar <= YYEOF)
1352 : {
1353 0 : yychar = yytoken = YYEOF;
1354 : YYDPRINTF ((stderr, "Now at end of input.\n"));
1355 : }
1356 : else
1357 : {
1358 0 : yytoken = YYTRANSLATE (yychar);
1359 : YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1360 : }
1361 :
1362 : /* If the proper action on seeing token YYTOKEN is to reduce or to
1363 : detect an error, take that action. */
1364 0 : yyn += yytoken;
1365 0 : if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1366 : goto yydefault;
1367 0 : yyn = yytable[yyn];
1368 0 : if (yyn <= 0)
1369 : {
1370 : if (yytable_value_is_error (yyn))
1371 : goto yyerrlab;
1372 0 : yyn = -yyn;
1373 0 : goto yyreduce;
1374 : }
1375 :
1376 : /* Count tokens shifted since error; after three, turn off error
1377 : status. */
1378 0 : if (yyerrstatus)
1379 0 : yyerrstatus--;
1380 :
1381 : /* Shift the lookahead token. */
1382 : YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1383 :
1384 : /* Discard the shifted token. */
1385 0 : yychar = YYEMPTY;
1386 :
1387 0 : yystate = yyn;
1388 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1389 0 : *++yyvsp = yylval;
1390 : YY_IGNORE_MAYBE_UNINITIALIZED_END
1391 :
1392 0 : goto yynewstate;
1393 :
1394 :
1395 : /*-----------------------------------------------------------.
1396 : | yydefault -- do the default action for the current state. |
1397 : `-----------------------------------------------------------*/
1398 0 : yydefault:
1399 0 : yyn = yydefact[yystate];
1400 0 : if (yyn == 0)
1401 0 : goto yyerrlab;
1402 0 : goto yyreduce;
1403 :
1404 :
1405 : /*-----------------------------.
1406 : | yyreduce -- Do a reduction. |
1407 : `-----------------------------*/
1408 0 : yyreduce:
1409 : /* yyn is the number of a rule to reduce with. */
1410 0 : yylen = yyr2[yyn];
1411 :
1412 : /* If YYLEN is nonzero, implement the default value of the action:
1413 : '$$ = $1'.
1414 :
1415 : Otherwise, the following line sets YYVAL to garbage.
1416 : This behavior is undocumented and Bison
1417 : users should not rely upon it. Assigning to YYVAL
1418 : unconditionally makes the parser a bit smaller, and it avoids a
1419 : GCC warning that YYVAL may be used uninitialized. */
1420 0 : yyval = yyvsp[1-yylen];
1421 :
1422 :
1423 : YY_REDUCE_PRINT (yyn);
1424 0 : switch (yyn)
1425 : {
1426 0 : case 4:
1427 : #line 198 "source3/modules/getdate.y" /* yacc.c:1646 */
1428 : { pc->times_seen++; }
1429 : #line 1430 "source3/modules/getdate.c" /* yacc.c:1646 */
1430 0 : break;
1431 :
1432 0 : case 5:
1433 : #line 200 "source3/modules/getdate.y" /* yacc.c:1646 */
1434 : { pc->local_zones_seen++; }
1435 : #line 1436 "source3/modules/getdate.c" /* yacc.c:1646 */
1436 0 : break;
1437 :
1438 0 : case 6:
1439 : #line 202 "source3/modules/getdate.y" /* yacc.c:1646 */
1440 : { pc->zones_seen++; }
1441 : #line 1442 "source3/modules/getdate.c" /* yacc.c:1646 */
1442 0 : break;
1443 :
1444 0 : case 7:
1445 : #line 204 "source3/modules/getdate.y" /* yacc.c:1646 */
1446 : { pc->dates_seen++; }
1447 : #line 1448 "source3/modules/getdate.c" /* yacc.c:1646 */
1448 0 : break;
1449 :
1450 0 : case 8:
1451 : #line 206 "source3/modules/getdate.y" /* yacc.c:1646 */
1452 : { pc->days_seen++; }
1453 : #line 1454 "source3/modules/getdate.c" /* yacc.c:1646 */
1454 0 : break;
1455 :
1456 0 : case 9:
1457 : #line 208 "source3/modules/getdate.y" /* yacc.c:1646 */
1458 : { pc->rels_seen++; }
1459 : #line 1460 "source3/modules/getdate.c" /* yacc.c:1646 */
1460 0 : break;
1461 :
1462 0 : case 11:
1463 : #line 214 "source3/modules/getdate.y" /* yacc.c:1646 */
1464 : {
1465 : pc->hour = (yyvsp[-1].textintval).value;
1466 : pc->minutes = 0;
1467 : pc->seconds = 0;
1468 : pc->meridian = (yyvsp[0].intval);
1469 : }
1470 : #line 1471 "source3/modules/getdate.c" /* yacc.c:1646 */
1471 0 : break;
1472 :
1473 0 : case 12:
1474 : #line 221 "source3/modules/getdate.y" /* yacc.c:1646 */
1475 : {
1476 : pc->hour = (yyvsp[-3].textintval).value;
1477 : pc->minutes = (yyvsp[-1].textintval).value;
1478 : pc->seconds = 0;
1479 : pc->meridian = (yyvsp[0].intval);
1480 : }
1481 : #line 1482 "source3/modules/getdate.c" /* yacc.c:1646 */
1482 0 : break;
1483 :
1484 0 : case 13:
1485 : #line 228 "source3/modules/getdate.y" /* yacc.c:1646 */
1486 : {
1487 : pc->hour = (yyvsp[-3].textintval).value;
1488 : pc->minutes = (yyvsp[-1].textintval).value;
1489 : pc->meridian = MER24;
1490 : pc->zones_seen++;
1491 : pc->time_zone = (yyvsp[0].textintval).value % 100 + ((yyvsp[0].textintval).value / 100) * 60;
1492 : }
1493 : #line 1494 "source3/modules/getdate.c" /* yacc.c:1646 */
1494 0 : break;
1495 :
1496 0 : case 14:
1497 : #line 236 "source3/modules/getdate.y" /* yacc.c:1646 */
1498 : {
1499 : pc->hour = (yyvsp[-5].textintval).value;
1500 : pc->minutes = (yyvsp[-3].textintval).value;
1501 : pc->seconds = (yyvsp[-1].textintval).value;
1502 : pc->meridian = (yyvsp[0].intval);
1503 : }
1504 : #line 1505 "source3/modules/getdate.c" /* yacc.c:1646 */
1505 0 : break;
1506 :
1507 0 : case 15:
1508 : #line 243 "source3/modules/getdate.y" /* yacc.c:1646 */
1509 : {
1510 : pc->hour = (yyvsp[-5].textintval).value;
1511 : pc->minutes = (yyvsp[-3].textintval).value;
1512 : pc->seconds = (yyvsp[-1].textintval).value;
1513 : pc->meridian = MER24;
1514 : pc->zones_seen++;
1515 : pc->time_zone = (yyvsp[0].textintval).value % 100 + ((yyvsp[0].textintval).value / 100) * 60;
1516 : }
1517 : #line 1518 "source3/modules/getdate.c" /* yacc.c:1646 */
1518 0 : break;
1519 :
1520 0 : case 16:
1521 : #line 255 "source3/modules/getdate.y" /* yacc.c:1646 */
1522 : { pc->local_isdst = (yyvsp[0].intval); }
1523 : #line 1524 "source3/modules/getdate.c" /* yacc.c:1646 */
1524 0 : break;
1525 :
1526 0 : case 17:
1527 : #line 257 "source3/modules/getdate.y" /* yacc.c:1646 */
1528 : { pc->local_isdst = (yyvsp[-1].intval) < 0 ? 1 : (yyvsp[-1].intval) + 1; }
1529 : #line 1530 "source3/modules/getdate.c" /* yacc.c:1646 */
1530 0 : break;
1531 :
1532 0 : case 18:
1533 : #line 262 "source3/modules/getdate.y" /* yacc.c:1646 */
1534 : { pc->time_zone = (yyvsp[0].intval); }
1535 : #line 1536 "source3/modules/getdate.c" /* yacc.c:1646 */
1536 0 : break;
1537 :
1538 0 : case 19:
1539 : #line 264 "source3/modules/getdate.y" /* yacc.c:1646 */
1540 : { pc->time_zone = (yyvsp[0].intval) + 60; }
1541 : #line 1542 "source3/modules/getdate.c" /* yacc.c:1646 */
1542 0 : break;
1543 :
1544 0 : case 20:
1545 : #line 266 "source3/modules/getdate.y" /* yacc.c:1646 */
1546 : { pc->time_zone = (yyvsp[-1].intval) + 60; }
1547 : #line 1548 "source3/modules/getdate.c" /* yacc.c:1646 */
1548 0 : break;
1549 :
1550 0 : case 21:
1551 : #line 271 "source3/modules/getdate.y" /* yacc.c:1646 */
1552 : {
1553 : pc->day_ordinal = 1;
1554 : pc->day_number = (yyvsp[0].intval);
1555 : }
1556 : #line 1557 "source3/modules/getdate.c" /* yacc.c:1646 */
1557 0 : break;
1558 :
1559 0 : case 22:
1560 : #line 276 "source3/modules/getdate.y" /* yacc.c:1646 */
1561 : {
1562 : pc->day_ordinal = 1;
1563 : pc->day_number = (yyvsp[-1].intval);
1564 : }
1565 : #line 1566 "source3/modules/getdate.c" /* yacc.c:1646 */
1566 0 : break;
1567 :
1568 0 : case 23:
1569 : #line 281 "source3/modules/getdate.y" /* yacc.c:1646 */
1570 : {
1571 : pc->day_ordinal = (yyvsp[-1].textintval).value;
1572 : pc->day_number = (yyvsp[0].intval);
1573 : }
1574 : #line 1575 "source3/modules/getdate.c" /* yacc.c:1646 */
1575 0 : break;
1576 :
1577 0 : case 24:
1578 : #line 289 "source3/modules/getdate.y" /* yacc.c:1646 */
1579 : {
1580 : pc->month = (yyvsp[-2].textintval).value;
1581 : pc->day = (yyvsp[0].textintval).value;
1582 : }
1583 : #line 1584 "source3/modules/getdate.c" /* yacc.c:1646 */
1584 0 : break;
1585 :
1586 0 : case 25:
1587 : #line 294 "source3/modules/getdate.y" /* yacc.c:1646 */
1588 : {
1589 : /* Interpret as YYYY/MM/DD if the first value has 4 or more digits,
1590 : otherwise as MM/DD/YY.
1591 : The goal in recognizing YYYY/MM/DD is solely to support legacy
1592 : machine-generated dates like those in an RCS log listing. If
1593 : you want portability, use the ISO 8601 format. */
1594 : if (4 <= (yyvsp[-4].textintval).digits)
1595 : {
1596 : pc->year = (yyvsp[-4].textintval);
1597 : pc->month = (yyvsp[-2].textintval).value;
1598 : pc->day = (yyvsp[0].textintval).value;
1599 : }
1600 : else
1601 : {
1602 : pc->month = (yyvsp[-4].textintval).value;
1603 : pc->day = (yyvsp[-2].textintval).value;
1604 : pc->year = (yyvsp[0].textintval);
1605 : }
1606 : }
1607 : #line 1608 "source3/modules/getdate.c" /* yacc.c:1646 */
1608 0 : break;
1609 :
1610 0 : case 26:
1611 : #line 314 "source3/modules/getdate.y" /* yacc.c:1646 */
1612 : {
1613 : /* ISO 8601 format. YYYY-MM-DD. */
1614 : pc->year = (yyvsp[-2].textintval);
1615 : pc->month = -(yyvsp[-1].textintval).value;
1616 : pc->day = -(yyvsp[0].textintval).value;
1617 : }
1618 : #line 1619 "source3/modules/getdate.c" /* yacc.c:1646 */
1619 0 : break;
1620 :
1621 0 : case 27:
1622 : #line 321 "source3/modules/getdate.y" /* yacc.c:1646 */
1623 : {
1624 : /* e.g. 17-JUN-1992. */
1625 : pc->day = (yyvsp[-2].textintval).value;
1626 : pc->month = (yyvsp[-1].intval);
1627 : pc->year.value = -(yyvsp[0].textintval).value;
1628 : pc->year.digits = (yyvsp[0].textintval).digits;
1629 : }
1630 : #line 1631 "source3/modules/getdate.c" /* yacc.c:1646 */
1631 0 : break;
1632 :
1633 0 : case 28:
1634 : #line 329 "source3/modules/getdate.y" /* yacc.c:1646 */
1635 : {
1636 : pc->month = (yyvsp[-1].intval);
1637 : pc->day = (yyvsp[0].textintval).value;
1638 : }
1639 : #line 1640 "source3/modules/getdate.c" /* yacc.c:1646 */
1640 0 : break;
1641 :
1642 0 : case 29:
1643 : #line 334 "source3/modules/getdate.y" /* yacc.c:1646 */
1644 : {
1645 : pc->month = (yyvsp[-3].intval);
1646 : pc->day = (yyvsp[-2].textintval).value;
1647 : pc->year = (yyvsp[0].textintval);
1648 : }
1649 : #line 1650 "source3/modules/getdate.c" /* yacc.c:1646 */
1650 0 : break;
1651 :
1652 0 : case 30:
1653 : #line 340 "source3/modules/getdate.y" /* yacc.c:1646 */
1654 : {
1655 : pc->day = (yyvsp[-1].textintval).value;
1656 : pc->month = (yyvsp[0].intval);
1657 : }
1658 : #line 1659 "source3/modules/getdate.c" /* yacc.c:1646 */
1659 0 : break;
1660 :
1661 0 : case 31:
1662 : #line 345 "source3/modules/getdate.y" /* yacc.c:1646 */
1663 : {
1664 : pc->day = (yyvsp[-2].textintval).value;
1665 : pc->month = (yyvsp[-1].intval);
1666 : pc->year = (yyvsp[0].textintval);
1667 : }
1668 : #line 1669 "source3/modules/getdate.c" /* yacc.c:1646 */
1669 0 : break;
1670 :
1671 0 : case 32:
1672 : #line 354 "source3/modules/getdate.y" /* yacc.c:1646 */
1673 : {
1674 : pc->rel_seconds = -pc->rel_seconds;
1675 : pc->rel_minutes = -pc->rel_minutes;
1676 : pc->rel_hour = -pc->rel_hour;
1677 : pc->rel_day = -pc->rel_day;
1678 : pc->rel_month = -pc->rel_month;
1679 : pc->rel_year = -pc->rel_year;
1680 : }
1681 : #line 1682 "source3/modules/getdate.c" /* yacc.c:1646 */
1682 0 : break;
1683 :
1684 0 : case 34:
1685 : #line 367 "source3/modules/getdate.y" /* yacc.c:1646 */
1686 : { pc->rel_year += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
1687 : #line 1688 "source3/modules/getdate.c" /* yacc.c:1646 */
1688 0 : break;
1689 :
1690 0 : case 35:
1691 : #line 369 "source3/modules/getdate.y" /* yacc.c:1646 */
1692 : { pc->rel_year += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
1693 : #line 1694 "source3/modules/getdate.c" /* yacc.c:1646 */
1694 0 : break;
1695 :
1696 0 : case 36:
1697 : #line 371 "source3/modules/getdate.y" /* yacc.c:1646 */
1698 : { pc->rel_year += (yyvsp[0].intval); }
1699 : #line 1700 "source3/modules/getdate.c" /* yacc.c:1646 */
1700 0 : break;
1701 :
1702 0 : case 37:
1703 : #line 373 "source3/modules/getdate.y" /* yacc.c:1646 */
1704 : { pc->rel_month += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
1705 : #line 1706 "source3/modules/getdate.c" /* yacc.c:1646 */
1706 0 : break;
1707 :
1708 0 : case 38:
1709 : #line 375 "source3/modules/getdate.y" /* yacc.c:1646 */
1710 : { pc->rel_month += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
1711 : #line 1712 "source3/modules/getdate.c" /* yacc.c:1646 */
1712 0 : break;
1713 :
1714 0 : case 39:
1715 : #line 377 "source3/modules/getdate.y" /* yacc.c:1646 */
1716 : { pc->rel_month += (yyvsp[0].intval); }
1717 : #line 1718 "source3/modules/getdate.c" /* yacc.c:1646 */
1718 0 : break;
1719 :
1720 0 : case 40:
1721 : #line 379 "source3/modules/getdate.y" /* yacc.c:1646 */
1722 : { pc->rel_day += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
1723 : #line 1724 "source3/modules/getdate.c" /* yacc.c:1646 */
1724 0 : break;
1725 :
1726 0 : case 41:
1727 : #line 381 "source3/modules/getdate.y" /* yacc.c:1646 */
1728 : { pc->rel_day += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
1729 : #line 1730 "source3/modules/getdate.c" /* yacc.c:1646 */
1730 0 : break;
1731 :
1732 0 : case 42:
1733 : #line 383 "source3/modules/getdate.y" /* yacc.c:1646 */
1734 : { pc->rel_day += (yyvsp[0].intval); }
1735 : #line 1736 "source3/modules/getdate.c" /* yacc.c:1646 */
1736 0 : break;
1737 :
1738 0 : case 43:
1739 : #line 385 "source3/modules/getdate.y" /* yacc.c:1646 */
1740 : { pc->rel_hour += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
1741 : #line 1742 "source3/modules/getdate.c" /* yacc.c:1646 */
1742 0 : break;
1743 :
1744 0 : case 44:
1745 : #line 387 "source3/modules/getdate.y" /* yacc.c:1646 */
1746 : { pc->rel_hour += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
1747 : #line 1748 "source3/modules/getdate.c" /* yacc.c:1646 */
1748 0 : break;
1749 :
1750 0 : case 45:
1751 : #line 389 "source3/modules/getdate.y" /* yacc.c:1646 */
1752 : { pc->rel_hour += (yyvsp[0].intval); }
1753 : #line 1754 "source3/modules/getdate.c" /* yacc.c:1646 */
1754 0 : break;
1755 :
1756 0 : case 46:
1757 : #line 391 "source3/modules/getdate.y" /* yacc.c:1646 */
1758 : { pc->rel_minutes += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
1759 : #line 1760 "source3/modules/getdate.c" /* yacc.c:1646 */
1760 0 : break;
1761 :
1762 0 : case 47:
1763 : #line 393 "source3/modules/getdate.y" /* yacc.c:1646 */
1764 : { pc->rel_minutes += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
1765 : #line 1766 "source3/modules/getdate.c" /* yacc.c:1646 */
1766 0 : break;
1767 :
1768 0 : case 48:
1769 : #line 395 "source3/modules/getdate.y" /* yacc.c:1646 */
1770 : { pc->rel_minutes += (yyvsp[0].intval); }
1771 : #line 1772 "source3/modules/getdate.c" /* yacc.c:1646 */
1772 0 : break;
1773 :
1774 0 : case 49:
1775 : #line 397 "source3/modules/getdate.y" /* yacc.c:1646 */
1776 : { pc->rel_seconds += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
1777 : #line 1778 "source3/modules/getdate.c" /* yacc.c:1646 */
1778 0 : break;
1779 :
1780 0 : case 50:
1781 : #line 399 "source3/modules/getdate.y" /* yacc.c:1646 */
1782 : { pc->rel_seconds += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
1783 : #line 1784 "source3/modules/getdate.c" /* yacc.c:1646 */
1784 0 : break;
1785 :
1786 0 : case 51:
1787 : #line 401 "source3/modules/getdate.y" /* yacc.c:1646 */
1788 : { pc->rel_seconds += (yyvsp[0].intval); }
1789 : #line 1790 "source3/modules/getdate.c" /* yacc.c:1646 */
1790 0 : break;
1791 :
1792 0 : case 52:
1793 : #line 406 "source3/modules/getdate.y" /* yacc.c:1646 */
1794 : {
1795 : if (pc->dates_seen
1796 : && ! pc->rels_seen && (pc->times_seen || 2 < (yyvsp[0].textintval).digits))
1797 : pc->year = (yyvsp[0].textintval);
1798 : else
1799 : {
1800 : if (4 < (yyvsp[0].textintval).digits)
1801 : {
1802 : pc->dates_seen++;
1803 : pc->day = (yyvsp[0].textintval).value % 100;
1804 : pc->month = ((yyvsp[0].textintval).value / 100) % 100;
1805 : pc->year.value = (yyvsp[0].textintval).value / 10000;
1806 : pc->year.digits = (yyvsp[0].textintval).digits - 4;
1807 : }
1808 : else
1809 : {
1810 : pc->times_seen++;
1811 : if ((yyvsp[0].textintval).digits <= 2)
1812 : {
1813 : pc->hour = (yyvsp[0].textintval).value;
1814 : pc->minutes = 0;
1815 : }
1816 : else
1817 : {
1818 : pc->hour = (yyvsp[0].textintval).value / 100;
1819 : pc->minutes = (yyvsp[0].textintval).value % 100;
1820 : }
1821 : pc->seconds = 0;
1822 : pc->meridian = MER24;
1823 : }
1824 : }
1825 : }
1826 : #line 1827 "source3/modules/getdate.c" /* yacc.c:1646 */
1827 0 : break;
1828 :
1829 0 : case 53:
1830 : #line 442 "source3/modules/getdate.y" /* yacc.c:1646 */
1831 : { (yyval.intval) = MER24; }
1832 : #line 1833 "source3/modules/getdate.c" /* yacc.c:1646 */
1833 0 : break;
1834 :
1835 0 : case 54:
1836 : #line 444 "source3/modules/getdate.y" /* yacc.c:1646 */
1837 : { (yyval.intval) = (yyvsp[0].intval); }
1838 : #line 1839 "source3/modules/getdate.c" /* yacc.c:1646 */
1839 0 : break;
1840 :
1841 :
1842 : #line 1843 "source3/modules/getdate.c" /* yacc.c:1646 */
1843 0 : default: break;
1844 : }
1845 : /* User semantic actions sometimes alter yychar, and that requires
1846 : that yytoken be updated with the new translation. We take the
1847 : approach of translating immediately before every use of yytoken.
1848 : One alternative is translating here after every semantic action,
1849 : but that translation would be missed if the semantic action invokes
1850 : YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1851 : if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1852 : incorrect destructor might then be invoked immediately. In the
1853 : case of YYERROR or YYBACKUP, subsequent parser actions might lead
1854 : to an incorrect destructor call or verbose syntax error message
1855 : before the lookahead is translated. */
1856 : YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1857 :
1858 0 : YYPOPSTACK (yylen);
1859 0 : yylen = 0;
1860 : YY_STACK_PRINT (yyss, yyssp);
1861 :
1862 0 : *++yyvsp = yyval;
1863 :
1864 : /* Now 'shift' the result of the reduction. Determine what state
1865 : that goes to, based on the state we popped back to and the rule
1866 : number reduced by. */
1867 :
1868 0 : yyn = yyr1[yyn];
1869 :
1870 0 : yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1871 0 : if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1872 0 : yystate = yytable[yystate];
1873 : else
1874 0 : yystate = yydefgoto[yyn - YYNTOKENS];
1875 :
1876 0 : goto yynewstate;
1877 :
1878 :
1879 : /*--------------------------------------.
1880 : | yyerrlab -- here on detecting error. |
1881 : `--------------------------------------*/
1882 0 : yyerrlab:
1883 : /* Make sure we have latest lookahead translation. See comments at
1884 : user semantic actions for why this is necessary. */
1885 0 : yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1886 :
1887 : /* If not already recovering from an error, report this error. */
1888 0 : if (!yyerrstatus)
1889 : {
1890 0 : ++yynerrs;
1891 : #if ! YYERROR_VERBOSE
1892 0 : yyerror (pc, YY_("syntax error"));
1893 : #else
1894 : # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1895 : yyssp, yytoken)
1896 : {
1897 : char const *yymsgp = YY_("syntax error");
1898 : int yysyntax_error_status;
1899 : yysyntax_error_status = YYSYNTAX_ERROR;
1900 : if (yysyntax_error_status == 0)
1901 : yymsgp = yymsg;
1902 : else if (yysyntax_error_status == 1)
1903 : {
1904 : if (yymsg != yymsgbuf)
1905 : YYSTACK_FREE (yymsg);
1906 : yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1907 : if (!yymsg)
1908 : {
1909 : yymsg = yymsgbuf;
1910 : yymsg_alloc = sizeof yymsgbuf;
1911 : yysyntax_error_status = 2;
1912 : }
1913 : else
1914 : {
1915 : yysyntax_error_status = YYSYNTAX_ERROR;
1916 : yymsgp = yymsg;
1917 : }
1918 : }
1919 : yyerror (pc, yymsgp);
1920 : if (yysyntax_error_status == 2)
1921 : goto yyexhaustedlab;
1922 : }
1923 : # undef YYSYNTAX_ERROR
1924 : #endif
1925 : }
1926 :
1927 :
1928 :
1929 0 : if (yyerrstatus == 3)
1930 : {
1931 : /* If just tried and failed to reuse lookahead token after an
1932 : error, discard it. */
1933 :
1934 0 : if (yychar <= YYEOF)
1935 : {
1936 : /* Return failure if at end of input. */
1937 0 : if (yychar == YYEOF)
1938 0 : YYABORT;
1939 : }
1940 : else
1941 : {
1942 0 : yydestruct ("Error: discarding",
1943 : yytoken, &yylval, pc);
1944 0 : yychar = YYEMPTY;
1945 : }
1946 : }
1947 :
1948 : /* Else will try to reuse lookahead token after shifting the error
1949 : token. */
1950 0 : goto yyerrlab1;
1951 :
1952 :
1953 : /*---------------------------------------------------.
1954 : | yyerrorlab -- error raised explicitly by YYERROR. |
1955 : `---------------------------------------------------*/
1956 : yyerrorlab:
1957 :
1958 : /* Pacify compilers like GCC when the user code never invokes
1959 : YYERROR and the label yyerrorlab therefore never appears in user
1960 : code. */
1961 : if (/*CONSTCOND*/ 0)
1962 : goto yyerrorlab;
1963 :
1964 : /* Do not reclaim the symbols of the rule whose action triggered
1965 : this YYERROR. */
1966 : YYPOPSTACK (yylen);
1967 : yylen = 0;
1968 : YY_STACK_PRINT (yyss, yyssp);
1969 : yystate = *yyssp;
1970 : goto yyerrlab1;
1971 :
1972 :
1973 : /*-------------------------------------------------------------.
1974 : | yyerrlab1 -- common code for both syntax error and YYERROR. |
1975 : `-------------------------------------------------------------*/
1976 0 : yyerrlab1:
1977 0 : yyerrstatus = 3; /* Each real token shifted decrements this. */
1978 :
1979 : for (;;)
1980 : {
1981 0 : yyn = yypact[yystate];
1982 0 : if (!yypact_value_is_default (yyn))
1983 : {
1984 0 : yyn += YYTERROR;
1985 0 : if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1986 : {
1987 0 : yyn = yytable[yyn];
1988 0 : if (0 < yyn)
1989 0 : break;
1990 : }
1991 : }
1992 :
1993 : /* Pop the current state because it cannot handle the error token. */
1994 0 : if (yyssp == yyss)
1995 0 : YYABORT;
1996 :
1997 :
1998 0 : yydestruct ("Error: popping",
1999 0 : yystos[yystate], yyvsp, pc);
2000 0 : YYPOPSTACK (1);
2001 0 : yystate = *yyssp;
2002 : YY_STACK_PRINT (yyss, yyssp);
2003 : }
2004 :
2005 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2006 0 : *++yyvsp = yylval;
2007 : YY_IGNORE_MAYBE_UNINITIALIZED_END
2008 :
2009 :
2010 : /* Shift the error token. */
2011 : YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2012 :
2013 0 : yystate = yyn;
2014 0 : goto yynewstate;
2015 :
2016 :
2017 : /*-------------------------------------.
2018 : | yyacceptlab -- YYACCEPT comes here. |
2019 : `-------------------------------------*/
2020 0 : yyacceptlab:
2021 0 : yyresult = 0;
2022 0 : goto yyreturn;
2023 :
2024 : /*-----------------------------------.
2025 : | yyabortlab -- YYABORT comes here. |
2026 : `-----------------------------------*/
2027 0 : yyabortlab:
2028 0 : yyresult = 1;
2029 0 : goto yyreturn;
2030 :
2031 : #if !defined yyoverflow || YYERROR_VERBOSE
2032 : /*-------------------------------------------------.
2033 : | yyexhaustedlab -- memory exhaustion comes here. |
2034 : `-------------------------------------------------*/
2035 0 : yyexhaustedlab:
2036 0 : yyerror (pc, YY_("memory exhausted"));
2037 0 : yyresult = 2;
2038 : /* Fall through. */
2039 : #endif
2040 :
2041 0 : yyreturn:
2042 0 : if (yychar != YYEMPTY)
2043 : {
2044 : /* Make sure we have latest lookahead translation. See comments at
2045 : user semantic actions for why this is necessary. */
2046 0 : yytoken = YYTRANSLATE (yychar);
2047 0 : yydestruct ("Cleanup: discarding lookahead",
2048 : yytoken, &yylval, pc);
2049 : }
2050 : /* Do not reclaim the symbols of the rule whose action triggered
2051 : this YYABORT or YYACCEPT. */
2052 0 : YYPOPSTACK (yylen);
2053 : YY_STACK_PRINT (yyss, yyssp);
2054 0 : while (yyssp != yyss)
2055 : {
2056 0 : yydestruct ("Cleanup: popping",
2057 0 : yystos[*yyssp], yyvsp, pc);
2058 0 : YYPOPSTACK (1);
2059 : }
2060 : #ifndef yyoverflow
2061 0 : if (yyss != yyssa)
2062 0 : YYSTACK_FREE (yyss);
2063 : #endif
2064 : #if YYERROR_VERBOSE
2065 : if (yymsg != yymsgbuf)
2066 : YYSTACK_FREE (yymsg);
2067 : #endif
2068 0 : return yyresult;
2069 : }
2070 : #line 447 "source3/modules/getdate.y" /* yacc.c:1906 */
2071 :
2072 :
2073 : /* Include this file down here because bison inserts code above which
2074 : may define-away `const'. We want the prototype for get_date to have
2075 : the same signature as the function definition. */
2076 : #include "modules/getdate.h"
2077 :
2078 : #ifndef gmtime
2079 : struct tm *gmtime (const time_t *);
2080 : #endif
2081 : #ifndef localtime
2082 : struct tm *localtime (const time_t *);
2083 : #endif
2084 : #ifndef mktime
2085 : time_t mktime (struct tm *);
2086 : #endif
2087 :
2088 : static table const meridian_table[] =
2089 : {
2090 : { "AM", tMERIDIAN, MERam },
2091 : { "A.M.", tMERIDIAN, MERam },
2092 : { "PM", tMERIDIAN, MERpm },
2093 : { "P.M.", tMERIDIAN, MERpm },
2094 : { 0, 0, 0 }
2095 : };
2096 :
2097 : static table const dst_table[] =
2098 : {
2099 : { "DST", tDST, 0 }
2100 : };
2101 :
2102 : static table const month_and_day_table[] =
2103 : {
2104 : { "JANUARY", tMONTH, 1 },
2105 : { "FEBRUARY", tMONTH, 2 },
2106 : { "MARCH", tMONTH, 3 },
2107 : { "APRIL", tMONTH, 4 },
2108 : { "MAY", tMONTH, 5 },
2109 : { "JUNE", tMONTH, 6 },
2110 : { "JULY", tMONTH, 7 },
2111 : { "AUGUST", tMONTH, 8 },
2112 : { "SEPTEMBER",tMONTH, 9 },
2113 : { "SEPT", tMONTH, 9 },
2114 : { "OCTOBER", tMONTH, 10 },
2115 : { "NOVEMBER", tMONTH, 11 },
2116 : { "DECEMBER", tMONTH, 12 },
2117 : { "SUNDAY", tDAY, 0 },
2118 : { "MONDAY", tDAY, 1 },
2119 : { "TUESDAY", tDAY, 2 },
2120 : { "TUES", tDAY, 2 },
2121 : { "WEDNESDAY",tDAY, 3 },
2122 : { "WEDNES", tDAY, 3 },
2123 : { "THURSDAY", tDAY, 4 },
2124 : { "THUR", tDAY, 4 },
2125 : { "THURS", tDAY, 4 },
2126 : { "FRIDAY", tDAY, 5 },
2127 : { "SATURDAY", tDAY, 6 },
2128 : { 0, 0, 0 }
2129 : };
2130 :
2131 : static table const time_units_table[] =
2132 : {
2133 : { "YEAR", tYEAR_UNIT, 1 },
2134 : { "MONTH", tMONTH_UNIT, 1 },
2135 : { "FORTNIGHT",tDAY_UNIT, 14 },
2136 : { "WEEK", tDAY_UNIT, 7 },
2137 : { "DAY", tDAY_UNIT, 1 },
2138 : { "HOUR", tHOUR_UNIT, 1 },
2139 : { "MINUTE", tMINUTE_UNIT, 1 },
2140 : { "MIN", tMINUTE_UNIT, 1 },
2141 : { "SECOND", tSEC_UNIT, 1 },
2142 : { "SEC", tSEC_UNIT, 1 },
2143 : { 0, 0, 0 }
2144 : };
2145 :
2146 : /* Assorted relative-time words. */
2147 : static table const relative_time_table[] =
2148 : {
2149 : { "TOMORROW", tMINUTE_UNIT, 24 * 60 },
2150 : { "YESTERDAY",tMINUTE_UNIT, - (24 * 60) },
2151 : { "TODAY", tMINUTE_UNIT, 0 },
2152 : { "NOW", tMINUTE_UNIT, 0 },
2153 : { "LAST", tUNUMBER, -1 },
2154 : { "THIS", tUNUMBER, 0 },
2155 : { "NEXT", tUNUMBER, 1 },
2156 : { "FIRST", tUNUMBER, 1 },
2157 : /*{ "SECOND", tUNUMBER, 2 }, */
2158 : { "THIRD", tUNUMBER, 3 },
2159 : { "FOURTH", tUNUMBER, 4 },
2160 : { "FIFTH", tUNUMBER, 5 },
2161 : { "SIXTH", tUNUMBER, 6 },
2162 : { "SEVENTH", tUNUMBER, 7 },
2163 : { "EIGHTH", tUNUMBER, 8 },
2164 : { "NINTH", tUNUMBER, 9 },
2165 : { "TENTH", tUNUMBER, 10 },
2166 : { "ELEVENTH", tUNUMBER, 11 },
2167 : { "TWELFTH", tUNUMBER, 12 },
2168 : { "AGO", tAGO, 1 },
2169 : { 0, 0, 0 }
2170 : };
2171 :
2172 : /* The time zone table. This table is necessarily incomplete, as time
2173 : zone abbreviations are ambiguous; e.g. Australians interpret "EST"
2174 : as Eastern time in Australia, not as US Eastern Standard Time.
2175 : You cannot rely on getdate to handle arbitrary time zone
2176 : abbreviations; use numeric abbreviations like `-0500' instead. */
2177 : static table const time_zone_table[] =
2178 : {
2179 : { "GMT", tZONE, HOUR ( 0) }, /* Greenwich Mean */
2180 : { "UT", tZONE, HOUR ( 0) }, /* Universal (Coordinated) */
2181 : { "UTC", tZONE, HOUR ( 0) },
2182 : { "WET", tZONE, HOUR ( 0) }, /* Western European */
2183 : { "WEST", tDAYZONE, HOUR ( 0) }, /* Western European Summer */
2184 : { "BST", tDAYZONE, HOUR ( 0) }, /* British Summer */
2185 : { "ART", tZONE, -HOUR ( 3) }, /* Argentina */
2186 : { "BRT", tZONE, -HOUR ( 3) }, /* Brazil */
2187 : { "BRST", tDAYZONE, -HOUR ( 3) }, /* Brazil Summer */
2188 : { "NST", tZONE, -(HOUR ( 3) + 30) }, /* Newfoundland Standard */
2189 : { "NDT", tDAYZONE,-(HOUR ( 3) + 30) }, /* Newfoundland Daylight */
2190 : { "AST", tZONE, -HOUR ( 4) }, /* Atlantic Standard */
2191 : { "ADT", tDAYZONE, -HOUR ( 4) }, /* Atlantic Daylight */
2192 : { "CLT", tZONE, -HOUR ( 4) }, /* Chile */
2193 : { "CLST", tDAYZONE, -HOUR ( 4) }, /* Chile Summer */
2194 : { "EST", tZONE, -HOUR ( 5) }, /* Eastern Standard */
2195 : { "EDT", tDAYZONE, -HOUR ( 5) }, /* Eastern Daylight */
2196 : { "CST", tZONE, -HOUR ( 6) }, /* Central Standard */
2197 : { "CDT", tDAYZONE, -HOUR ( 6) }, /* Central Daylight */
2198 : { "MST", tZONE, -HOUR ( 7) }, /* Mountain Standard */
2199 : { "MDT", tDAYZONE, -HOUR ( 7) }, /* Mountain Daylight */
2200 : { "PST", tZONE, -HOUR ( 8) }, /* Pacific Standard */
2201 : { "PDT", tDAYZONE, -HOUR ( 8) }, /* Pacific Daylight */
2202 : { "AKST", tZONE, -HOUR ( 9) }, /* Alaska Standard */
2203 : { "AKDT", tDAYZONE, -HOUR ( 9) }, /* Alaska Daylight */
2204 : { "HST", tZONE, -HOUR (10) }, /* Hawaii Standard */
2205 : { "HAST", tZONE, -HOUR (10) }, /* Hawaii-Aleutian Standard */
2206 : { "HADT", tDAYZONE, -HOUR (10) }, /* Hawaii-Aleutian Daylight */
2207 : { "SST", tZONE, -HOUR (12) }, /* Samoa Standard */
2208 : { "WAT", tZONE, HOUR ( 1) }, /* West Africa */
2209 : { "CET", tZONE, HOUR ( 1) }, /* Central European */
2210 : { "CEST", tDAYZONE, HOUR ( 1) }, /* Central European Summer */
2211 : { "MET", tZONE, HOUR ( 1) }, /* Middle European */
2212 : { "MEZ", tZONE, HOUR ( 1) }, /* Middle European */
2213 : { "MEST", tDAYZONE, HOUR ( 1) }, /* Middle European Summer */
2214 : { "MESZ", tDAYZONE, HOUR ( 1) }, /* Middle European Summer */
2215 : { "EET", tZONE, HOUR ( 2) }, /* Eastern European */
2216 : { "EEST", tDAYZONE, HOUR ( 2) }, /* Eastern European Summer */
2217 : { "CAT", tZONE, HOUR ( 2) }, /* Central Africa */
2218 : { "SAST", tZONE, HOUR ( 2) }, /* South Africa Standard */
2219 : { "EAT", tZONE, HOUR ( 3) }, /* East Africa */
2220 : { "MSK", tZONE, HOUR ( 3) }, /* Moscow */
2221 : { "MSD", tDAYZONE, HOUR ( 3) }, /* Moscow Daylight */
2222 : { "IST", tZONE, (HOUR ( 5) + 30) }, /* India Standard */
2223 : { "SGT", tZONE, HOUR ( 8) }, /* Singapore */
2224 : { "KST", tZONE, HOUR ( 9) }, /* Korea Standard */
2225 : { "JST", tZONE, HOUR ( 9) }, /* Japan Standard */
2226 : { "GST", tZONE, HOUR (10) }, /* Guam Standard */
2227 : { "NZST", tZONE, HOUR (12) }, /* New Zealand Standard */
2228 : { "NZDT", tDAYZONE, HOUR (12) }, /* New Zealand Daylight */
2229 : { 0, 0, 0 }
2230 : };
2231 :
2232 : /* Military time zone table. */
2233 : static table const military_table[] =
2234 : {
2235 : { "A", tZONE, -HOUR ( 1) },
2236 : { "B", tZONE, -HOUR ( 2) },
2237 : { "C", tZONE, -HOUR ( 3) },
2238 : { "D", tZONE, -HOUR ( 4) },
2239 : { "E", tZONE, -HOUR ( 5) },
2240 : { "F", tZONE, -HOUR ( 6) },
2241 : { "G", tZONE, -HOUR ( 7) },
2242 : { "H", tZONE, -HOUR ( 8) },
2243 : { "I", tZONE, -HOUR ( 9) },
2244 : { "K", tZONE, -HOUR (10) },
2245 : { "L", tZONE, -HOUR (11) },
2246 : { "M", tZONE, -HOUR (12) },
2247 : { "N", tZONE, HOUR ( 1) },
2248 : { "O", tZONE, HOUR ( 2) },
2249 : { "P", tZONE, HOUR ( 3) },
2250 : { "Q", tZONE, HOUR ( 4) },
2251 : { "R", tZONE, HOUR ( 5) },
2252 : { "S", tZONE, HOUR ( 6) },
2253 : { "T", tZONE, HOUR ( 7) },
2254 : { "U", tZONE, HOUR ( 8) },
2255 : { "V", tZONE, HOUR ( 9) },
2256 : { "W", tZONE, HOUR (10) },
2257 : { "X", tZONE, HOUR (11) },
2258 : { "Y", tZONE, HOUR (12) },
2259 : { "Z", tZONE, HOUR ( 0) },
2260 : { 0, 0, 0 }
2261 : };
2262 :
2263 :
2264 :
2265 : static int
2266 : to_hour (int hours, int meridian)
2267 : {
2268 : switch (meridian)
2269 : {
2270 : case MER24:
2271 : return 0 <= hours && hours < 24 ? hours : -1;
2272 : case MERam:
2273 : return 0 < hours && hours < 12 ? hours : hours == 12 ? 0 : -1;
2274 : case MERpm:
2275 : return 0 < hours && hours < 12 ? hours + 12 : hours == 12 ? 12 : -1;
2276 : default:
2277 : abort ();
2278 : }
2279 : /* NOTREACHED */
2280 : return 0;
2281 : }
2282 :
2283 : static int
2284 : to_year (textint textyear)
2285 : {
2286 : int year = textyear.value;
2287 :
2288 : if (year < 0)
2289 : year = -year;
2290 :
2291 : /* XPG4 suggests that years 00-68 map to 2000-2068, and
2292 : years 69-99 map to 1969-1999. */
2293 : if (textyear.digits == 2)
2294 : year += year < 69 ? 2000 : 1900;
2295 :
2296 : return year;
2297 : }
2298 :
2299 : static table const *
2300 : lookup_zone (struct parser_control const *pc, char const *name)
2301 : {
2302 : table const *tp;
2303 :
2304 : /* Try local zone abbreviations first; they're more likely to be right. */
2305 : for (tp = pc->local_time_zone_table; tp->name; tp++)
2306 : if (strcmp (name, tp->name) == 0)
2307 : return tp;
2308 :
2309 : for (tp = time_zone_table; tp->name; tp++)
2310 : if (strcmp (name, tp->name) == 0)
2311 : return tp;
2312 :
2313 : return 0;
2314 : }
2315 :
2316 : #if ! HAVE_TM_GMTOFF
2317 : /* Yield the difference between *A and *B,
2318 : measured in seconds, ignoring leap seconds.
2319 : The body of this function is taken directly from the GNU C Library;
2320 : see src/strftime.c. */
2321 : static int
2322 : tm_diff (struct tm const *a, struct tm const *b)
2323 : {
2324 : /* Compute intervening leap days correctly even if year is negative.
2325 : Take care to avoid int overflow in leap day calculations,
2326 : but it's OK to assume that A and B are close to each other. */
2327 : int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
2328 : int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
2329 : int a100 = a4 / 25 - (a4 % 25 < 0);
2330 : int b100 = b4 / 25 - (b4 % 25 < 0);
2331 : int a400 = a100 >> 2;
2332 : int b400 = b100 >> 2;
2333 : int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
2334 : int years = a->tm_year - b->tm_year;
2335 : int days = (365 * years + intervening_leap_days
2336 : + (a->tm_yday - b->tm_yday));
2337 : return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
2338 : + (a->tm_min - b->tm_min))
2339 : + (a->tm_sec - b->tm_sec));
2340 : }
2341 : #endif /* ! HAVE_TM_GMTOFF */
2342 :
2343 : static table const *
2344 : lookup_word (struct parser_control const *pc, char *word)
2345 : {
2346 : char *p;
2347 : char *q;
2348 : size_t wordlen;
2349 : table const *tp;
2350 : int i;
2351 : int abbrev;
2352 :
2353 : /* Make it uppercase. */
2354 : for (p = word; *p; p++)
2355 : if (ISLOWER ((unsigned char) *p))
2356 : *p = toupper ((unsigned char) *p);
2357 :
2358 : for (tp = meridian_table; tp->name; tp++)
2359 : if (strcmp (word, tp->name) == 0)
2360 : return tp;
2361 :
2362 : /* See if we have an abbreviation for a month. */
2363 : wordlen = strlen (word);
2364 : abbrev = wordlen == 3 || (wordlen == 4 && word[3] == '.');
2365 :
2366 : for (tp = month_and_day_table; tp->name; tp++)
2367 : if ((abbrev ? strncmp (word, tp->name, 3) : strcmp (word, tp->name)) == 0)
2368 : return tp;
2369 :
2370 : if ((tp = lookup_zone (pc, word)))
2371 : return tp;
2372 :
2373 : if (strcmp (word, dst_table[0].name) == 0)
2374 : return dst_table;
2375 :
2376 : for (tp = time_units_table; tp->name; tp++)
2377 : if (strcmp (word, tp->name) == 0)
2378 : return tp;
2379 :
2380 : /* Strip off any plural and try the units table again. */
2381 : if (word[wordlen - 1] == 'S')
2382 : {
2383 : word[wordlen - 1] = '\0';
2384 : for (tp = time_units_table; tp->name; tp++)
2385 : if (strcmp (word, tp->name) == 0)
2386 : return tp;
2387 : word[wordlen - 1] = 'S'; /* For "this" in relative_time_table. */
2388 : }
2389 :
2390 : for (tp = relative_time_table; tp->name; tp++)
2391 : if (strcmp (word, tp->name) == 0)
2392 : return tp;
2393 :
2394 : /* Military time zones. */
2395 : if (wordlen == 1)
2396 : for (tp = military_table; tp->name; tp++)
2397 : if (word[0] == tp->name[0])
2398 : return tp;
2399 :
2400 : /* Drop out any periods and try the time zone table again. */
2401 : for (i = 0, p = q = word; (*p = *q); q++)
2402 : if (*q == '.')
2403 : i = 1;
2404 : else
2405 : p++;
2406 : if (i && (tp = lookup_zone (pc, word)))
2407 : return tp;
2408 :
2409 : return 0;
2410 : }
2411 :
2412 : static int
2413 : yylex (YYSTYPE *lvalp, struct parser_control *pc)
2414 : {
2415 : unsigned char c;
2416 : size_t count;
2417 :
2418 : for (;;)
2419 : {
2420 : while (c = *pc->input, ISSPACE (c))
2421 : pc->input++;
2422 :
2423 : if (ISDIGIT (c) || c == '-' || c == '+')
2424 : {
2425 : char const *p;
2426 : int sign;
2427 : int value;
2428 : if (c == '-' || c == '+')
2429 : {
2430 : sign = c == '-' ? -1 : 1;
2431 : c = *++pc->input;
2432 : if (! ISDIGIT (c))
2433 : /* skip the '-' sign */
2434 : continue;
2435 : }
2436 : else
2437 : sign = 0;
2438 : p = pc->input;
2439 : value = 0;
2440 : do
2441 : {
2442 : value = 10 * value + c - '0';
2443 : c = *++p;
2444 : }
2445 : while (ISDIGIT (c));
2446 : lvalp->textintval.value = sign < 0 ? -value : value;
2447 : lvalp->textintval.digits = p - pc->input;
2448 : pc->input = p;
2449 : return sign ? tSNUMBER : tUNUMBER;
2450 : }
2451 :
2452 : if (ISALPHA (c))
2453 : {
2454 : char buff[20];
2455 : size_t i = 0;
2456 : table const *tp;
2457 :
2458 : do
2459 : {
2460 : if (i < 20)
2461 : buff[i++] = c;
2462 : c = *++pc->input;
2463 : }
2464 : while (ISALPHA (c) || c == '.');
2465 :
2466 : buff[i] = '\0';
2467 : tp = lookup_word (pc, buff);
2468 : if (! tp)
2469 : return '?';
2470 : lvalp->intval = tp->value;
2471 : return tp->type;
2472 : }
2473 :
2474 : if (c != '(')
2475 : return *pc->input++;
2476 : count = 0;
2477 : do
2478 : {
2479 : c = *pc->input++;
2480 : if (c == '\0')
2481 : return c;
2482 : if (c == '(')
2483 : count++;
2484 : else if (c == ')')
2485 : count--;
2486 : }
2487 : while (count > 0);
2488 : }
2489 : }
2490 :
2491 : /* Do nothing if the parser reports an error. */
2492 : static int
2493 : yyerror (struct parser_control *pc ATTRIBUTE_UNUSED, const char *s ATTRIBUTE_UNUSED)
2494 : {
2495 : return 0;
2496 : }
2497 :
2498 : /* Parse a date/time string P. Return the corresponding time_t value,
2499 : or (time_t) -1 if there is an error. P can be an incomplete or
2500 : relative time specification; if so, use *NOW as the basis for the
2501 : returned time. */
2502 : time_t
2503 : get_date (const char *p, const time_t *now)
2504 : {
2505 : time_t Start = now ? *now : time (0);
2506 : struct tm *tmp = localtime (&Start);
2507 : struct tm tm;
2508 : struct tm tm0;
2509 : struct parser_control pc;
2510 :
2511 : if (! tmp)
2512 : return -1;
2513 :
2514 : pc.input = p;
2515 : pc.year.value = tmp->tm_year + TM_YEAR_BASE;
2516 : pc.year.digits = 4;
2517 : pc.month = tmp->tm_mon + 1;
2518 : pc.day = tmp->tm_mday;
2519 : pc.hour = tmp->tm_hour;
2520 : pc.minutes = tmp->tm_min;
2521 : pc.seconds = tmp->tm_sec;
2522 : tm.tm_isdst = tmp->tm_isdst;
2523 :
2524 : pc.meridian = MER24;
2525 : pc.rel_seconds = 0;
2526 : pc.rel_minutes = 0;
2527 : pc.rel_hour = 0;
2528 : pc.rel_day = 0;
2529 : pc.rel_month = 0;
2530 : pc.rel_year = 0;
2531 : pc.dates_seen = 0;
2532 : pc.days_seen = 0;
2533 : pc.rels_seen = 0;
2534 : pc.times_seen = 0;
2535 : pc.local_zones_seen = 0;
2536 : pc.zones_seen = 0;
2537 :
2538 : #ifdef HAVE_STRUCT_TM_TM_ZONE
2539 : pc.local_time_zone_table[0].name = tmp->tm_zone;
2540 : pc.local_time_zone_table[0].type = tLOCAL_ZONE;
2541 : pc.local_time_zone_table[0].value = tmp->tm_isdst;
2542 : pc.local_time_zone_table[1].name = 0;
2543 :
2544 : /* Probe the names used in the next three calendar quarters, looking
2545 : for a tm_isdst different from the one we already have. */
2546 : {
2547 : int quarter;
2548 : for (quarter = 1; quarter <= 3; quarter++)
2549 : {
2550 : time_t probe = Start + quarter * (90 * 24 * 60 * 60);
2551 : struct tm *probe_tm = localtime (&probe);
2552 : if (probe_tm && probe_tm->tm_zone
2553 : && probe_tm->tm_isdst != pc.local_time_zone_table[0].value)
2554 : {
2555 : {
2556 : pc.local_time_zone_table[1].name = probe_tm->tm_zone;
2557 : pc.local_time_zone_table[1].type = tLOCAL_ZONE;
2558 : pc.local_time_zone_table[1].value = probe_tm->tm_isdst;
2559 : pc.local_time_zone_table[2].name = 0;
2560 : }
2561 : break;
2562 : }
2563 : }
2564 : }
2565 : #else
2566 : #ifdef HAVE_TZNAME
2567 : {
2568 : # ifndef tzname
2569 : extern char *tzname[];
2570 : # endif
2571 : int i;
2572 : for (i = 0; i < 2; i++)
2573 : {
2574 : pc.local_time_zone_table[i].name = tzname[i];
2575 : pc.local_time_zone_table[i].type = tLOCAL_ZONE;
2576 : pc.local_time_zone_table[i].value = i;
2577 : }
2578 : pc.local_time_zone_table[i].name = 0;
2579 : }
2580 : #else
2581 : pc.local_time_zone_table[0].name = 0;
2582 : #endif
2583 : #endif
2584 :
2585 : if (pc.local_time_zone_table[0].name && pc.local_time_zone_table[1].name
2586 : && ! strcmp (pc.local_time_zone_table[0].name,
2587 : pc.local_time_zone_table[1].name))
2588 : {
2589 : /* This locale uses the same abbrevation for standard and
2590 : daylight times. So if we see that abbreviation, we don't
2591 : know whether it's daylight time. */
2592 : pc.local_time_zone_table[0].value = -1;
2593 : pc.local_time_zone_table[1].name = 0;
2594 : }
2595 :
2596 : if (yyparse (&pc) != 0
2597 : || 1 < pc.times_seen || 1 < pc.dates_seen || 1 < pc.days_seen
2598 : || 1 < (pc.local_zones_seen + pc.zones_seen)
2599 : || (pc.local_zones_seen && 1 < pc.local_isdst))
2600 : return -1;
2601 :
2602 : tm.tm_year = to_year (pc.year) - TM_YEAR_BASE + pc.rel_year;
2603 : tm.tm_mon = pc.month - 1 + pc.rel_month;
2604 : tm.tm_mday = pc.day + pc.rel_day;
2605 : if (pc.times_seen || (pc.rels_seen && ! pc.dates_seen && ! pc.days_seen))
2606 : {
2607 : tm.tm_hour = to_hour (pc.hour, pc.meridian);
2608 : if (tm.tm_hour < 0)
2609 : return -1;
2610 : tm.tm_min = pc.minutes;
2611 : tm.tm_sec = pc.seconds;
2612 : }
2613 : else
2614 : {
2615 : tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
2616 : }
2617 :
2618 : /* Let mktime deduce tm_isdst if we have an absolute time stamp,
2619 : or if the relative time stamp mentions days, months, or years. */
2620 : if (pc.dates_seen | pc.days_seen | pc.times_seen | pc.rel_day
2621 : | pc.rel_month | pc.rel_year)
2622 : tm.tm_isdst = -1;
2623 :
2624 : /* But if the input explicitly specifies local time with or without
2625 : DST, give mktime that information. */
2626 : if (pc.local_zones_seen)
2627 : tm.tm_isdst = pc.local_isdst;
2628 :
2629 : tm0 = tm;
2630 :
2631 : Start = mktime (&tm);
2632 :
2633 : if (Start == (time_t) -1)
2634 : {
2635 :
2636 : /* Guard against falsely reporting errors near the time_t boundaries
2637 : when parsing times in other time zones. For example, if the min
2638 : time_t value is 1970-01-01 00:00:00 UTC and we are 8 hours ahead
2639 : of UTC, then the min localtime value is 1970-01-01 08:00:00; if
2640 : we apply mktime to 1970-01-01 00:00:00 we will get an error, so
2641 : we apply mktime to 1970-01-02 08:00:00 instead and adjust the time
2642 : zone by 24 hours to compensate. This algorithm assumes that
2643 : there is no DST transition within a day of the time_t boundaries. */
2644 : if (pc.zones_seen)
2645 : {
2646 : tm = tm0;
2647 : if (tm.tm_year <= EPOCH_YEAR - TM_YEAR_BASE)
2648 : {
2649 : tm.tm_mday++;
2650 : pc.time_zone += 24 * 60;
2651 : }
2652 : else
2653 : {
2654 : tm.tm_mday--;
2655 : pc.time_zone -= 24 * 60;
2656 : }
2657 : Start = mktime (&tm);
2658 : }
2659 :
2660 : if (Start == (time_t) -1)
2661 : return Start;
2662 : }
2663 :
2664 : if (pc.days_seen && ! pc.dates_seen)
2665 : {
2666 : tm.tm_mday += ((pc.day_number - tm.tm_wday + 7) % 7
2667 : + 7 * (pc.day_ordinal - (0 < pc.day_ordinal)));
2668 : tm.tm_isdst = -1;
2669 : Start = mktime (&tm);
2670 : if (Start == (time_t) -1)
2671 : return Start;
2672 : }
2673 :
2674 : if (pc.zones_seen)
2675 : {
2676 : int delta = pc.time_zone * 60;
2677 : #ifdef HAVE_TM_GMTOFF
2678 : delta -= tm.tm_gmtoff;
2679 : #else
2680 : struct tm *gmt = gmtime (&Start);
2681 : if (! gmt)
2682 : return -1;
2683 : delta -= tm_diff (&tm, gmt);
2684 : #endif
2685 : if ((Start < Start - delta) != (delta < 0))
2686 : return -1; /* time_t overflow */
2687 : Start -= delta;
2688 : }
2689 :
2690 : /* Add relative hours, minutes, and seconds. Ignore leap seconds;
2691 : i.e. "+ 10 minutes" means 600 seconds, even if one of them is a
2692 : leap second. Typically this is not what the user wants, but it's
2693 : too hard to do it the other way, because the time zone indicator
2694 : must be applied before relative times, and if mktime is applied
2695 : again the time zone will be lost. */
2696 : {
2697 : time_t t0 = Start;
2698 : long d1 = 60 * 60 * (long) pc.rel_hour;
2699 : time_t t1 = t0 + d1;
2700 : long d2 = 60 * (long) pc.rel_minutes;
2701 : time_t t2 = t1 + d2;
2702 : int d3 = pc.rel_seconds;
2703 : time_t t3 = t2 + d3;
2704 : if ((d1 / (60 * 60) ^ pc.rel_hour)
2705 : | (d2 / 60 ^ pc.rel_minutes)
2706 : | ((t0 + d1 < t0) ^ (d1 < 0))
2707 : | ((t1 + d2 < t1) ^ (d2 < 0))
2708 : | ((t2 + d3 < t2) ^ (d3 < 0)))
2709 : return -1;
2710 : Start = t3;
2711 : }
2712 :
2713 : return Start;
2714 : }
2715 :
2716 : #if TEST
2717 :
2718 : #include <stdio.h>
2719 :
2720 : int
2721 : main (int ac, char **av)
2722 : {
2723 : char buff[BUFSIZ];
2724 : time_t d;
2725 :
2726 : printf ("Enter date, or blank line to exit.\n\t> ");
2727 : fflush (stdout);
2728 :
2729 : buff[BUFSIZ - 1] = 0;
2730 : while (fgets (buff, BUFSIZ - 1, stdin) && buff[0])
2731 : {
2732 : d = get_date (buff, 0);
2733 : if (d == (time_t) -1)
2734 : printf ("Bad format - couldn't convert.\n");
2735 : else
2736 : printf ("%s", ctime (&d));
2737 : printf ("\t> ");
2738 : fflush (stdout);
2739 : }
2740 : return 0;
2741 : }
2742 : #endif /* defined TEST */
|
