2018-03-23 11:30:27 +03:00
/* A Bison parser, made by GNU Bison 3.0.4. */
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
/* Bison implementation for Yacc-like parsers in C
2008-12-16 09:34:07 +03:00
2018-03-23 11:30:27 +03:00
Copyright ( C ) 1984 , 1989 - 1990 , 2000 - 2015 Free Software Foundation , Inc .
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
This program is free software : you can redistribute it and / or modify
2003-08-12 08:35:47 +04:00
it under the terms of the GNU General Public License as published by
2018-03-23 11:30:27 +03:00
the Free Software Foundation , either version 3 of the License , or
( at your option ) any later version .
2003-08-12 08:35:47 +04:00
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
You should have received a copy of the GNU General Public License
2018-03-23 11:30:27 +03:00
along with this program . If not , see < http : //www.gnu.org/licenses/>. */
2008-12-16 09:34:07 +03:00
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice , so long as that work isn ' t itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton . Alternatively , if you modify or redistribute
the parser skeleton itself , you may ( at your option ) remove this
special exception , which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception .
This special exception was added by the Free Software Foundation in
version 2.2 of Bison . */
/* C LALR(1) parser skeleton written by Richard Stallman, by
simplifying the original so - called " semantic " parser . */
2003-08-12 08:35:47 +04:00
/* All symbols defined below should begin with yy or YY, to avoid
infringing on user name space . This should be done even for local
variables , as they might otherwise be expanded by user macros .
There are some unavoidable exceptions within include files to
define necessary library symbols ; they are noted " INFRINGES ON
USER NAME SPACE " below. */
/* Identify Bison output. */
# define YYBISON 1
2008-12-16 09:34:07 +03:00
/* Bison version. */
2018-03-23 11:30:27 +03:00
# define YYBISON_VERSION "3.0.4"
2008-12-16 09:34:07 +03:00
2003-08-12 08:35:47 +04:00
/* Skeleton name. */
# define YYSKELETON_NAME "yacc.c"
/* Pure parsers. */
# define YYPURE 1
2018-03-23 11:30:27 +03:00
/* Push parsers. */
# define YYPUSH 0
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
/* Pull parsers. */
# define YYPULL 1
2003-08-12 08:35:47 +04:00
/* Copy the first part of user declarations. */
2018-03-23 11:30:27 +03:00
# line 1 "source3 / modules / getdate.y" /* yacc.c:339 */
2003-08-12 08:35:47 +04:00
/* Parse a string into an internal time stamp.
Copyright ( C ) 1999 , 2000 , 2002 Free Software Foundation , Inc .
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation ; either version 2 , or ( at your option )
any later version .
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
You should have received a copy of the GNU General Public License
2007-07-10 07:42:26 +04:00
along with this program ; if not , see < http : //www.gnu.org/licenses/>. */
2003-08-12 08:35:47 +04:00
/* Originally written by Steven M. Bellovin <smb@research.att.com> while
at the University of North Carolina at Chapel Hill . Later tweaked by
a couple of people on Usenet . Completely overhauled by Rich $ alz
< rsalz @ bbn . com > and Jim Berets < jberets @ bbn . com > in August , 1990.
Modified by Paul Eggert < eggert @ twinsun . com > in August 1999 to do
the right thing about local DST . Unlike previous versions , this
version is reentrant . */
2005-05-31 17:46:45 +04:00
# ifdef HAVE_CONFIG_H
# include <config.h>
# ifdef HAVE_ALLOCA_H
# include <alloca.h>
# endif
2003-08-12 08:35:47 +04:00
# endif
/* Since the code of getdate.y is not included in the Emacs executable
itself , there is no need to # define static in this file . Even if
the code were included in the Emacs executable , it probably
wouldn ' t do any harm to # undef it here ; this will only cause
problems if we try to write to a static variable , which I don ' t
think this code needs to do . */
# ifdef emacs
# undef static
# endif
# include <ctype.h>
2006-02-08 07:11:08 +03:00
# include <string.h>
2003-08-12 08:35:47 +04:00
# if HAVE_STDLIB_H
# include <stdlib.h> /* for `free'; used by Bison 1.27 */
# endif
# if STDC_HEADERS || (! defined isascii && ! HAVE_ISASCII)
# define IN_CTYPE_DOMAIN(c) 1
# else
# define IN_CTYPE_DOMAIN(c) isascii (c)
# endif
# define ISSPACE(c) (IN_CTYPE_DOMAIN (c) && isspace (c))
# define ISALPHA(c) (IN_CTYPE_DOMAIN (c) && isalpha (c))
# define ISLOWER(c) (IN_CTYPE_DOMAIN (c) && islower (c))
# define ISDIGIT_LOCALE(c) (IN_CTYPE_DOMAIN (c) && isdigit (c))
/* ISDIGIT differs from ISDIGIT_LOCALE, as follows:
- Its arg may be any int or unsigned int ; it need not be an unsigned char .
- It ' s guaranteed to evaluate its argument exactly once .
- It ' s typically faster .
POSIX says that only ' 0 ' through ' 9 ' are digits . Prefer ISDIGIT to
ISDIGIT_LOCALE unless it ' s important to use the locale ' s definition
of ` digit ' even when the host does not conform to POSIX . */
# define ISDIGIT(c) ((unsigned) (c) - '0' <= 9)
# if STDC_HEADERS || HAVE_STRING_H
# include <string.h>
# endif
2016-03-23 05:27:45 +03:00
# ifndef HAVE___ATTRIBUTE__
2003-08-12 08:35:47 +04:00
# define __attribute__(x)
# endif
# ifndef ATTRIBUTE_UNUSED
# define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
# endif
# define EPOCH_YEAR 1970
# define TM_YEAR_BASE 1900
# define HOUR(x) ((x) * 60)
/* An integer value, and the number of digits in its textual
representation . */
typedef struct
{
int value ;
int digits ;
} textint ;
/* An entry in the lexical lookup table. */
typedef struct
{
char const * name ;
int type ;
int value ;
} table ;
/* Meridian: am, pm, or 24-hour style. */
enum { MERam , MERpm , MER24 } ;
/* Information passed to and from the parser. */
2018-03-23 11:30:27 +03:00
struct parser_control
2003-08-12 08:35:47 +04:00
{
/* The input string remaining to be parsed. */
const char * input ;
/* N, if this is the Nth Tuesday. */
int day_ordinal ;
/* Day of week; Sunday is 0. */
int day_number ;
/* tm_isdst flag for the local zone. */
int local_isdst ;
/* Time zone, in minutes east of UTC. */
int time_zone ;
/* Style used for time. */
int meridian ;
/* Gregorian year, month, day, hour, minutes, and seconds. */
textint year ;
int month ;
int day ;
int hour ;
int minutes ;
int seconds ;
/* Relative year, month, day, hour, minutes, and seconds. */
int rel_year ;
int rel_month ;
int rel_day ;
int rel_hour ;
int rel_minutes ;
int rel_seconds ;
/* Counts of nonterminals of various flavors parsed so far. */
int dates_seen ;
int days_seen ;
int local_zones_seen ;
int rels_seen ;
int times_seen ;
int zones_seen ;
/* Table of local time zone abbrevations, terminated by a null entry. */
table local_time_zone_table [ 3 ] ;
2018-03-23 11:30:27 +03:00
} ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
# line 223 "source3 / modules / getdate.c" /* yacc.c:339 */
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
# ifndef YY_NULLPTR
# if defined __cplusplus && 201103L <= __cplusplus
# define YY_NULLPTR nullptr
# else
# define YY_NULLPTR 0
# endif
# endif
2003-08-12 08:35:47 +04:00
/* Enabling verbose error messages. */
# ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
# else
# define YYERROR_VERBOSE 0
# endif
2018-03-23 11:30:27 +03:00
/* Debug traces. */
# ifndef YYDEBUG
# define YYDEBUG 0
# endif
# if YYDEBUG
extern int yydebug ;
# endif
/* Token type. */
# ifndef YYTOKENTYPE
# define YYTOKENTYPE
enum yytokentype
{
tAGO = 258 ,
tDST = 259 ,
tDAY = 260 ,
tDAY_UNIT = 261 ,
tDAYZONE = 262 ,
tHOUR_UNIT = 263 ,
tLOCAL_ZONE = 264 ,
tMERIDIAN = 265 ,
tMINUTE_UNIT = 266 ,
tMONTH = 267 ,
tMONTH_UNIT = 268 ,
tSEC_UNIT = 269 ,
tYEAR_UNIT = 270 ,
tZONE = 271 ,
tSNUMBER = 272 ,
tUNUMBER = 273
} ;
2008-12-16 09:34:07 +03:00
# endif
2018-03-23 11:30:27 +03:00
/* Value type. */
2008-12-16 09:34:07 +03:00
# if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
2018-03-23 11:30:27 +03:00
union YYSTYPE
2008-12-16 09:34:07 +03:00
{
2018-03-23 11:30:27 +03:00
# line 168 "source3 / modules / getdate.y" /* yacc.c:355 */
2003-08-12 08:35:47 +04:00
int intval ;
textint textintval ;
2018-03-23 11:30:27 +03:00
# line 284 "source3 / modules / getdate.c" /* yacc.c:355 */
} ;
typedef union YYSTYPE YYSTYPE ;
2003-08-12 08:35:47 +04:00
# define YYSTYPE_IS_TRIVIAL 1
2018-03-23 11:30:27 +03:00
# define YYSTYPE_IS_DECLARED 1
2003-08-12 08:35:47 +04:00
# endif
2018-03-23 11:30:27 +03:00
int yyparse ( struct parser_control * pc ) ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
/* Copy the second part of user declarations. */
# line 173 "source3 / modules / getdate.y" /* yacc.c:358 */
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
static int yyerror ( struct parser_control * , const char * ) ;
static int yylex ( YYSTYPE * , struct parser_control * ) ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
# line 306 "source3 / modules / getdate.c" /* yacc.c:358 */
2008-12-16 09:34:07 +03:00
# ifdef short
# undef short
# endif
# ifdef YYTYPE_UINT8
typedef YYTYPE_UINT8 yytype_uint8 ;
# else
typedef unsigned char yytype_uint8 ;
# endif
# ifdef YYTYPE_INT8
typedef YYTYPE_INT8 yytype_int8 ;
# else
2018-03-23 11:30:27 +03:00
typedef signed char yytype_int8 ;
2008-12-16 09:34:07 +03:00
# endif
# ifdef YYTYPE_UINT16
typedef YYTYPE_UINT16 yytype_uint16 ;
# else
typedef unsigned short int yytype_uint16 ;
# endif
# ifdef YYTYPE_INT16
typedef YYTYPE_INT16 yytype_int16 ;
# else
typedef short int yytype_int16 ;
# endif
# ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
# define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
# define YYSIZE_T size_t
2018-03-23 11:30:27 +03:00
# elif ! defined YYSIZE_T
2008-12-16 09:34:07 +03:00
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
2003-08-12 08:35:47 +04:00
# else
2008-12-16 09:34:07 +03:00
# define YYSIZE_T unsigned int
# endif
# endif
# define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
# ifndef YY_
2018-03-23 11:30:27 +03:00
# if defined YYENABLE_NLS && YYENABLE_NLS
2008-12-16 09:34:07 +03:00
# if ENABLE_NLS
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
2018-03-23 11:30:27 +03:00
# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
2008-12-16 09:34:07 +03:00
# endif
# endif
# ifndef YY_
2018-03-23 11:30:27 +03:00
# define YY_(Msgid) Msgid
# endif
# endif
# ifndef YY_ATTRIBUTE
# if (defined __GNUC__ \
& & ( 2 < __GNUC__ | | ( __GNUC__ = = 2 & & 96 < = __GNUC_MINOR__ ) ) ) \
| | defined __SUNPRO_C & & 0x5110 < = __SUNPRO_C
# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
# else
# define YY_ATTRIBUTE(Spec) /* empty */
# endif
# endif
# ifndef YY_ATTRIBUTE_PURE
# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
# endif
# ifndef YY_ATTRIBUTE_UNUSED
# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
# endif
# if !defined _Noreturn \
& & ( ! defined __STDC_VERSION__ | | __STDC_VERSION__ < 201112 )
# if defined _MSC_VER && 1200 <= _MSC_VER
# define _Noreturn __declspec (noreturn)
# else
# define _Noreturn YY_ATTRIBUTE ((__noreturn__))
2008-12-16 09:34:07 +03:00
# endif
# endif
/* Suppress unused-variable warnings by "using" E. */
# if ! defined lint || defined __GNUC__
2018-03-23 11:30:27 +03:00
# define YYUSE(E) ((void) (E))
2008-12-16 09:34:07 +03:00
# else
2018-03-23 11:30:27 +03:00
# define YYUSE(E) /* empty */
2008-12-16 09:34:07 +03:00
# endif
2018-03-23 11:30:27 +03:00
# if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
/* Suppress an incorrect diagnostic about yylval being uninitialized. */
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
_Pragma ( " GCC diagnostic push " ) \
_Pragma ( " GCC diagnostic ignored \" -Wuninitialized \" " ) \
_Pragma ( " GCC diagnostic ignored \" -Wmaybe-uninitialized \" " )
# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
_Pragma ( " GCC diagnostic pop " )
2008-12-16 09:34:07 +03:00
# else
2018-03-23 11:30:27 +03:00
# define YY_INITIAL_VALUE(Value) Value
2008-12-16 09:34:07 +03:00
# endif
2018-03-23 11:30:27 +03:00
# ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
# endif
# ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */
2008-12-16 09:34:07 +03:00
# endif
2018-03-23 11:30:27 +03:00
2008-12-16 09:34:07 +03:00
# if ! defined yyoverflow || YYERROR_VERBOSE
/* The parser invokes alloca or malloc; define the necessary symbols. */
# ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA
# ifdef __GNUC__
# define YYSTACK_ALLOC __builtin_alloca
# elif defined __BUILTIN_VA_ARG_INCR
# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
# elif defined _AIX
# define YYSTACK_ALLOC __alloca
# elif defined _MSC_VER
# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
# define alloca _alloca
2003-08-12 08:35:47 +04:00
# else
2008-12-16 09:34:07 +03:00
# define YYSTACK_ALLOC alloca
2018-03-23 11:30:27 +03:00
# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
2008-12-16 09:34:07 +03:00
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
2018-03-23 11:30:27 +03:00
/* Use EXIT_SUCCESS as a witness for stdlib.h. */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
2008-12-16 09:34:07 +03:00
# endif
2003-08-12 08:35:47 +04:00
# endif
# endif
# endif
# endif
# ifdef YYSTACK_ALLOC
2018-03-23 11:30:27 +03:00
/* Pacify GCC's 'empty if-body' warning. */
# define YYSTACK_FREE(Ptr) do { /* empty */ ; } while (0)
2008-12-16 09:34:07 +03:00
# ifndef YYSTACK_ALLOC_MAXIMUM
/* The OS might guarantee only one guard page at the bottom of the stack,
and a page size can be as small as 4096 bytes . So we cannot safely
invoke alloca ( N ) if N exceeds 4096. Use a slightly smaller number
to allow for a few compiler - allocated temporary stack slots . */
# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
# endif
2003-08-12 08:35:47 +04:00
# else
2008-12-16 09:34:07 +03:00
# define YYSTACK_ALLOC YYMALLOC
# define YYSTACK_FREE YYFREE
# ifndef YYSTACK_ALLOC_MAXIMUM
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
# endif
2018-03-23 11:30:27 +03:00
# if (defined __cplusplus && ! defined EXIT_SUCCESS \
2008-12-16 09:34:07 +03:00
& & ! ( ( defined YYMALLOC | | defined malloc ) \
2018-03-23 11:30:27 +03:00
& & ( defined YYFREE | | defined free ) ) )
2003-08-12 08:35:47 +04:00
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
2018-03-23 11:30:27 +03:00
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
2008-12-16 09:34:07 +03:00
# endif
# endif
# ifndef YYMALLOC
# define YYMALLOC malloc
2018-03-23 11:30:27 +03:00
# if ! defined malloc && ! defined EXIT_SUCCESS
2008-12-16 09:34:07 +03:00
void * malloc ( YYSIZE_T ) ; /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE free
2018-03-23 11:30:27 +03:00
# if ! defined free && ! defined EXIT_SUCCESS
2008-12-16 09:34:07 +03:00
void free ( void * ) ; /* INFRINGES ON USER NAME SPACE */
# endif
2003-08-12 08:35:47 +04:00
# endif
# endif
2008-12-16 09:34:07 +03:00
# endif /* ! defined yyoverflow || YYERROR_VERBOSE */
2003-08-12 08:35:47 +04:00
2008-12-16 09:34:07 +03:00
# if (! defined yyoverflow \
& & ( ! defined __cplusplus \
2018-03-23 11:30:27 +03:00
| | ( defined YYSTYPE_IS_TRIVIAL & & YYSTYPE_IS_TRIVIAL ) ) )
2003-08-12 08:35:47 +04:00
/* A type that is properly aligned for any stack member. */
union yyalloc
{
2018-03-23 11:30:27 +03:00
yytype_int16 yyss_alloc ;
YYSTYPE yyvs_alloc ;
} ;
2003-08-12 08:35:47 +04:00
/* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
/* The size of an array large to enough to hold all stacks, each with
N elements . */
# define YYSTACK_BYTES(N) \
2008-12-16 09:34:07 +03:00
( ( N ) * ( sizeof ( yytype_int16 ) + sizeof ( YYSTYPE ) ) \
2003-08-12 08:35:47 +04:00
+ YYSTACK_GAP_MAXIMUM )
2018-03-23 11:30:27 +03:00
# define YYCOPY_NEEDED 1
2003-08-12 08:35:47 +04:00
/* Relocate STACK from its old location to the new one. The
local variables YYSIZE and YYSTACKSIZE give the old and new number of
elements in the stack , and YYPTR gives the new location of the
stack . Advance YYPTR to a properly aligned location for the next
stack . */
2018-03-23 11:30:27 +03:00
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
YYSIZE_T yynewbytes ; \
YYCOPY ( & yyptr - > Stack_alloc , Stack , yysize ) ; \
Stack = & yyptr - > Stack_alloc ; \
yynewbytes = yystacksize * sizeof ( * Stack ) + YYSTACK_GAP_MAXIMUM ; \
yyptr + = yynewbytes / sizeof ( * yyptr ) ; \
} \
while ( 0 )
2003-08-12 08:35:47 +04:00
# endif
2018-03-23 11:30:27 +03:00
# if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from SRC to DST. The source and destination do
not overlap . */
# ifndef YYCOPY
# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(Dst, Src, Count) \
__builtin_memcpy ( Dst , Src , ( Count ) * sizeof ( * ( Src ) ) )
# else
# define YYCOPY(Dst, Src, Count) \
do \
{ \
YYSIZE_T yyi ; \
for ( yyi = 0 ; yyi < ( Count ) ; yyi + + ) \
( Dst ) [ yyi ] = ( Src ) [ yyi ] ; \
} \
while ( 0 )
# endif
# endif
# endif /* !YYCOPY_NEEDED */
2008-12-16 09:34:07 +03:00
/* YYFINAL -- State number of the termination state. */
2003-08-12 08:35:47 +04:00
# define YYFINAL 2
/* YYLAST -- Last index in YYTABLE. */
# define YYLAST 52
2008-12-16 09:34:07 +03:00
/* YYNTOKENS -- Number of terminals. */
2003-08-12 08:35:47 +04:00
# define YYNTOKENS 22
2008-12-16 09:34:07 +03:00
/* YYNNTS -- Number of nonterminals. */
2003-08-12 08:35:47 +04:00
# define YYNNTS 12
2008-12-16 09:34:07 +03:00
/* YYNRULES -- Number of rules. */
2003-08-12 08:35:47 +04:00
# define YYNRULES 54
2018-03-23 11:30:27 +03:00
/* YYNSTATES -- Number of states. */
2003-08-12 08:35:47 +04:00
# define YYNSTATES 64
2018-03-23 11:30:27 +03:00
/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
by yylex , with out - of - bounds checking . */
2003-08-12 08:35:47 +04:00
# define YYUNDEFTOK 2
# define YYMAXUTOK 273
2018-03-23 11:30:27 +03:00
# define YYTRANSLATE(YYX) \
2003-08-12 08:35:47 +04:00
( ( unsigned int ) ( YYX ) < = YYMAXUTOK ? yytranslate [ YYX ] : YYUNDEFTOK )
2018-03-23 11:30:27 +03:00
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
as returned by yylex , without out - of - bounds checking . */
2008-12-16 09:34:07 +03:00
static const yytype_uint8 yytranslate [ ] =
2003-08-12 08:35:47 +04:00
{
0 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 20 , 2 , 2 , 21 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 19 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 , 1 , 2 , 3 , 4 ,
5 , 6 , 7 , 8 , 9 , 10 , 11 , 12 , 13 , 14 ,
15 , 16 , 17 , 18
} ;
# if YYDEBUG
2018-03-23 11:30:27 +03:00
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
2008-12-16 09:34:07 +03:00
static const yytype_uint16 yyrline [ ] =
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
0 , 191 , 191 , 193 , 197 , 199 , 201 , 203 , 205 , 207 ,
209 , 213 , 220 , 227 , 235 , 242 , 254 , 256 , 261 , 263 ,
265 , 270 , 275 , 280 , 288 , 293 , 313 , 320 , 328 , 333 ,
339 , 344 , 353 , 362 , 366 , 368 , 370 , 372 , 374 , 376 ,
378 , 380 , 382 , 384 , 386 , 388 , 390 , 392 , 394 , 396 ,
398 , 400 , 405 , 442 , 443
2003-08-12 08:35:47 +04:00
} ;
# endif
2018-03-23 11:30:27 +03:00
# if YYDEBUG || YYERROR_VERBOSE || 0
2008-12-16 09:34:07 +03:00
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First , the terminals , then , starting at YYNTOKENS , nonterminals . */
2003-08-12 08:35:47 +04:00
static const char * const yytname [ ] =
{
2008-12-16 09:34:07 +03:00
" $end " , " error " , " $undefined " , " tAGO " , " tDST " , " tDAY " , " tDAY_UNIT " ,
" tDAYZONE " , " tHOUR_UNIT " , " tLOCAL_ZONE " , " tMERIDIAN " , " tMINUTE_UNIT " ,
" tMONTH " , " tMONTH_UNIT " , " tSEC_UNIT " , " tYEAR_UNIT " , " tZONE " , " tSNUMBER " ,
" tUNUMBER " , " ':' " , " ',' " , " '/' " , " $accept " , " spec " , " item " , " time " ,
" local_zone " , " zone " , " day " , " date " , " rel " , " relunit " , " number " ,
2018-03-23 11:30:27 +03:00
" o_merid " , YY_NULLPTR
2003-08-12 08:35:47 +04:00
} ;
# endif
# ifdef YYPRINT
2018-03-23 11:30:27 +03:00
/* YYTOKNUM[NUM] -- (External) token number corresponding to the
( internal ) symbol number NUM ( which must be that of a token ) . */
2008-12-16 09:34:07 +03:00
static const yytype_uint16 yytoknum [ ] =
2003-08-12 08:35:47 +04:00
{
0 , 256 , 257 , 258 , 259 , 260 , 261 , 262 , 263 , 264 ,
265 , 266 , 267 , 268 , 269 , 270 , 271 , 272 , 273 , 58 ,
44 , 47
} ;
# endif
2018-03-23 11:30:27 +03:00
# define YYPACT_NINF -17
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
# define yypact_value_is_default(Yystate) \
( ! ! ( ( Yystate ) = = ( - 17 ) ) )
# define YYTABLE_NINF -1
# define yytable_value_is_error(Yytable_value) \
0
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE - NUM . */
static const yytype_int8 yypact [ ] =
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
- 17 , 0 , - 17 , 1 , - 17 , - 17 , - 17 , 19 , - 17 , - 14 ,
- 17 , - 17 , - 17 , 32 , 26 , 14 , - 17 , - 17 , - 17 , - 17 ,
- 17 , - 17 , - 17 , 27 , - 17 , - 17 , - 17 , 22 , - 17 , - 17 ,
- 17 , - 17 , - 17 , - 17 , - 17 , - 17 , - 17 , - 17 , - 17 , - 17 ,
- 16 , - 17 , - 17 , - 17 , 29 , 25 , 30 , - 17 , 31 , - 17 ,
- 17 , - 17 , 28 , 23 , - 17 , - 17 , - 17 , 33 , - 17 , 34 ,
- 7 , - 17 , - 17 , - 17
2003-08-12 08:35:47 +04:00
} ;
2018-03-23 11:30:27 +03:00
/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
Performed when YYTABLE does not specify something else to do . Zero
means the default is an error . */
2008-12-16 09:34:07 +03:00
static const yytype_uint8 yydefact [ ] =
2003-08-12 08:35:47 +04:00
{
2 , 0 , 1 , 21 , 42 , 19 , 45 , 16 , 48 , 0 ,
39 , 51 , 36 , 18 , 0 , 52 , 3 , 4 , 5 , 6 ,
8 , 7 , 9 , 33 , 10 , 22 , 17 , 28 , 20 , 41 ,
44 , 47 , 38 , 50 , 35 , 23 , 40 , 43 , 11 , 46 ,
30 , 37 , 49 , 34 , 0 , 0 , 0 , 32 , 0 , 27 ,
31 , 26 , 53 , 24 , 29 , 54 , 13 , 0 , 12 , 0 ,
53 , 25 , 15 , 14
} ;
2018-03-23 11:30:27 +03:00
/* YYPGOTO[NTERM-NUM]. */
static const yytype_int8 yypgoto [ ] =
2003-08-12 08:35:47 +04:00
{
- 17 , - 17 , - 17 , - 17 , - 17 , - 17 , - 17 , - 17 , - 17 , - 17 ,
2018-03-23 11:30:27 +03:00
- 17 , - 10
2003-08-12 08:35:47 +04:00
} ;
2018-03-23 11:30:27 +03:00
/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int8 yydefgoto [ ] =
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
- 1 , 1 , 16 , 17 , 18 , 19 , 20 , 21 , 22 , 23 ,
24 , 58
2003-08-12 08:35:47 +04:00
} ;
2018-03-23 11:30:27 +03:00
/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
positive , shift that token . If negative , reduce the rule whose
number is the opposite . If YYTABLE_NINF , syntax error . */
2008-12-16 09:34:07 +03:00
static const yytype_uint8 yytable [ ] =
2003-08-12 08:35:47 +04:00
{
2 , 49 , 50 , 55 , 27 , 3 , 4 , 5 , 6 , 7 ,
62 , 8 , 9 , 10 , 11 , 12 , 13 , 14 , 15 , 35 ,
36 , 25 , 37 , 26 , 38 , 39 , 40 , 41 , 42 , 43 ,
47 , 44 , 29 , 45 , 30 , 46 , 28 , 31 , 55 , 32 ,
33 , 34 , 48 , 52 , 59 , 56 , 51 , 57 , 53 , 54 ,
63 , 60 , 61
} ;
2008-12-16 09:34:07 +03:00
static const yytype_uint8 yycheck [ ] =
2003-08-12 08:35:47 +04:00
{
0 , 17 , 18 , 10 , 18 , 5 , 6 , 7 , 8 , 9 ,
17 , 11 , 12 , 13 , 14 , 15 , 16 , 17 , 18 , 5 ,
6 , 20 , 8 , 4 , 10 , 11 , 12 , 13 , 14 , 15 ,
3 , 17 , 6 , 19 , 8 , 21 , 4 , 11 , 10 , 13 ,
14 , 15 , 20 , 18 , 21 , 17 , 17 , 19 , 18 , 18 ,
60 , 18 , 18
} ;
2018-03-23 11:30:27 +03:00
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE - NUM . */
2008-12-16 09:34:07 +03:00
static const yytype_uint8 yystos [ ] =
2003-08-12 08:35:47 +04:00
{
0 , 23 , 0 , 5 , 6 , 7 , 8 , 9 , 11 , 12 ,
13 , 14 , 15 , 16 , 17 , 18 , 24 , 25 , 26 , 27 ,
28 , 29 , 30 , 31 , 32 , 20 , 4 , 18 , 4 , 6 ,
8 , 11 , 13 , 14 , 15 , 5 , 6 , 8 , 10 , 11 ,
12 , 13 , 14 , 15 , 17 , 19 , 21 , 3 , 20 , 17 ,
18 , 17 , 18 , 18 , 18 , 10 , 17 , 19 , 33 , 21 ,
18 , 18 , 17 , 33
} ;
2018-03-23 11:30:27 +03:00
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const yytype_uint8 yyr1 [ ] =
{
0 , 22 , 23 , 23 , 24 , 24 , 24 , 24 , 24 , 24 ,
24 , 25 , 25 , 25 , 25 , 25 , 26 , 26 , 27 , 27 ,
27 , 28 , 28 , 28 , 29 , 29 , 29 , 29 , 29 , 29 ,
29 , 29 , 30 , 30 , 31 , 31 , 31 , 31 , 31 , 31 ,
31 , 31 , 31 , 31 , 31 , 31 , 31 , 31 , 31 , 31 ,
31 , 31 , 32 , 33 , 33
} ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
static const yytype_uint8 yyr2 [ ] =
{
0 , 2 , 0 , 2 , 1 , 1 , 1 , 1 , 1 , 1 ,
1 , 2 , 4 , 4 , 6 , 6 , 1 , 2 , 1 , 1 ,
2 , 1 , 2 , 2 , 3 , 5 , 3 , 3 , 2 , 4 ,
2 , 3 , 2 , 1 , 2 , 2 , 1 , 2 , 2 , 1 ,
2 , 2 , 1 , 2 , 2 , 1 , 2 , 2 , 1 , 2 ,
2 , 1 , 1 , 0 , 1
} ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
# define yyerrok (yyerrstatus = 0)
# define yyclearin (yychar = YYEMPTY)
# define YYEMPTY (-2)
# define YYEOF 0
2008-12-16 09:34:07 +03:00
2018-03-23 11:30:27 +03:00
# define YYACCEPT goto yyacceptlab
# define YYABORT goto yyabortlab
# define YYERROR goto yyerrorlab
2008-12-16 09:34:07 +03:00
2018-03-23 11:30:27 +03:00
# define YYRECOVERING() (!!yyerrstatus)
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
# define YYBACKUP(Token, Value) \
do \
if ( yychar = = YYEMPTY ) \
{ \
yychar = ( Token ) ; \
yylval = ( Value ) ; \
YYPOPSTACK ( yylen ) ; \
yystate = * yyssp ; \
goto yybackup ; \
} \
else \
{ \
yyerror ( pc , YY_ ( " syntax error: cannot back up " ) ) ; \
YYERROR ; \
} \
while ( 0 )
/* Error token number */
# define YYTERROR 1
# define YYERRCODE 256
2008-12-16 09:34:07 +03:00
2003-08-12 08:35:47 +04:00
/* Enable debugging if requested. */
# if YYDEBUG
# ifndef YYFPRINTF
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
# define YYFPRINTF fprintf
# endif
2018-03-23 11:30:27 +03:00
# define YYDPRINTF(Args) \
do { \
if ( yydebug ) \
YYFPRINTF Args ; \
} while ( 0 )
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
/* This macro is provided for backward compatibility. */
# ifndef YY_LOCATION_PRINT
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
2003-08-12 08:35:47 +04:00
2008-12-16 09:34:07 +03:00
2018-03-23 11:30:27 +03:00
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
do { \
if ( yydebug ) \
{ \
YYFPRINTF ( stderr , " %s " , Title ) ; \
yy_symbol_print ( stderr , \
Type , Value , pc ) ; \
YYFPRINTF ( stderr , " \n " ) ; \
} \
} while ( 0 )
/*----------------------------------------.
| Print this symbol ' s value on YYOUTPUT . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2008-12-16 09:34:07 +03:00
static void
2018-03-23 11:30:27 +03:00
yy_symbol_value_print ( FILE * yyoutput , int yytype , YYSTYPE const * const yyvaluep , struct parser_control * pc )
2008-12-16 09:34:07 +03:00
{
2018-03-23 11:30:27 +03:00
FILE * yyo = yyoutput ;
YYUSE ( yyo ) ;
YYUSE ( pc ) ;
2008-12-16 09:34:07 +03:00
if ( ! yyvaluep )
return ;
# ifdef YYPRINT
if ( yytype < YYNTOKENS )
YYPRINT ( yyoutput , yytoknum [ yytype ] , * yyvaluep ) ;
# endif
2018-03-23 11:30:27 +03:00
YYUSE ( yytype ) ;
2008-12-16 09:34:07 +03:00
}
/*--------------------------------.
| Print this symbol on YYOUTPUT . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
static void
2018-03-23 11:30:27 +03:00
yy_symbol_print ( FILE * yyoutput , int yytype , YYSTYPE const * const yyvaluep , struct parser_control * pc )
2008-12-16 09:34:07 +03:00
{
2018-03-23 11:30:27 +03:00
YYFPRINTF ( yyoutput , " %s %s ( " ,
yytype < YYNTOKENS ? " token " : " nterm " , yytname [ yytype ] ) ;
2008-12-16 09:34:07 +03:00
2018-03-23 11:30:27 +03:00
yy_symbol_value_print ( yyoutput , yytype , yyvaluep , pc ) ;
2008-12-16 09:34:07 +03:00
YYFPRINTF ( yyoutput , " ) " ) ;
}
2003-08-12 08:35:47 +04:00
/*------------------------------------------------------------------.
| yy_stack_print - - Print the state stack from its BOTTOM up to its |
2008-12-16 09:34:07 +03:00
| TOP ( included ) . |
2003-08-12 08:35:47 +04:00
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
static void
2018-03-23 11:30:27 +03:00
yy_stack_print ( yytype_int16 * yybottom , yytype_int16 * yytop )
2003-08-12 08:35:47 +04:00
{
YYFPRINTF ( stderr , " Stack now " ) ;
2018-03-23 11:30:27 +03:00
for ( ; yybottom < = yytop ; yybottom + + )
{
int yybot = * yybottom ;
YYFPRINTF ( stderr , " %d " , yybot ) ;
}
2003-08-12 08:35:47 +04:00
YYFPRINTF ( stderr , " \n " ) ;
}
2018-03-23 11:30:27 +03:00
# define YY_STACK_PRINT(Bottom, Top) \
do { \
if ( yydebug ) \
yy_stack_print ( ( Bottom ) , ( Top ) ) ; \
} while ( 0 )
2003-08-12 08:35:47 +04:00
/*------------------------------------------------.
| Report that the YYRULE is going to be reduced . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
static void
2018-03-23 11:30:27 +03:00
yy_reduce_print ( yytype_int16 * yyssp , YYSTYPE * yyvsp , int yyrule , struct parser_control * pc )
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
unsigned long int yylno = yyrline [ yyrule ] ;
2008-12-16 09:34:07 +03:00
int yynrhs = yyr2 [ yyrule ] ;
2003-08-12 08:35:47 +04:00
int yyi ;
2008-12-16 09:34:07 +03:00
YYFPRINTF ( stderr , " Reducing stack by rule %d (line %lu): \n " ,
2018-03-23 11:30:27 +03:00
yyrule - 1 , yylno ) ;
2008-12-16 09:34:07 +03:00
/* The symbols being reduced. */
for ( yyi = 0 ; yyi < yynrhs ; yyi + + )
{
2018-03-23 11:30:27 +03:00
YYFPRINTF ( stderr , " $%d = " , yyi + 1 ) ;
yy_symbol_print ( stderr ,
yystos [ yyssp [ yyi + 1 - yynrhs ] ] ,
& ( yyvsp [ ( yyi + 1 ) - ( yynrhs ) ] )
, pc ) ;
YYFPRINTF ( stderr , " \n " ) ;
2008-12-16 09:34:07 +03:00
}
2003-08-12 08:35:47 +04:00
}
2018-03-23 11:30:27 +03:00
# define YY_REDUCE_PRINT(Rule) \
do { \
if ( yydebug ) \
yy_reduce_print ( yyssp , yyvsp , Rule , pc ) ; \
} while ( 0 )
2003-08-12 08:35:47 +04:00
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist . */
int yydebug ;
# else /* !YYDEBUG */
# define YYDPRINTF(Args)
2008-12-16 09:34:07 +03:00
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
2003-08-12 08:35:47 +04:00
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
# endif /* !YYDEBUG */
/* YYINITDEPTH -- initial size of the parser's stacks. */
2018-03-23 11:30:27 +03:00
# ifndef YYINITDEPTH
2003-08-12 08:35:47 +04:00
# define YYINITDEPTH 200
# endif
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
if the built - in stack extension method is used ) .
Do not make this value too large ; the results are undefined if
2008-12-16 09:34:07 +03:00
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES ( YYMAXDEPTH )
2003-08-12 08:35:47 +04:00
evaluated with infinite - precision integer arithmetic . */
# ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
# endif
# if YYERROR_VERBOSE
# ifndef yystrlen
2008-12-16 09:34:07 +03:00
# if defined __GLIBC__ && defined _STRING_H
2003-08-12 08:35:47 +04:00
# define yystrlen strlen
# else
/* Return the length of YYSTR. */
static YYSIZE_T
yystrlen ( const char * yystr )
{
2008-12-16 09:34:07 +03:00
YYSIZE_T yylen ;
for ( yylen = 0 ; yystr [ yylen ] ; yylen + + )
2003-08-12 08:35:47 +04:00
continue ;
2008-12-16 09:34:07 +03:00
return yylen ;
2003-08-12 08:35:47 +04:00
}
# endif
# endif
# ifndef yystpcpy
2008-12-16 09:34:07 +03:00
# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
2003-08-12 08:35:47 +04:00
# define yystpcpy stpcpy
# else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
YYDEST . */
static char *
yystpcpy ( char * yydest , const char * yysrc )
{
2008-12-16 09:34:07 +03:00
char * yyd = yydest ;
const char * yys = yysrc ;
2003-08-12 08:35:47 +04:00
while ( ( * yyd + + = * yys + + ) ! = ' \0 ' )
continue ;
return yyd - 1 ;
}
# endif
# endif
2008-12-16 09:34:07 +03:00
# ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
quotes and backslashes , so that it ' s suitable for yyerror . The
heuristic is that double - quoting is unnecessary unless the string
contains an apostrophe , a comma , or backslash ( other than
backslash - backslash ) . YYSTR is taken from yytname . If YYRES is
null , do not copy ; instead , return the length of what the result
would have been . */
static YYSIZE_T
yytnamerr ( char * yyres , const char * yystr )
{
if ( * yystr = = ' " ' )
{
YYSIZE_T yyn = 0 ;
char const * yyp = yystr ;
for ( ; ; )
2018-03-23 11:30:27 +03:00
switch ( * + + yyp )
{
case ' \' ' :
case ' , ' :
goto do_not_strip_quotes ;
case ' \\ ' :
if ( * + + yyp ! = ' \\ ' )
goto do_not_strip_quotes ;
/* Fall through. */
default :
if ( yyres )
yyres [ yyn ] = * yyp ;
yyn + + ;
break ;
case ' " ' :
if ( yyres )
yyres [ yyn ] = ' \0 ' ;
return yyn ;
}
2008-12-16 09:34:07 +03:00
do_not_strip_quotes : ;
}
2003-08-12 08:35:47 +04:00
2008-12-16 09:34:07 +03:00
if ( ! yyres )
return yystrlen ( yystr ) ;
2003-08-12 08:35:47 +04:00
2008-12-16 09:34:07 +03:00
return yystpcpy ( yyres , yystr ) - yyres ;
}
# endif
2018-03-23 11:30:27 +03:00
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
about the unexpected token YYTOKEN for the state stack whose top is
YYSSP .
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
Return 0 if * YYMSG was successfully written . Return 1 if * YYMSG is
not large enough to hold the message . In that case , also set
* YYMSG_ALLOC to the required number of bytes . Return 2 if the
required number of bytes is too large to store . */
static int
yysyntax_error ( YYSIZE_T * yymsg_alloc , char * * yymsg ,
yytype_int16 * yyssp , int yytoken )
{
YYSIZE_T yysize0 = yytnamerr ( YY_NULLPTR , yytname [ yytoken ] ) ;
YYSIZE_T yysize = yysize0 ;
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 } ;
/* Internationalized format string. */
const char * yyformat = YY_NULLPTR ;
/* Arguments of yyformat. */
char const * yyarg [ YYERROR_VERBOSE_ARGS_MAXIMUM ] ;
/* Number of reported tokens (one for the "unexpected", one per
" expected " ) . */
int yycount = 0 ;
/* There are many possibilities here to consider:
- If this state is a consistent state with a default action , then
the only way this function was invoked is if the default action
is an error action . In that case , don ' t check for expected
tokens because there are none .
- The only way there can be no lookahead present ( in yychar ) is if
this state is a consistent state with a default action . Thus ,
detecting the absence of a lookahead is sufficient to determine
that there is no unexpected or expected token to report . In that
case , just report a simple " syntax error " .
- Don ' t assume there isn ' t a lookahead just because this state is a
consistent state with a default action . There might have been a
previous inconsistent state , consistent state with a non - default
action , or user semantic action that manipulated yychar .
- Of course , the expected token list depends on states to have
correct lookahead information , and it depends on the parser not
to perform extra reductions after fetching a lookahead from the
scanner and before detecting a syntax error . Thus , state merging
( from LALR or IELR ) and default reductions corrupt the expected
token list . However , the list is correct for canonical LR with
one exception : it will still contain any token that will not be
accepted due to an error action in a later state .
*/
if ( yytoken ! = YYEMPTY )
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
int yyn = yypact [ * yyssp ] ;
yyarg [ yycount + + ] = yytname [ yytoken ] ;
if ( ! yypact_value_is_default ( yyn ) )
{
/* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK . In other words , skip the first - YYN actions for
this state because they are default actions . */
int yyxbegin = yyn < 0 ? - yyn : 0 ;
/* Stay within bounds of both yycheck and yytname. */
int yychecklim = YYLAST - yyn + 1 ;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS ;
int yyx ;
for ( yyx = yyxbegin ; yyx < yyxend ; + + yyx )
if ( yycheck [ yyx + yyn ] = = yyx & & yyx ! = YYTERROR
& & ! yytable_value_is_error ( yytable [ yyx + yyn ] ) )
{
if ( yycount = = YYERROR_VERBOSE_ARGS_MAXIMUM )
{
yycount = 1 ;
yysize = yysize0 ;
break ;
}
yyarg [ yycount + + ] = yytname [ yyx ] ;
{
YYSIZE_T yysize1 = yysize + yytnamerr ( YY_NULLPTR , yytname [ yyx ] ) ;
if ( ! ( yysize < = yysize1
& & yysize1 < = YYSTACK_ALLOC_MAXIMUM ) )
return 2 ;
yysize = yysize1 ;
}
}
}
}
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
switch ( yycount )
{
# define YYCASE_(N, S) \
case N : \
yyformat = S ; \
break
YYCASE_ ( 0 , YY_ ( " syntax error " ) ) ;
YYCASE_ ( 1 , YY_ ( " syntax error, unexpected %s " ) ) ;
YYCASE_ ( 2 , YY_ ( " syntax error, unexpected %s, expecting %s " ) ) ;
YYCASE_ ( 3 , YY_ ( " syntax error, unexpected %s, expecting %s or %s " ) ) ;
YYCASE_ ( 4 , YY_ ( " syntax error, unexpected %s, expecting %s or %s or %s " ) ) ;
YYCASE_ ( 5 , YY_ ( " syntax error, unexpected %s, expecting %s or %s or %s or %s " ) ) ;
# undef YYCASE_
}
2008-12-16 09:34:07 +03:00
2018-03-23 11:30:27 +03:00
{
YYSIZE_T yysize1 = yysize + yystrlen ( yyformat ) ;
if ( ! ( yysize < = yysize1 & & yysize1 < = YYSTACK_ALLOC_MAXIMUM ) )
return 2 ;
yysize = yysize1 ;
}
2008-12-16 09:34:07 +03:00
2018-03-23 11:30:27 +03:00
if ( * yymsg_alloc < yysize )
{
* yymsg_alloc = 2 * yysize ;
if ( ! ( yysize < = * yymsg_alloc
& & * yymsg_alloc < = YYSTACK_ALLOC_MAXIMUM ) )
* yymsg_alloc = YYSTACK_ALLOC_MAXIMUM ;
return 1 ;
2003-08-12 08:35:47 +04:00
}
2018-03-23 11:30:27 +03:00
/* Avoid sprintf, as that infringes on the user's name space.
Don ' t have undefined behavior even if the translation
produced a string with the wrong number of " %s " s . */
{
char * yyp = * yymsg ;
int yyi = 0 ;
while ( ( * yyp = * yyformat ) ! = ' \0 ' )
if ( * yyp = = ' % ' & & yyformat [ 1 ] = = ' s ' & & yyi < yycount )
{
yyp + = yytnamerr ( yyp , yyarg [ yyi + + ] ) ;
yyformat + = 2 ;
}
else
{
yyp + + ;
yyformat + + ;
}
}
return 0 ;
2003-08-12 08:35:47 +04:00
}
2008-12-16 09:34:07 +03:00
# endif /* YYERROR_VERBOSE */
2003-08-12 08:35:47 +04:00
/*-----------------------------------------------.
| Release the memory associated to this symbol . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
static void
2018-03-23 11:30:27 +03:00
yydestruct ( const char * yymsg , int yytype , YYSTYPE * yyvaluep , struct parser_control * pc )
2003-08-12 08:35:47 +04:00
{
2008-12-16 09:34:07 +03:00
YYUSE ( yyvaluep ) ;
2018-03-23 11:30:27 +03:00
YYUSE ( pc ) ;
2008-12-16 09:34:07 +03:00
if ( ! yymsg )
yymsg = " Deleting " ;
YY_SYMBOL_PRINT ( yymsg , yytype , yyvaluep , yylocationp ) ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
YYUSE ( yytype ) ;
YY_IGNORE_MAYBE_UNINITIALIZED_END
2003-08-12 08:35:47 +04:00
}
/*----------.
| yyparse . |
` - - - - - - - - - - */
int
2018-03-23 11:30:27 +03:00
yyparse ( struct parser_control * pc )
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
/* The lookahead symbol. */
2003-08-12 08:35:47 +04:00
int yychar ;
2018-03-23 11:30:27 +03:00
/* The semantic value of the lookahead symbol. */
/* Default value used for initialization, for pacifying older GCCs
or non - GCC compilers . */
YY_INITIAL_VALUE ( static YYSTYPE yyval_default ; )
YYSTYPE yylval YY_INITIAL_VALUE ( = yyval_default ) ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
/* Number of syntax errors so far. */
int yynerrs ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
int yystate ;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
/* The stacks and their tools:
' yyss ' : related to states .
' yyvs ' : related to semantic values .
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
Refer to the stacks through separate pointers , to allow yyoverflow
to reallocate them elsewhere . */
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
/* The state stack. */
yytype_int16 yyssa [ YYINITDEPTH ] ;
yytype_int16 * yyss ;
yytype_int16 * yyssp ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
/* The semantic value stack. */
YYSTYPE yyvsa [ YYINITDEPTH ] ;
YYSTYPE * yyvs ;
YYSTYPE * yyvsp ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
YYSIZE_T yystacksize ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
int yyn ;
int yyresult ;
/* Lookahead token as an internal (translated) token number. */
int yytoken = 0 ;
2003-08-12 08:35:47 +04:00
/* The variables used to return semantic value and location from the
action routines . */
YYSTYPE yyval ;
2018-03-23 11:30:27 +03:00
# if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */
char yymsgbuf [ 128 ] ;
char * yymsg = yymsgbuf ;
YYSIZE_T yymsg_alloc = sizeof yymsgbuf ;
# endif
# define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2003-08-12 08:35:47 +04:00
2008-12-16 09:34:07 +03:00
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped . */
int yylen = 0 ;
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
yyssp = yyss = yyssa ;
yyvsp = yyvs = yyvsa ;
yystacksize = YYINITDEPTH ;
2003-08-12 08:35:47 +04:00
YYDPRINTF ( ( stderr , " Starting parse \n " ) ) ;
yystate = 0 ;
yyerrstatus = 0 ;
yynerrs = 0 ;
2018-03-23 11:30:27 +03:00
yychar = YYEMPTY ; /* Cause a token to be read. */
2003-08-12 08:35:47 +04:00
goto yysetstate ;
/*------------------------------------------------------------.
| yynewstate - - Push a new state , which is found in yystate . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
yynewstate :
/* In all cases, when you get here, the value and location stacks
2008-12-16 09:34:07 +03:00
have just been pushed . So pushing a state here evens the stacks . */
2003-08-12 08:35:47 +04:00
yyssp + + ;
yysetstate :
* yyssp = yystate ;
if ( yyss + yystacksize - 1 < = yyssp )
{
/* Get the current used size of the three stacks, in elements. */
YYSIZE_T yysize = yyssp - yyss + 1 ;
# ifdef yyoverflow
{
2018-03-23 11:30:27 +03:00
/* Give user a chance to reallocate the stack. Use copies of
these so that the & ' s don ' t force the real ones into
memory . */
YYSTYPE * yyvs1 = yyvs ;
yytype_int16 * yyss1 = yyss ;
/* Each stack pointer address is followed by the size of the
data in use in that stack , in bytes . This used to be a
conditional around just the two extra args , but that might
be undefined if yyoverflow is a macro . */
yyoverflow ( YY_ ( " memory exhausted " ) ,
& yyss1 , yysize * sizeof ( * yyssp ) ,
& yyvs1 , yysize * sizeof ( * yyvsp ) ,
& yystacksize ) ;
yyss = yyss1 ;
yyvs = yyvs1 ;
2003-08-12 08:35:47 +04:00
}
# else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
2008-12-16 09:34:07 +03:00
goto yyexhaustedlab ;
2003-08-12 08:35:47 +04:00
# else
/* Extend the stack our own way. */
if ( YYMAXDEPTH < = yystacksize )
2018-03-23 11:30:27 +03:00
goto yyexhaustedlab ;
2003-08-12 08:35:47 +04:00
yystacksize * = 2 ;
if ( YYMAXDEPTH < yystacksize )
2018-03-23 11:30:27 +03:00
yystacksize = YYMAXDEPTH ;
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
yytype_int16 * yyss1 = yyss ;
union yyalloc * yyptr =
( union yyalloc * ) YYSTACK_ALLOC ( YYSTACK_BYTES ( yystacksize ) ) ;
if ( ! yyptr )
goto yyexhaustedlab ;
YYSTACK_RELOCATE ( yyss_alloc , yyss ) ;
YYSTACK_RELOCATE ( yyvs_alloc , yyvs ) ;
2003-08-12 08:35:47 +04:00
# undef YYSTACK_RELOCATE
2018-03-23 11:30:27 +03:00
if ( yyss1 ! = yyssa )
YYSTACK_FREE ( yyss1 ) ;
2003-08-12 08:35:47 +04:00
}
# endif
# endif /* no yyoverflow */
yyssp = yyss + yysize - 1 ;
yyvsp = yyvs + yysize - 1 ;
YYDPRINTF ( ( stderr , " Stack size increased to %lu \n " ,
2018-03-23 11:30:27 +03:00
( unsigned long int ) yystacksize ) ) ;
2003-08-12 08:35:47 +04:00
if ( yyss + yystacksize - 1 < = yyssp )
2018-03-23 11:30:27 +03:00
YYABORT ;
2003-08-12 08:35:47 +04:00
}
YYDPRINTF ( ( stderr , " Entering state %d \n " , yystate ) ) ;
2018-03-23 11:30:27 +03:00
if ( yystate = = YYFINAL )
YYACCEPT ;
2003-08-12 08:35:47 +04:00
goto yybackup ;
/*-----------.
| yybackup . |
` - - - - - - - - - - - */
yybackup :
2008-12-16 09:34:07 +03:00
/* Do appropriate processing given the current state. Read a
2018-03-23 11:30:27 +03:00
lookahead token if we need one and don ' t already have one . */
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
/* First try to decide what to do without reference to lookahead token. */
2003-08-12 08:35:47 +04:00
yyn = yypact [ yystate ] ;
2018-03-23 11:30:27 +03:00
if ( yypact_value_is_default ( yyn ) )
2003-08-12 08:35:47 +04:00
goto yydefault ;
2018-03-23 11:30:27 +03:00
/* Not known => get a lookahead token if don't already have one. */
2003-08-12 08:35:47 +04:00
2018-03-23 11:30:27 +03:00
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2003-08-12 08:35:47 +04:00
if ( yychar = = YYEMPTY )
{
YYDPRINTF ( ( stderr , " Reading a token: " ) ) ;
2018-03-23 11:30:27 +03:00
yychar = yylex ( & yylval , pc ) ;
2003-08-12 08:35:47 +04:00
}
if ( yychar < = YYEOF )
{
yychar = yytoken = YYEOF ;
YYDPRINTF ( ( stderr , " Now at end of input. \n " ) ) ;
}
else
{
yytoken = YYTRANSLATE ( yychar ) ;
2008-12-16 09:34:07 +03:00
YY_SYMBOL_PRINT ( " Next token is " , yytoken , & yylval , & yylloc ) ;
2003-08-12 08:35:47 +04:00
}
/* If the proper action on seeing token YYTOKEN is to reduce or to
detect an error , take that action . */
yyn + = yytoken ;
if ( yyn < 0 | | YYLAST < yyn | | yycheck [ yyn ] ! = yytoken )
goto yydefault ;
yyn = yytable [ yyn ] ;
if ( yyn < = 0 )
{
2018-03-23 11:30:27 +03:00
if ( yytable_value_is_error ( yyn ) )
goto yyerrlab ;
2003-08-12 08:35:47 +04:00
yyn = - yyn ;
goto yyreduce ;
}
/* Count tokens shifted since error; after three, turn off error
status . */
if ( yyerrstatus )
yyerrstatus - - ;
2018-03-23 11:30:27 +03:00
/* Shift the lookahead token. */
2008-12-16 09:34:07 +03:00
YY_SYMBOL_PRINT ( " Shifting " , yytoken , & yylval , & yylloc ) ;
2018-03-23 11:30:27 +03:00
/* Discard the shifted token. */
yychar = YYEMPTY ;
2008-12-16 09:34:07 +03:00
2003-08-12 08:35:47 +04:00
yystate = yyn ;
2018-03-23 11:30:27 +03:00
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2008-12-16 09:34:07 +03:00
* + + yyvsp = yylval ;
2018-03-23 11:30:27 +03:00
YY_IGNORE_MAYBE_UNINITIALIZED_END
2008-12-16 09:34:07 +03:00
2003-08-12 08:35:47 +04:00
goto yynewstate ;
/*-----------------------------------------------------------.
| yydefault - - do the default action for the current state . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
yydefault :
yyn = yydefact [ yystate ] ;
if ( yyn = = 0 )
goto yyerrlab ;
goto yyreduce ;
/*-----------------------------.
| yyreduce - - Do a reduction . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
yyreduce :
/* yyn is the number of a rule to reduce with. */
yylen = yyr2 [ yyn ] ;
/* If YYLEN is nonzero, implement the default value of the action:
2018-03-23 11:30:27 +03:00
' $ $ = $ 1 ' .
2003-08-12 08:35:47 +04:00
Otherwise , the following line sets YYVAL to garbage .
This behavior is undocumented and Bison
users should not rely upon it . Assigning to YYVAL
unconditionally makes the parser a bit smaller , and it avoids a
GCC warning that YYVAL may be used uninitialized . */
yyval = yyvsp [ 1 - yylen ] ;
YY_REDUCE_PRINT ( yyn ) ;
switch ( yyn )
{
case 4 :
2018-03-23 11:30:27 +03:00
# line 198 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > times_seen + + ; }
# line 1430 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 5 :
2018-03-23 11:30:27 +03:00
# line 200 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > local_zones_seen + + ; }
# line 1436 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 6 :
2018-03-23 11:30:27 +03:00
# line 202 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > zones_seen + + ; }
# line 1442 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 7 :
2018-03-23 11:30:27 +03:00
# line 204 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > dates_seen + + ; }
# line 1448 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 8 :
2018-03-23 11:30:27 +03:00
# line 206 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > days_seen + + ; }
# line 1454 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 9 :
2018-03-23 11:30:27 +03:00
# line 208 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rels_seen + + ; }
# line 1460 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 11 :
2018-03-23 11:30:27 +03:00
# line 214 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > hour = ( yyvsp [ - 1 ] . textintval ) . value ;
pc - > minutes = 0 ;
pc - > seconds = 0 ;
pc - > meridian = ( yyvsp [ 0 ] . intval ) ;
}
# line 1471 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 12 :
2018-03-23 11:30:27 +03:00
# line 221 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > hour = ( yyvsp [ - 3 ] . textintval ) . value ;
pc - > minutes = ( yyvsp [ - 1 ] . textintval ) . value ;
pc - > seconds = 0 ;
pc - > meridian = ( yyvsp [ 0 ] . intval ) ;
}
# line 1482 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 13 :
2018-03-23 11:30:27 +03:00
# line 228 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > hour = ( yyvsp [ - 3 ] . textintval ) . value ;
pc - > minutes = ( yyvsp [ - 1 ] . textintval ) . value ;
pc - > meridian = MER24 ;
pc - > zones_seen + + ;
pc - > time_zone = ( yyvsp [ 0 ] . textintval ) . value % 100 + ( ( yyvsp [ 0 ] . textintval ) . value / 100 ) * 60 ;
}
# line 1494 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 14 :
2018-03-23 11:30:27 +03:00
# line 236 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > hour = ( yyvsp [ - 5 ] . textintval ) . value ;
pc - > minutes = ( yyvsp [ - 3 ] . textintval ) . value ;
pc - > seconds = ( yyvsp [ - 1 ] . textintval ) . value ;
pc - > meridian = ( yyvsp [ 0 ] . intval ) ;
}
# line 1505 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 15 :
2018-03-23 11:30:27 +03:00
# line 243 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > hour = ( yyvsp [ - 5 ] . textintval ) . value ;
pc - > minutes = ( yyvsp [ - 3 ] . textintval ) . value ;
pc - > seconds = ( yyvsp [ - 1 ] . textintval ) . value ;
pc - > meridian = MER24 ;
pc - > zones_seen + + ;
pc - > time_zone = ( yyvsp [ 0 ] . textintval ) . value % 100 + ( ( yyvsp [ 0 ] . textintval ) . value / 100 ) * 60 ;
}
# line 1518 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 16 :
2018-03-23 11:30:27 +03:00
# line 255 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > local_isdst = ( yyvsp [ 0 ] . intval ) ; }
# line 1524 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 17 :
2018-03-23 11:30:27 +03:00
# line 257 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > local_isdst = ( yyvsp [ - 1 ] . intval ) < 0 ? 1 : ( yyvsp [ - 1 ] . intval ) + 1 ; }
# line 1530 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 18 :
2018-03-23 11:30:27 +03:00
# line 262 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > time_zone = ( yyvsp [ 0 ] . intval ) ; }
# line 1536 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 19 :
2018-03-23 11:30:27 +03:00
# line 264 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > time_zone = ( yyvsp [ 0 ] . intval ) + 60 ; }
# line 1542 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 20 :
2018-03-23 11:30:27 +03:00
# line 266 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > time_zone = ( yyvsp [ - 1 ] . intval ) + 60 ; }
# line 1548 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 21 :
2018-03-23 11:30:27 +03:00
# line 271 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > day_ordinal = 1 ;
pc - > day_number = ( yyvsp [ 0 ] . intval ) ;
}
# line 1557 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 22 :
2018-03-23 11:30:27 +03:00
# line 276 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > day_ordinal = 1 ;
pc - > day_number = ( yyvsp [ - 1 ] . intval ) ;
}
# line 1566 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 23 :
2018-03-23 11:30:27 +03:00
# line 281 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > day_ordinal = ( yyvsp [ - 1 ] . textintval ) . value ;
pc - > day_number = ( yyvsp [ 0 ] . intval ) ;
}
# line 1575 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 24 :
2018-03-23 11:30:27 +03:00
# line 289 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > month = ( yyvsp [ - 2 ] . textintval ) . value ;
pc - > day = ( yyvsp [ 0 ] . textintval ) . value ;
}
# line 1584 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 25 :
2018-03-23 11:30:27 +03:00
# line 294 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
/* Interpret as YYYY/MM/DD if the first value has 4 or more digits,
otherwise as MM / DD / YY .
The goal in recognizing YYYY / MM / DD is solely to support legacy
machine - generated dates like those in an RCS log listing . If
you want portability , use the ISO 8601 format . */
2018-03-23 11:30:27 +03:00
if ( 4 < = ( yyvsp [ - 4 ] . textintval ) . digits )
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > year = ( yyvsp [ - 4 ] . textintval ) ;
pc - > month = ( yyvsp [ - 2 ] . textintval ) . value ;
pc - > day = ( yyvsp [ 0 ] . textintval ) . value ;
2003-08-12 08:35:47 +04:00
}
else
{
2018-03-23 11:30:27 +03:00
pc - > month = ( yyvsp [ - 4 ] . textintval ) . value ;
pc - > day = ( yyvsp [ - 2 ] . textintval ) . value ;
pc - > year = ( yyvsp [ 0 ] . textintval ) ;
2003-08-12 08:35:47 +04:00
}
2018-03-23 11:30:27 +03:00
}
# line 1608 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 26 :
2018-03-23 11:30:27 +03:00
# line 314 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
/* ISO 8601 format. YYYY-MM-DD. */
2018-03-23 11:30:27 +03:00
pc - > year = ( yyvsp [ - 2 ] . textintval ) ;
pc - > month = - ( yyvsp [ - 1 ] . textintval ) . value ;
pc - > day = - ( yyvsp [ 0 ] . textintval ) . value ;
}
# line 1619 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 27 :
2018-03-23 11:30:27 +03:00
# line 321 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
/* e.g. 17-JUN-1992. */
2018-03-23 11:30:27 +03:00
pc - > day = ( yyvsp [ - 2 ] . textintval ) . value ;
pc - > month = ( yyvsp [ - 1 ] . intval ) ;
pc - > year . value = - ( yyvsp [ 0 ] . textintval ) . value ;
pc - > year . digits = ( yyvsp [ 0 ] . textintval ) . digits ;
}
# line 1631 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 28 :
2018-03-23 11:30:27 +03:00
# line 329 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > month = ( yyvsp [ - 1 ] . intval ) ;
pc - > day = ( yyvsp [ 0 ] . textintval ) . value ;
}
# line 1640 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 29 :
2018-03-23 11:30:27 +03:00
# line 334 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > month = ( yyvsp [ - 3 ] . intval ) ;
pc - > day = ( yyvsp [ - 2 ] . textintval ) . value ;
pc - > year = ( yyvsp [ 0 ] . textintval ) ;
}
# line 1650 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 30 :
2018-03-23 11:30:27 +03:00
# line 340 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > day = ( yyvsp [ - 1 ] . textintval ) . value ;
pc - > month = ( yyvsp [ 0 ] . intval ) ;
}
# line 1659 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 31 :
2018-03-23 11:30:27 +03:00
# line 345 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > day = ( yyvsp [ - 2 ] . textintval ) . value ;
pc - > month = ( yyvsp [ - 1 ] . intval ) ;
pc - > year = ( yyvsp [ 0 ] . textintval ) ;
}
# line 1669 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 32 :
2018-03-23 11:30:27 +03:00
# line 354 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > rel_seconds = - pc - > rel_seconds ;
pc - > rel_minutes = - pc - > rel_minutes ;
pc - > rel_hour = - pc - > rel_hour ;
pc - > rel_day = - pc - > rel_day ;
pc - > rel_month = - pc - > rel_month ;
pc - > rel_year = - pc - > rel_year ;
}
# line 1682 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 34 :
2018-03-23 11:30:27 +03:00
# line 367 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_year + = ( yyvsp [ - 1 ] . textintval ) . value * ( yyvsp [ 0 ] . intval ) ; }
# line 1688 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 35 :
2018-03-23 11:30:27 +03:00
# line 369 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_year + = ( yyvsp [ - 1 ] . textintval ) . value * ( yyvsp [ 0 ] . intval ) ; }
# line 1694 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 36 :
2018-03-23 11:30:27 +03:00
# line 371 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_year + = ( yyvsp [ 0 ] . intval ) ; }
# line 1700 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 37 :
2018-03-23 11:30:27 +03:00
# line 373 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_month + = ( yyvsp [ - 1 ] . textintval ) . value * ( yyvsp [ 0 ] . intval ) ; }
# line 1706 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 38 :
2018-03-23 11:30:27 +03:00
# line 375 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_month + = ( yyvsp [ - 1 ] . textintval ) . value * ( yyvsp [ 0 ] . intval ) ; }
# line 1712 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 39 :
2018-03-23 11:30:27 +03:00
# line 377 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_month + = ( yyvsp [ 0 ] . intval ) ; }
# line 1718 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 40 :
2018-03-23 11:30:27 +03:00
# line 379 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_day + = ( yyvsp [ - 1 ] . textintval ) . value * ( yyvsp [ 0 ] . intval ) ; }
# line 1724 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 41 :
2018-03-23 11:30:27 +03:00
# line 381 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_day + = ( yyvsp [ - 1 ] . textintval ) . value * ( yyvsp [ 0 ] . intval ) ; }
# line 1730 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 42 :
2018-03-23 11:30:27 +03:00
# line 383 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_day + = ( yyvsp [ 0 ] . intval ) ; }
# line 1736 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 43 :
2018-03-23 11:30:27 +03:00
# line 385 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_hour + = ( yyvsp [ - 1 ] . textintval ) . value * ( yyvsp [ 0 ] . intval ) ; }
# line 1742 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 44 :
2018-03-23 11:30:27 +03:00
# line 387 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_hour + = ( yyvsp [ - 1 ] . textintval ) . value * ( yyvsp [ 0 ] . intval ) ; }
# line 1748 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 45 :
2018-03-23 11:30:27 +03:00
# line 389 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_hour + = ( yyvsp [ 0 ] . intval ) ; }
# line 1754 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 46 :
2018-03-23 11:30:27 +03:00
# line 391 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_minutes + = ( yyvsp [ - 1 ] . textintval ) . value * ( yyvsp [ 0 ] . intval ) ; }
# line 1760 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 47 :
2018-03-23 11:30:27 +03:00
# line 393 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_minutes + = ( yyvsp [ - 1 ] . textintval ) . value * ( yyvsp [ 0 ] . intval ) ; }
# line 1766 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 48 :
2018-03-23 11:30:27 +03:00
# line 395 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_minutes + = ( yyvsp [ 0 ] . intval ) ; }
# line 1772 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 49 :
2018-03-23 11:30:27 +03:00
# line 397 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_seconds + = ( yyvsp [ - 1 ] . textintval ) . value * ( yyvsp [ 0 ] . intval ) ; }
# line 1778 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 50 :
2018-03-23 11:30:27 +03:00
# line 399 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_seconds + = ( yyvsp [ - 1 ] . textintval ) . value * ( yyvsp [ 0 ] . intval ) ; }
# line 1784 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 51 :
2018-03-23 11:30:27 +03:00
# line 401 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ pc - > rel_seconds + = ( yyvsp [ 0 ] . intval ) ; }
# line 1790 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 52 :
2018-03-23 11:30:27 +03:00
# line 406 "source3 / modules / getdate.y" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
if ( pc - > dates_seen
& & ! pc - > rels_seen & & ( pc - > times_seen | | 2 < ( yyvsp [ 0 ] . textintval ) . digits ) )
pc - > year = ( yyvsp [ 0 ] . textintval ) ;
2003-08-12 08:35:47 +04:00
else
{
2018-03-23 11:30:27 +03:00
if ( 4 < ( yyvsp [ 0 ] . textintval ) . digits )
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > dates_seen + + ;
pc - > day = ( yyvsp [ 0 ] . textintval ) . value % 100 ;
pc - > month = ( ( yyvsp [ 0 ] . textintval ) . value / 100 ) % 100 ;
pc - > year . value = ( yyvsp [ 0 ] . textintval ) . value / 10000 ;
pc - > year . digits = ( yyvsp [ 0 ] . textintval ) . digits - 4 ;
2003-08-12 08:35:47 +04:00
}
else
{
2018-03-23 11:30:27 +03:00
pc - > times_seen + + ;
if ( ( yyvsp [ 0 ] . textintval ) . digits < = 2 )
2003-08-12 08:35:47 +04:00
{
2018-03-23 11:30:27 +03:00
pc - > hour = ( yyvsp [ 0 ] . textintval ) . value ;
pc - > minutes = 0 ;
2003-08-12 08:35:47 +04:00
}
else
{
2018-03-23 11:30:27 +03:00
pc - > hour = ( yyvsp [ 0 ] . textintval ) . value / 100 ;
pc - > minutes = ( yyvsp [ 0 ] . textintval ) . value % 100 ;
2003-08-12 08:35:47 +04:00
}
2018-03-23 11:30:27 +03:00
pc - > seconds = 0 ;
pc - > meridian = MER24 ;
2003-08-12 08:35:47 +04:00
}
}
2018-03-23 11:30:27 +03:00
}
# line 1827 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 53 :
2018-03-23 11:30:27 +03:00
# line 442 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ ( yyval . intval ) = MER24 ; }
# line 1833 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
case 54 :
2018-03-23 11:30:27 +03:00
# line 444 "source3 / modules / getdate.y" /* yacc.c:1646 */
{ ( yyval . intval ) = ( yyvsp [ 0 ] . intval ) ; }
# line 1839 "source3 / modules / getdate.c" /* yacc.c:1646 */
2003-08-12 08:35:47 +04:00
break ;
2018-03-23 11:30:27 +03:00
# line 1843 "source3 / modules / getdate.c" /* yacc.c:1646 */
2008-12-16 09:34:07 +03:00
default : break ;
2003-08-12 08:35:47 +04:00
}
2018-03-23 11:30:27 +03:00
/* User semantic actions sometimes alter yychar, and that requires
that yytoken be updated with the new translation . We take the
approach of translating immediately before every use of yytoken .
One alternative is translating here after every semantic action ,
but that translation would be missed if the semantic action invokes
YYABORT , YYACCEPT , or YYERROR immediately after altering yychar or
if it invokes YYBACKUP . In the case of YYABORT or YYACCEPT , an
incorrect destructor might then be invoked immediately . In the
case of YYERROR or YYBACKUP , subsequent parser actions might lead
to an incorrect destructor call or verbose syntax error message
before the lookahead is translated . */
2008-12-16 09:34:07 +03:00
YY_SYMBOL_PRINT ( " -> $$ = " , yyr1 [ yyn ] , & yyval , & yyloc ) ;
2003-08-12 08:35:47 +04:00
2008-12-16 09:34:07 +03:00
YYPOPSTACK ( yylen ) ;
yylen = 0 ;
2003-08-12 08:35:47 +04:00
YY_STACK_PRINT ( yyss , yyssp ) ;
* + + yyvsp = yyval ;
2018-03-23 11:30:27 +03:00
/* Now 'shift' the result of the reduction. Determine what state
2003-08-12 08:35:47 +04:00
that goes to , based on the state we popped back to and the rule
number reduced by . */
yyn = yyr1 [ yyn ] ;
yystate = yypgoto [ yyn - YYNTOKENS ] + * yyssp ;
if ( 0 < = yystate & & yystate < = YYLAST & & yycheck [ yystate ] = = * yyssp )
yystate = yytable [ yystate ] ;
else
yystate = yydefgoto [ yyn - YYNTOKENS ] ;
goto yynewstate ;
2018-03-23 11:30:27 +03:00
/*--------------------------------------.
| yyerrlab - - here on detecting error . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2003-08-12 08:35:47 +04:00
yyerrlab :
2018-03-23 11:30:27 +03:00
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary . */
yytoken = yychar = = YYEMPTY ? YYEMPTY : YYTRANSLATE ( yychar ) ;
2003-08-12 08:35:47 +04:00
/* If not already recovering from an error, report this error. */
if ( ! yyerrstatus )
{
+ + yynerrs ;
2008-12-16 09:34:07 +03:00
# if ! YYERROR_VERBOSE
2018-03-23 11:30:27 +03:00
yyerror ( pc , YY_ ( " syntax error " ) ) ;
2008-12-16 09:34:07 +03:00
# else
2018-03-23 11:30:27 +03:00
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
yyssp , yytoken )
2008-12-16 09:34:07 +03:00
{
2018-03-23 11:30:27 +03:00
char const * yymsgp = YY_ ( " syntax error " ) ;
int yysyntax_error_status ;
yysyntax_error_status = YYSYNTAX_ERROR ;
if ( yysyntax_error_status = = 0 )
yymsgp = yymsg ;
else if ( yysyntax_error_status = = 1 )
{
if ( yymsg ! = yymsgbuf )
YYSTACK_FREE ( yymsg ) ;
yymsg = ( char * ) YYSTACK_ALLOC ( yymsg_alloc ) ;
if ( ! yymsg )
{
yymsg = yymsgbuf ;
yymsg_alloc = sizeof yymsgbuf ;
yysyntax_error_status = 2 ;
}
else
{
yysyntax_error_status = YYSYNTAX_ERROR ;
yymsgp = yymsg ;
}
}
yyerror ( pc , yymsgp ) ;
if ( yysyntax_error_status = = 2 )
goto yyexhaustedlab ;
2008-12-16 09:34:07 +03:00
}
2018-03-23 11:30:27 +03:00
# undef YYSYNTAX_ERROR
2008-12-16 09:34:07 +03:00
# endif
2003-08-12 08:35:47 +04:00
}
if ( yyerrstatus = = 3 )
{
2018-03-23 11:30:27 +03:00
/* If just tried and failed to reuse lookahead token after an
error , discard it . */
2003-08-12 08:35:47 +04:00
2008-12-16 09:34:07 +03:00
if ( yychar < = YYEOF )
2018-03-23 11:30:27 +03:00
{
/* Return failure if at end of input. */
if ( yychar = = YYEOF )
YYABORT ;
}
2008-12-16 09:34:07 +03:00
else
2018-03-23 11:30:27 +03:00
{
yydestruct ( " Error: discarding " ,
yytoken , & yylval , pc ) ;
yychar = YYEMPTY ;
}
2003-08-12 08:35:47 +04:00
}
2018-03-23 11:30:27 +03:00
/* Else will try to reuse lookahead token after shifting the error
2003-08-12 08:35:47 +04:00
token . */
goto yyerrlab1 ;
2008-12-16 09:34:07 +03:00
/*---------------------------------------------------.
| yyerrorlab - - error raised explicitly by YYERROR . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
yyerrorlab :
/* Pacify compilers like GCC when the user code never invokes
YYERROR and the label yyerrorlab therefore never appears in user
code . */
if ( /*CONSTCOND*/ 0 )
goto yyerrorlab ;
2018-03-23 11:30:27 +03:00
/* Do not reclaim the symbols of the rule whose action triggered
2008-12-16 09:34:07 +03:00
this YYERROR . */
YYPOPSTACK ( yylen ) ;
yylen = 0 ;
YY_STACK_PRINT ( yyss , yyssp ) ;
yystate = * yyssp ;
goto yyerrlab1 ;
/*-------------------------------------------------------------.
| yyerrlab1 - - common code for both syntax error and YYERROR . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2003-08-12 08:35:47 +04:00
yyerrlab1 :
2018-03-23 11:30:27 +03:00
yyerrstatus = 3 ; /* Each real token shifted decrements this. */
2003-08-12 08:35:47 +04:00
for ( ; ; )
{
yyn = yypact [ yystate ] ;
2018-03-23 11:30:27 +03:00
if ( ! yypact_value_is_default ( yyn ) )
{
yyn + = YYTERROR ;
if ( 0 < = yyn & & yyn < = YYLAST & & yycheck [ yyn ] = = YYTERROR )
{
yyn = yytable [ yyn ] ;
if ( 0 < yyn )
break ;
}
}
2003-08-12 08:35:47 +04:00
/* Pop the current state because it cannot handle the error token. */
if ( yyssp = = yyss )
2018-03-23 11:30:27 +03:00
YYABORT ;
2003-08-12 08:35:47 +04:00
2008-12-16 09:34:07 +03:00
yydestruct ( " Error: popping " ,
2018-03-23 11:30:27 +03:00
yystos [ yystate ] , yyvsp , pc ) ;
2008-12-16 09:34:07 +03:00
YYPOPSTACK ( 1 ) ;
yystate = * yyssp ;
2003-08-12 08:35:47 +04:00
YY_STACK_PRINT ( yyss , yyssp ) ;
}
2018-03-23 11:30:27 +03:00
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2003-08-12 08:35:47 +04:00
* + + yyvsp = yylval ;
2018-03-23 11:30:27 +03:00
YY_IGNORE_MAYBE_UNINITIALIZED_END
2003-08-12 08:35:47 +04:00
2008-12-16 09:34:07 +03:00
/* Shift the error token. */
YY_SYMBOL_PRINT ( " Shifting " , yystos [ yyn ] , yyvsp , yylsp ) ;
2003-08-12 08:35:47 +04:00
yystate = yyn ;
goto yynewstate ;
/*-------------------------------------.
| yyacceptlab - - YYACCEPT comes here . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
yyacceptlab :
yyresult = 0 ;
goto yyreturn ;
/*-----------------------------------.
| yyabortlab - - YYABORT comes here . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
yyabortlab :
yyresult = 1 ;
goto yyreturn ;
2018-03-23 11:30:27 +03:00
# if !defined yyoverflow || YYERROR_VERBOSE
2008-12-16 09:34:07 +03:00
/*-------------------------------------------------.
| yyexhaustedlab - - memory exhaustion comes here . |
` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
yyexhaustedlab :
2018-03-23 11:30:27 +03:00
yyerror ( pc , YY_ ( " memory exhausted " ) ) ;
2003-08-12 08:35:47 +04:00
yyresult = 2 ;
/* Fall through. */
# endif
yyreturn :
2018-03-23 11:30:27 +03:00
if ( yychar ! = YYEMPTY )
{
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary . */
yytoken = YYTRANSLATE ( yychar ) ;
yydestruct ( " Cleanup: discarding lookahead " ,
yytoken , & yylval , pc ) ;
}
/* Do not reclaim the symbols of the rule whose action triggered
2008-12-16 09:34:07 +03:00
this YYABORT or YYACCEPT . */
YYPOPSTACK ( yylen ) ;
YY_STACK_PRINT ( yyss , yyssp ) ;
while ( yyssp ! = yyss )
{
yydestruct ( " Cleanup: popping " ,
2018-03-23 11:30:27 +03:00
yystos [ * yyssp ] , yyvsp , pc ) ;
2008-12-16 09:34:07 +03:00
YYPOPSTACK ( 1 ) ;
}
2003-08-12 08:35:47 +04:00
# ifndef yyoverflow
if ( yyss ! = yyssa )
YYSTACK_FREE ( yyss ) ;
# endif
2008-12-16 09:34:07 +03:00
# if YYERROR_VERBOSE
if ( yymsg ! = yymsgbuf )
YYSTACK_FREE ( yymsg ) ;
# endif
2018-03-23 11:30:27 +03:00
return yyresult ;
2003-08-12 08:35:47 +04:00
}
2018-03-23 11:30:27 +03:00
# line 447 "source3 / modules / getdate.y" /* yacc.c:1906 */
2003-08-12 08:35:47 +04:00
/* Include this file down here because bison inserts code above which
may define - away ` const ' . We want the prototype for get_date to have
the same signature as the function definition . */
2003-08-12 22:57:33 +04:00
# include "modules/getdate.h"
2003-08-12 08:35:47 +04:00
# ifndef gmtime
2008-12-16 09:34:07 +03:00
struct tm * gmtime ( const time_t * ) ;
2003-08-12 08:35:47 +04:00
# endif
# ifndef localtime
2008-12-16 09:34:07 +03:00
struct tm * localtime ( const time_t * ) ;
2003-08-12 08:35:47 +04:00
# endif
# ifndef mktime
2008-12-16 09:34:07 +03:00
time_t mktime ( struct tm * ) ;
2003-08-12 08:35:47 +04:00
# endif
static table const meridian_table [ ] =
{
{ " AM " , tMERIDIAN , MERam } ,
{ " A.M. " , tMERIDIAN , MERam } ,
{ " PM " , tMERIDIAN , MERpm } ,
{ " P.M. " , tMERIDIAN , MERpm } ,
{ 0 , 0 , 0 }
} ;
static table const dst_table [ ] =
{
{ " DST " , tDST , 0 }
} ;
static table const month_and_day_table [ ] =
{
{ " JANUARY " , tMONTH , 1 } ,
{ " FEBRUARY " , tMONTH , 2 } ,
{ " MARCH " , tMONTH , 3 } ,
{ " APRIL " , tMONTH , 4 } ,
{ " MAY " , tMONTH , 5 } ,
{ " JUNE " , tMONTH , 6 } ,
{ " JULY " , tMONTH , 7 } ,
{ " AUGUST " , tMONTH , 8 } ,
{ " SEPTEMBER " , tMONTH , 9 } ,
{ " SEPT " , tMONTH , 9 } ,
{ " OCTOBER " , tMONTH , 10 } ,
{ " NOVEMBER " , tMONTH , 11 } ,
{ " DECEMBER " , tMONTH , 12 } ,
{ " SUNDAY " , tDAY , 0 } ,
{ " MONDAY " , tDAY , 1 } ,
{ " TUESDAY " , tDAY , 2 } ,
{ " TUES " , tDAY , 2 } ,
{ " WEDNESDAY " , tDAY , 3 } ,
{ " WEDNES " , tDAY , 3 } ,
{ " THURSDAY " , tDAY , 4 } ,
{ " THUR " , tDAY , 4 } ,
{ " THURS " , tDAY , 4 } ,
{ " FRIDAY " , tDAY , 5 } ,
{ " SATURDAY " , tDAY , 6 } ,
{ 0 , 0 , 0 }
} ;
static table const time_units_table [ ] =
{
{ " YEAR " , tYEAR_UNIT , 1 } ,
{ " MONTH " , tMONTH_UNIT , 1 } ,
{ " FORTNIGHT " , tDAY_UNIT , 14 } ,
{ " WEEK " , tDAY_UNIT , 7 } ,
{ " DAY " , tDAY_UNIT , 1 } ,
{ " HOUR " , tHOUR_UNIT , 1 } ,
{ " MINUTE " , tMINUTE_UNIT , 1 } ,
{ " MIN " , tMINUTE_UNIT , 1 } ,
{ " SECOND " , tSEC_UNIT , 1 } ,
{ " SEC " , tSEC_UNIT , 1 } ,
{ 0 , 0 , 0 }
} ;
/* Assorted relative-time words. */
static table const relative_time_table [ ] =
{
{ " TOMORROW " , tMINUTE_UNIT , 24 * 60 } ,
{ " YESTERDAY " , tMINUTE_UNIT , - ( 24 * 60 ) } ,
{ " TODAY " , tMINUTE_UNIT , 0 } ,
{ " NOW " , tMINUTE_UNIT , 0 } ,
{ " LAST " , tUNUMBER , - 1 } ,
{ " THIS " , tUNUMBER , 0 } ,
{ " NEXT " , tUNUMBER , 1 } ,
{ " FIRST " , tUNUMBER , 1 } ,
/*{ "SECOND", tUNUMBER, 2 }, */
{ " THIRD " , tUNUMBER , 3 } ,
{ " FOURTH " , tUNUMBER , 4 } ,
{ " FIFTH " , tUNUMBER , 5 } ,
{ " SIXTH " , tUNUMBER , 6 } ,
{ " SEVENTH " , tUNUMBER , 7 } ,
{ " EIGHTH " , tUNUMBER , 8 } ,
{ " NINTH " , tUNUMBER , 9 } ,
{ " TENTH " , tUNUMBER , 10 } ,
{ " ELEVENTH " , tUNUMBER , 11 } ,
{ " TWELFTH " , tUNUMBER , 12 } ,
{ " AGO " , tAGO , 1 } ,
{ 0 , 0 , 0 }
} ;
/* The time zone table. This table is necessarily incomplete, as time
zone abbreviations are ambiguous ; e . g . Australians interpret " EST "
as Eastern time in Australia , not as US Eastern Standard Time .
You cannot rely on getdate to handle arbitrary time zone
abbreviations ; use numeric abbreviations like ` - 0500 ' instead . */
static table const time_zone_table [ ] =
{
{ " GMT " , tZONE , HOUR ( 0 ) } , /* Greenwich Mean */
{ " UT " , tZONE , HOUR ( 0 ) } , /* Universal (Coordinated) */
{ " UTC " , tZONE , HOUR ( 0 ) } ,
{ " WET " , tZONE , HOUR ( 0 ) } , /* Western European */
{ " WEST " , tDAYZONE , HOUR ( 0 ) } , /* Western European Summer */
{ " BST " , tDAYZONE , HOUR ( 0 ) } , /* British Summer */
{ " ART " , tZONE , - HOUR ( 3 ) } , /* Argentina */
{ " BRT " , tZONE , - HOUR ( 3 ) } , /* Brazil */
{ " BRST " , tDAYZONE , - HOUR ( 3 ) } , /* Brazil Summer */
{ " NST " , tZONE , - ( HOUR ( 3 ) + 30 ) } , /* Newfoundland Standard */
{ " NDT " , tDAYZONE , - ( HOUR ( 3 ) + 30 ) } , /* Newfoundland Daylight */
{ " AST " , tZONE , - HOUR ( 4 ) } , /* Atlantic Standard */
{ " ADT " , tDAYZONE , - HOUR ( 4 ) } , /* Atlantic Daylight */
{ " CLT " , tZONE , - HOUR ( 4 ) } , /* Chile */
{ " CLST " , tDAYZONE , - HOUR ( 4 ) } , /* Chile Summer */
{ " EST " , tZONE , - HOUR ( 5 ) } , /* Eastern Standard */
{ " EDT " , tDAYZONE , - HOUR ( 5 ) } , /* Eastern Daylight */
{ " CST " , tZONE , - HOUR ( 6 ) } , /* Central Standard */
{ " CDT " , tDAYZONE , - HOUR ( 6 ) } , /* Central Daylight */
{ " MST " , tZONE , - HOUR ( 7 ) } , /* Mountain Standard */
{ " MDT " , tDAYZONE , - HOUR ( 7 ) } , /* Mountain Daylight */
{ " PST " , tZONE , - HOUR ( 8 ) } , /* Pacific Standard */
{ " PDT " , tDAYZONE , - HOUR ( 8 ) } , /* Pacific Daylight */
{ " AKST " , tZONE , - HOUR ( 9 ) } , /* Alaska Standard */
{ " AKDT " , tDAYZONE , - HOUR ( 9 ) } , /* Alaska Daylight */
{ " HST " , tZONE , - HOUR ( 10 ) } , /* Hawaii Standard */
{ " HAST " , tZONE , - HOUR ( 10 ) } , /* Hawaii-Aleutian Standard */
{ " HADT " , tDAYZONE , - HOUR ( 10 ) } , /* Hawaii-Aleutian Daylight */
{ " SST " , tZONE , - HOUR ( 12 ) } , /* Samoa Standard */
{ " WAT " , tZONE , HOUR ( 1 ) } , /* West Africa */
{ " CET " , tZONE , HOUR ( 1 ) } , /* Central European */
{ " CEST " , tDAYZONE , HOUR ( 1 ) } , /* Central European Summer */
{ " MET " , tZONE , HOUR ( 1 ) } , /* Middle European */
{ " MEZ " , tZONE , HOUR ( 1 ) } , /* Middle European */
{ " MEST " , tDAYZONE , HOUR ( 1 ) } , /* Middle European Summer */
{ " MESZ " , tDAYZONE , HOUR ( 1 ) } , /* Middle European Summer */
{ " EET " , tZONE , HOUR ( 2 ) } , /* Eastern European */
{ " EEST " , tDAYZONE , HOUR ( 2 ) } , /* Eastern European Summer */
{ " CAT " , tZONE , HOUR ( 2 ) } , /* Central Africa */
{ " SAST " , tZONE , HOUR ( 2 ) } , /* South Africa Standard */
{ " EAT " , tZONE , HOUR ( 3 ) } , /* East Africa */
{ " MSK " , tZONE , HOUR ( 3 ) } , /* Moscow */
{ " MSD " , tDAYZONE , HOUR ( 3 ) } , /* Moscow Daylight */
{ " IST " , tZONE , ( HOUR ( 5 ) + 30 ) } , /* India Standard */
{ " SGT " , tZONE , HOUR ( 8 ) } , /* Singapore */
{ " KST " , tZONE , HOUR ( 9 ) } , /* Korea Standard */
{ " JST " , tZONE , HOUR ( 9 ) } , /* Japan Standard */
{ " GST " , tZONE , HOUR ( 10 ) } , /* Guam Standard */
{ " NZST " , tZONE , HOUR ( 12 ) } , /* New Zealand Standard */
{ " NZDT " , tDAYZONE , HOUR ( 12 ) } , /* New Zealand Daylight */
{ 0 , 0 , 0 }
} ;
/* Military time zone table. */
static table const military_table [ ] =
{
{ " A " , tZONE , - HOUR ( 1 ) } ,
{ " B " , tZONE , - HOUR ( 2 ) } ,
{ " C " , tZONE , - HOUR ( 3 ) } ,
{ " D " , tZONE , - HOUR ( 4 ) } ,
{ " E " , tZONE , - HOUR ( 5 ) } ,
{ " F " , tZONE , - HOUR ( 6 ) } ,
{ " G " , tZONE , - HOUR ( 7 ) } ,
{ " H " , tZONE , - HOUR ( 8 ) } ,
{ " I " , tZONE , - HOUR ( 9 ) } ,
{ " K " , tZONE , - HOUR ( 10 ) } ,
{ " L " , tZONE , - HOUR ( 11 ) } ,
{ " M " , tZONE , - HOUR ( 12 ) } ,
{ " N " , tZONE , HOUR ( 1 ) } ,
{ " O " , tZONE , HOUR ( 2 ) } ,
{ " P " , tZONE , HOUR ( 3 ) } ,
{ " Q " , tZONE , HOUR ( 4 ) } ,
{ " R " , tZONE , HOUR ( 5 ) } ,
{ " S " , tZONE , HOUR ( 6 ) } ,
{ " T " , tZONE , HOUR ( 7 ) } ,
{ " U " , tZONE , HOUR ( 8 ) } ,
{ " V " , tZONE , HOUR ( 9 ) } ,
{ " W " , tZONE , HOUR ( 10 ) } ,
{ " X " , tZONE , HOUR ( 11 ) } ,
{ " Y " , tZONE , HOUR ( 12 ) } ,
{ " Z " , tZONE , HOUR ( 0 ) } ,
{ 0 , 0 , 0 }
} ;
static int
to_hour ( int hours , int meridian )
{
switch ( meridian )
{
case MER24 :
return 0 < = hours & & hours < 24 ? hours : - 1 ;
case MERam :
return 0 < hours & & hours < 12 ? hours : hours = = 12 ? 0 : - 1 ;
case MERpm :
return 0 < hours & & hours < 12 ? hours + 12 : hours = = 12 ? 12 : - 1 ;
default :
abort ( ) ;
}
/* NOTREACHED */
2003-08-15 05:42:30 +04:00
return 0 ;
2003-08-12 08:35:47 +04:00
}
static int
to_year ( textint textyear )
{
int year = textyear . value ;
if ( year < 0 )
year = - year ;
/* XPG4 suggests that years 00-68 map to 2000-2068, and
years 69 - 99 map to 1969 - 1999. */
if ( textyear . digits = = 2 )
year + = year < 69 ? 2000 : 1900 ;
return year ;
}
static table const *
2018-03-23 11:30:27 +03:00
lookup_zone ( struct parser_control const * pc , char const * name )
2003-08-12 08:35:47 +04:00
{
table const * tp ;
/* Try local zone abbreviations first; they're more likely to be right. */
for ( tp = pc - > local_time_zone_table ; tp - > name ; tp + + )
if ( strcmp ( name , tp - > name ) = = 0 )
return tp ;
for ( tp = time_zone_table ; tp - > name ; tp + + )
if ( strcmp ( name , tp - > name ) = = 0 )
return tp ;
return 0 ;
}
# if ! HAVE_TM_GMTOFF
/* Yield the difference between *A and *B,
measured in seconds , ignoring leap seconds .
The body of this function is taken directly from the GNU C Library ;
see src / strftime . c . */
static int
tm_diff ( struct tm const * a , struct tm const * b )
{
/* Compute intervening leap days correctly even if year is negative.
Take care to avoid int overflow in leap day calculations ,
but it ' s OK to assume that A and B are close to each other . */
int a4 = ( a - > tm_year > > 2 ) + ( TM_YEAR_BASE > > 2 ) - ! ( a - > tm_year & 3 ) ;
int b4 = ( b - > tm_year > > 2 ) + ( TM_YEAR_BASE > > 2 ) - ! ( b - > tm_year & 3 ) ;
int a100 = a4 / 25 - ( a4 % 25 < 0 ) ;
int b100 = b4 / 25 - ( b4 % 25 < 0 ) ;
int a400 = a100 > > 2 ;
int b400 = b100 > > 2 ;
int intervening_leap_days = ( a4 - b4 ) - ( a100 - b100 ) + ( a400 - b400 ) ;
int years = a - > tm_year - b - > tm_year ;
int days = ( 365 * years + intervening_leap_days
+ ( a - > tm_yday - b - > tm_yday ) ) ;
return ( 60 * ( 60 * ( 24 * days + ( a - > tm_hour - b - > tm_hour ) )
+ ( a - > tm_min - b - > tm_min ) )
+ ( a - > tm_sec - b - > tm_sec ) ) ;
}
# endif /* ! HAVE_TM_GMTOFF */
static table const *
2018-03-23 11:30:27 +03:00
lookup_word ( struct parser_control const * pc , char * word )
2003-08-12 08:35:47 +04:00
{
char * p ;
char * q ;
size_t wordlen ;
table const * tp ;
int i ;
int abbrev ;
/* Make it uppercase. */
for ( p = word ; * p ; p + + )
if ( ISLOWER ( ( unsigned char ) * p ) )
* p = toupper ( ( unsigned char ) * p ) ;
for ( tp = meridian_table ; tp - > name ; tp + + )
if ( strcmp ( word , tp - > name ) = = 0 )
return tp ;
/* See if we have an abbreviation for a month. */
wordlen = strlen ( word ) ;
abbrev = wordlen = = 3 | | ( wordlen = = 4 & & word [ 3 ] = = ' . ' ) ;
for ( tp = month_and_day_table ; tp - > name ; tp + + )
if ( ( abbrev ? strncmp ( word , tp - > name , 3 ) : strcmp ( word , tp - > name ) ) = = 0 )
return tp ;
if ( ( tp = lookup_zone ( pc , word ) ) )
return tp ;
if ( strcmp ( word , dst_table [ 0 ] . name ) = = 0 )
return dst_table ;
for ( tp = time_units_table ; tp - > name ; tp + + )
if ( strcmp ( word , tp - > name ) = = 0 )
return tp ;
/* Strip off any plural and try the units table again. */
if ( word [ wordlen - 1 ] = = ' S ' )
{
word [ wordlen - 1 ] = ' \0 ' ;
for ( tp = time_units_table ; tp - > name ; tp + + )
if ( strcmp ( word , tp - > name ) = = 0 )
return tp ;
word [ wordlen - 1 ] = ' S ' ; /* For "this" in relative_time_table. */
}
for ( tp = relative_time_table ; tp - > name ; tp + + )
if ( strcmp ( word , tp - > name ) = = 0 )
return tp ;
/* Military time zones. */
if ( wordlen = = 1 )
for ( tp = military_table ; tp - > name ; tp + + )
if ( word [ 0 ] = = tp - > name [ 0 ] )
return tp ;
/* Drop out any periods and try the time zone table again. */
for ( i = 0 , p = q = word ; ( * p = * q ) ; q + + )
if ( * q = = ' . ' )
i = 1 ;
else
p + + ;
if ( i & & ( tp = lookup_zone ( pc , word ) ) )
return tp ;
return 0 ;
}
static int
2018-03-23 11:30:27 +03:00
yylex ( YYSTYPE * lvalp , struct parser_control * pc )
2003-08-12 08:35:47 +04:00
{
unsigned char c ;
2017-12-07 22:07:08 +03:00
size_t count ;
2003-08-12 08:35:47 +04:00
for ( ; ; )
{
while ( c = * pc - > input , ISSPACE ( c ) )
pc - > input + + ;
if ( ISDIGIT ( c ) | | c = = ' - ' | | c = = ' + ' )
{
char const * p ;
int sign ;
int value ;
if ( c = = ' - ' | | c = = ' + ' )
{
sign = c = = ' - ' ? - 1 : 1 ;
c = * + + pc - > input ;
if ( ! ISDIGIT ( c ) )
/* skip the '-' sign */
continue ;
}
else
sign = 0 ;
p = pc - > input ;
value = 0 ;
do
{
value = 10 * value + c - ' 0 ' ;
c = * + + p ;
}
while ( ISDIGIT ( c ) ) ;
lvalp - > textintval . value = sign < 0 ? - value : value ;
lvalp - > textintval . digits = p - pc - > input ;
pc - > input = p ;
return sign ? tSNUMBER : tUNUMBER ;
}
if ( ISALPHA ( c ) )
{
char buff [ 20 ] ;
2018-03-23 11:30:27 +03:00
size_t i = 0 ;
2003-08-12 08:35:47 +04:00
table const * tp ;
do
{
2018-03-23 11:30:27 +03:00
if ( i < 20 )
buff [ i + + ] = c ;
2003-08-12 08:35:47 +04:00
c = * + + pc - > input ;
}
while ( ISALPHA ( c ) | | c = = ' . ' ) ;
2018-03-23 11:30:27 +03:00
buff [ i ] = ' \0 ' ;
2003-08-12 08:35:47 +04:00
tp = lookup_word ( pc , buff ) ;
if ( ! tp )
return ' ? ' ;
lvalp - > intval = tp - > value ;
return tp - > type ;
}
if ( c ! = ' ( ' )
return * pc - > input + + ;
count = 0 ;
do
{
c = * pc - > input + + ;
if ( c = = ' \0 ' )
return c ;
if ( c = = ' ( ' )
count + + ;
else if ( c = = ' ) ' )
count - - ;
}
while ( count > 0 ) ;
}
}
/* Do nothing if the parser reports an error. */
static int
2018-03-23 11:30:27 +03:00
yyerror ( struct parser_control * pc ATTRIBUTE_UNUSED , const char * s ATTRIBUTE_UNUSED )
2003-08-12 08:35:47 +04:00
{
return 0 ;
}
/* Parse a date/time string P. Return the corresponding time_t value,
or ( time_t ) - 1 if there is an error . P can be an incomplete or
relative time specification ; if so , use * NOW as the basis for the
returned time . */
time_t
get_date ( const char * p , const time_t * now )
{
time_t Start = now ? * now : time ( 0 ) ;
struct tm * tmp = localtime ( & Start ) ;
struct tm tm ;
struct tm tm0 ;
2018-03-23 11:30:27 +03:00
struct parser_control pc ;
2003-08-12 08:35:47 +04:00
if ( ! tmp )
return - 1 ;
pc . input = p ;
pc . year . value = tmp - > tm_year + TM_YEAR_BASE ;
pc . year . digits = 4 ;
pc . month = tmp - > tm_mon + 1 ;
pc . day = tmp - > tm_mday ;
pc . hour = tmp - > tm_hour ;
pc . minutes = tmp - > tm_min ;
pc . seconds = tmp - > tm_sec ;
tm . tm_isdst = tmp - > tm_isdst ;
pc . meridian = MER24 ;
pc . rel_seconds = 0 ;
pc . rel_minutes = 0 ;
pc . rel_hour = 0 ;
pc . rel_day = 0 ;
pc . rel_month = 0 ;
pc . rel_year = 0 ;
pc . dates_seen = 0 ;
pc . days_seen = 0 ;
pc . rels_seen = 0 ;
pc . times_seen = 0 ;
pc . local_zones_seen = 0 ;
pc . zones_seen = 0 ;
# if HAVE_STRUCT_TM_TM_ZONE
pc . local_time_zone_table [ 0 ] . name = tmp - > tm_zone ;
pc . local_time_zone_table [ 0 ] . type = tLOCAL_ZONE ;
pc . local_time_zone_table [ 0 ] . value = tmp - > tm_isdst ;
pc . local_time_zone_table [ 1 ] . name = 0 ;
/* Probe the names used in the next three calendar quarters, looking
for a tm_isdst different from the one we already have . */
{
int quarter ;
for ( quarter = 1 ; quarter < = 3 ; quarter + + )
{
time_t probe = Start + quarter * ( 90 * 24 * 60 * 60 ) ;
struct tm * probe_tm = localtime ( & probe ) ;
if ( probe_tm & & probe_tm - > tm_zone
& & probe_tm - > tm_isdst ! = pc . local_time_zone_table [ 0 ] . value )
{
{
pc . local_time_zone_table [ 1 ] . name = probe_tm - > tm_zone ;
pc . local_time_zone_table [ 1 ] . type = tLOCAL_ZONE ;
pc . local_time_zone_table [ 1 ] . value = probe_tm - > tm_isdst ;
pc . local_time_zone_table [ 2 ] . name = 0 ;
}
break ;
}
}
}
# else
# if HAVE_TZNAME
{
# ifndef tzname
extern char * tzname [ ] ;
# endif
int i ;
for ( i = 0 ; i < 2 ; i + + )
{
pc . local_time_zone_table [ i ] . name = tzname [ i ] ;
pc . local_time_zone_table [ i ] . type = tLOCAL_ZONE ;
pc . local_time_zone_table [ i ] . value = i ;
}
pc . local_time_zone_table [ i ] . name = 0 ;
}
# else
pc . local_time_zone_table [ 0 ] . name = 0 ;
# endif
# endif
if ( pc . local_time_zone_table [ 0 ] . name & & pc . local_time_zone_table [ 1 ] . name
& & ! strcmp ( pc . local_time_zone_table [ 0 ] . name ,
pc . local_time_zone_table [ 1 ] . name ) )
{
/* This locale uses the same abbrevation for standard and
daylight times . So if we see that abbreviation , we don ' t
know whether it ' s daylight time . */
pc . local_time_zone_table [ 0 ] . value = - 1 ;
pc . local_time_zone_table [ 1 ] . name = 0 ;
}
if ( yyparse ( & pc ) ! = 0
| | 1 < pc . times_seen | | 1 < pc . dates_seen | | 1 < pc . days_seen
| | 1 < ( pc . local_zones_seen + pc . zones_seen )
| | ( pc . local_zones_seen & & 1 < pc . local_isdst ) )
return - 1 ;
tm . tm_year = to_year ( pc . year ) - TM_YEAR_BASE + pc . rel_year ;
tm . tm_mon = pc . month - 1 + pc . rel_month ;
tm . tm_mday = pc . day + pc . rel_day ;
if ( pc . times_seen | | ( pc . rels_seen & & ! pc . dates_seen & & ! pc . days_seen ) )
{
tm . tm_hour = to_hour ( pc . hour , pc . meridian ) ;
if ( tm . tm_hour < 0 )
return - 1 ;
tm . tm_min = pc . minutes ;
tm . tm_sec = pc . seconds ;
}
else
{
tm . tm_hour = tm . tm_min = tm . tm_sec = 0 ;
}
/* Let mktime deduce tm_isdst if we have an absolute time stamp,
or if the relative time stamp mentions days , months , or years . */
if ( pc . dates_seen | pc . days_seen | pc . times_seen | pc . rel_day
| pc . rel_month | pc . rel_year )
tm . tm_isdst = - 1 ;
/* But if the input explicitly specifies local time with or without
DST , give mktime that information . */
if ( pc . local_zones_seen )
tm . tm_isdst = pc . local_isdst ;
tm0 = tm ;
Start = mktime ( & tm ) ;
if ( Start = = ( time_t ) - 1 )
{
/* Guard against falsely reporting errors near the time_t boundaries
when parsing times in other time zones . For example , if the min
time_t value is 1970 - 01 - 01 00 : 00 : 00 UTC and we are 8 hours ahead
of UTC , then the min localtime value is 1970 - 01 - 01 08 : 00 : 00 ; if
we apply mktime to 1970 - 01 - 01 00 : 00 : 00 we will get an error , so
we apply mktime to 1970 - 01 - 02 08 : 00 : 00 instead and adjust the time
zone by 24 hours to compensate . This algorithm assumes that
there is no DST transition within a day of the time_t boundaries . */
if ( pc . zones_seen )
{
tm = tm0 ;
if ( tm . tm_year < = EPOCH_YEAR - TM_YEAR_BASE )
{
tm . tm_mday + + ;
pc . time_zone + = 24 * 60 ;
}
else
{
tm . tm_mday - - ;
pc . time_zone - = 24 * 60 ;
}
Start = mktime ( & tm ) ;
}
if ( Start = = ( time_t ) - 1 )
return Start ;
}
if ( pc . days_seen & & ! pc . dates_seen )
{
tm . tm_mday + = ( ( pc . day_number - tm . tm_wday + 7 ) % 7
+ 7 * ( pc . day_ordinal - ( 0 < pc . day_ordinal ) ) ) ;
tm . tm_isdst = - 1 ;
Start = mktime ( & tm ) ;
if ( Start = = ( time_t ) - 1 )
return Start ;
}
if ( pc . zones_seen )
{
int delta = pc . time_zone * 60 ;
# ifdef HAVE_TM_GMTOFF
delta - = tm . tm_gmtoff ;
# else
struct tm * gmt = gmtime ( & Start ) ;
if ( ! gmt )
return - 1 ;
delta - = tm_diff ( & tm , gmt ) ;
# endif
if ( ( Start < Start - delta ) ! = ( delta < 0 ) )
return - 1 ; /* time_t overflow */
Start - = delta ;
}
/* Add relative hours, minutes, and seconds. Ignore leap seconds;
i . e . " + 10 minutes " means 600 seconds , even if one of them is a
leap second . Typically this is not what the user wants , but it ' s
too hard to do it the other way , because the time zone indicator
must be applied before relative times , and if mktime is applied
again the time zone will be lost . */
{
time_t t0 = Start ;
long d1 = 60 * 60 * ( long ) pc . rel_hour ;
time_t t1 = t0 + d1 ;
long d2 = 60 * ( long ) pc . rel_minutes ;
time_t t2 = t1 + d2 ;
int d3 = pc . rel_seconds ;
time_t t3 = t2 + d3 ;
if ( ( d1 / ( 60 * 60 ) ^ pc . rel_hour )
| ( d2 / 60 ^ pc . rel_minutes )
| ( ( t0 + d1 < t0 ) ^ ( d1 < 0 ) )
| ( ( t1 + d2 < t1 ) ^ ( d2 < 0 ) )
| ( ( t2 + d3 < t2 ) ^ ( d3 < 0 ) ) )
return - 1 ;
Start = t3 ;
}
return Start ;
}
# if TEST
# include <stdio.h>
int
main ( int ac , char * * av )
{
char buff [ BUFSIZ ] ;
time_t d ;
printf ( " Enter date, or blank line to exit. \n \t > " ) ;
fflush ( stdout ) ;
buff [ BUFSIZ - 1 ] = 0 ;
while ( fgets ( buff , BUFSIZ - 1 , stdin ) & & buff [ 0 ] )
{
d = get_date ( buff , 0 ) ;
if ( d = = ( time_t ) - 1 )
printf ( " Bad format - couldn't convert. \n " ) ;
else
printf ( " %s " , ctime ( & d ) ) ;
printf ( " \t > " ) ;
fflush ( stdout ) ;
}
return 0 ;
}
# endif /* defined TEST */