#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#if defined(vms)
#include <types.h>
#include <time.h>
#else
#include <sys/types.h>
#ifdef TIME_WITH_SYS_TIME
#include <sys/time.h>
#include <time.h>
#else
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#else
#include <time.h>
#endif
#endif
#ifdef timezone
#undef timezone
#endif
#if defined(HAVE_SYS_TIMEB_H)
#include <sys/timeb.h>
#else
struct timeb {
time_t time;
unsigned short millitm;
short timezone;
short dstflag;
};
#endif
#endif
#if defined (STDC_HEADERS) || defined (USG)
#include <string.h>
#endif
#if !defined (HAVE_BCOPY) && defined (HAVE_MEMCPY) && !defined (bcopy)
#define bcopy(from, to, len) memcpy ((to), (from), (len))
#endif
#if defined (STDC_HEADERS)
#include <stdlib.h>
#endif
#if defined (HAVE_ALLOCA_H)
#include <alloca.h>
#endif
extern struct tm *gmtime();
extern struct tm *localtime();
#define yyparse getdate_yyparse
#define yylex getdate_yylex
#define yyerror getdate_yyerror
#if !defined(lint) && !defined(SABER)
static char RCS[] = "$CVSid: @(#)getdate.y 1.11 94/09/21 $";
#endif
static int yylex ();
static int yyerror ();
#define EPOCH 1970
#define HOUR(x) ((time_t)(x) * 60)
#define SECSPERDAY (24L * 60L * 60L)
typedef struct _TABLE {
char *name;
int type;
time_t value;
} TABLE;
typedef enum _DSTMODE {
DSTon, DSToff, DSTmaybe
} DSTMODE;
typedef enum _MERIDIAN {
MERam, MERpm, MER24
} MERIDIAN;
static char *yyInput;
static DSTMODE yyDSTmode;
static time_t yyDayOrdinal;
static time_t yyDayNumber;
static int yyHaveDate;
static int yyHaveDay;
static int yyHaveRel;
static int yyHaveTime;
static int yyHaveZone;
static time_t yyTimezone;
static time_t yyDay;
static time_t yyHour;
static time_t yyMinutes;
static time_t yyMonth;
static time_t yySeconds;
static time_t yyYear;
static MERIDIAN yyMeridian;
static time_t yyRelMonth;
static time_t yyRelSeconds;
typedef union {
time_t Number;
enum _MERIDIAN Meridian;
} YYSTYPE;
# define tAGO 257
# define tDAY 258
# define tDAYZONE 259
# define tID 260
# define tMERIDIAN 261
# define tMINUTE_UNIT 262
# define tMONTH 263
# define tMONTH_UNIT 264
# define tSEC_UNIT 265
# define tSNUMBER 266
# define tUNUMBER 267
# define tZONE 268
# define tDST 269
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern int yyerrflag;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
YYSTYPE yylval, yyval;
# define YYERRCODE 256
static TABLE const MonthDayTable[] = {
{ "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 },
{ NULL }
};
static TABLE const UnitsTable[] = {
{ "year", tMONTH_UNIT, 12 },
{ "month", tMONTH_UNIT, 1 },
{ "fortnight", tMINUTE_UNIT, 14 * 24 * 60 },
{ "week", tMINUTE_UNIT, 7 * 24 * 60 },
{ "day", tMINUTE_UNIT, 1 * 24 * 60 },
{ "hour", tMINUTE_UNIT, 60 },
{ "minute", tMINUTE_UNIT, 1 },
{ "min", tMINUTE_UNIT, 1 },
{ "second", tSEC_UNIT, 1 },
{ "sec", tSEC_UNIT, 1 },
{ NULL }
};
static TABLE const OtherTable[] = {
{ "tomorrow", tMINUTE_UNIT, 1 * 24 * 60 },
{ "yesterday", tMINUTE_UNIT, -1 * 24 * 60 },
{ "today", tMINUTE_UNIT, 0 },
{ "now", tMINUTE_UNIT, 0 },
{ "last", tUNUMBER, -1 },
{ "this", tMINUTE_UNIT, 0 },
{ "next", tUNUMBER, 2 },
{ "first", tUNUMBER, 1 },
{ "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 },
{ NULL }
};
static TABLE const TimezoneTable[] = {
{ "gmt", tZONE, HOUR( 0) },
{ "ut", tZONE, HOUR( 0) },
{ "utc", tZONE, HOUR( 0) },
{ "wet", tZONE, HOUR( 0) },
{ "bst", tDAYZONE, HOUR( 0) },
{ "wat", tZONE, HOUR( 1) },
{ "at", tZONE, HOUR( 2) },
#if 0
{ "bst", tZONE, HOUR( 3) },
{ "gst", tZONE, HOUR( 3) },
#endif
#if 0
{ "nft", tZONE, HOUR(3.5) },
{ "nst", tZONE, HOUR(3.5) },
{ "ndt", tDAYZONE, HOUR(3.5) },
#endif
{ "ast", tZONE, HOUR( 4) },
{ "adt", tDAYZONE, HOUR( 4) },
{ "est", tZONE, HOUR( 5) },
{ "edt", tDAYZONE, HOUR( 5) },
{ "cst", tZONE, HOUR( 6) },
{ "cdt", tDAYZONE, HOUR( 6) },
{ "mst", tZONE, HOUR( 7) },
{ "mdt", tDAYZONE, HOUR( 7) },
{ "pst", tZONE, HOUR( 8) },
{ "pdt", tDAYZONE, HOUR( 8) },
{ "yst", tZONE, HOUR( 9) },
{ "ydt", tDAYZONE, HOUR( 9) },
{ "hst", tZONE, HOUR(10) },
{ "hdt", tDAYZONE, HOUR(10) },
{ "cat", tZONE, HOUR(10) },
{ "ahst", tZONE, HOUR(10) },
{ "nt", tZONE, HOUR(11) },
{ "idlw", tZONE, HOUR(12) },
{ "cet", tZONE, -HOUR(1) },
{ "met", tZONE, -HOUR(1) },
{ "mewt", tZONE, -HOUR(1) },
{ "mest", tDAYZONE, -HOUR(1) },
{ "swt", tZONE, -HOUR(1) },
{ "sst", tDAYZONE, -HOUR(1) },
{ "fwt", tZONE, -HOUR(1) },
{ "fst", tDAYZONE, -HOUR(1) },
{ "eet", tZONE, -HOUR(2) },
{ "bt", tZONE, -HOUR(3) },
#if 0
{ "it", tZONE, -HOUR(3.5) },
#endif
{ "zp4", tZONE, -HOUR(4) },
{ "zp5", tZONE, -HOUR(5) },
#if 0
{ "ist", tZONE, -HOUR(5.5) },
#endif
{ "zp6", tZONE, -HOUR(6) },
#if 0
{ "nst", tZONE, -HOUR(6.5) },
{ "sst", tZONE, -HOUR(7) },
#endif
{ "wast", tZONE, -HOUR(7) },
{ "wadt", tDAYZONE, -HOUR(7) },
#if 0
{ "jt", tZONE, -HOUR(7.5) },
#endif
{ "cct", tZONE, -HOUR(8) },
{ "jst", tZONE, -HOUR(9) },
#if 0
{ "cast", tZONE, -HOUR(9.5) },
{ "cadt", tDAYZONE, -HOUR(9.5) },
#endif
{ "east", tZONE, -HOUR(10) },
{ "eadt", tDAYZONE, -HOUR(10) },
{ "gst", tZONE, -HOUR(10) },
{ "nzt", tZONE, -HOUR(12) },
{ "nzst", tZONE, -HOUR(12) },
{ "nzdt", tDAYZONE, -HOUR(12) },
{ "idle", tZONE, -HOUR(12) },
{ NULL }
};
static TABLE const MilitaryTable[] = {
{ "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) },
{ NULL }
};
static int
yyerror(s)
char *s;
{
return 0;
}
static time_t
ToSeconds(Hours, Minutes, Seconds, Meridian)
time_t Hours;
time_t Minutes;
time_t Seconds;
MERIDIAN Meridian;
{
if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 59)
return -1;
switch (Meridian) {
case MER24:
if (Hours < 0 || Hours > 23)
return -1;
return (Hours * 60L + Minutes) * 60L + Seconds;
case MERam:
if (Hours < 1 || Hours > 12)
return -1;
return (Hours * 60L + Minutes) * 60L + Seconds;
case MERpm:
if (Hours < 1 || Hours > 12)
return -1;
return ((Hours + 12) * 60L + Minutes) * 60L + Seconds;
default:
abort ();
}
}
static time_t
Convert(Month, Day, Year, Hours, Minutes, Seconds, Meridian, DSTmode)
time_t Month;
time_t Day;
time_t Year;
time_t Hours;
time_t Minutes;
time_t Seconds;
MERIDIAN Meridian;
DSTMODE DSTmode;
{
static int DaysInMonth[12] = {
31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
time_t tod;
time_t Julian;
int i;
if (Year < 0)
Year = -Year;
if (Year < 100)
Year += 1900;
DaysInMonth[1] = Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0)
? 29 : 28;
if (Year < EPOCH || Year > 1999
|| Month < 1 || Month > 12
|| Day < 1 || Day > DaysInMonth[(int)--Month])
return -1;
for (Julian = Day - 1, i = 0; i < Month; i++)
Julian += DaysInMonth[i];
for (i = EPOCH; i < Year; i++)
Julian += 365 + (i % 4 == 0);
Julian *= SECSPERDAY;
Julian += yyTimezone * 60L;
if ((tod = ToSeconds(Hours, Minutes, Seconds, Meridian)) < 0)
return -1;
Julian += tod;
if (DSTmode == DSTon
|| (DSTmode == DSTmaybe && localtime(&Julian)->tm_isdst))
Julian -= 60 * 60;
return Julian;
}
static time_t
DSTcorrect(Start, Future)
time_t Start;
time_t Future;
{
time_t StartDay;
time_t FutureDay;
StartDay = (localtime(&Start)->tm_hour + 1) % 24;
FutureDay = (localtime(&Future)->tm_hour + 1) % 24;
return (Future - Start) + (StartDay - FutureDay) * 60L * 60L;
}
static time_t
RelativeDate(Start, DayOrdinal, DayNumber)
time_t Start;
time_t DayOrdinal;
time_t DayNumber;
{
struct tm *tm;
time_t now;
now = Start;
tm = localtime(&now);
now += SECSPERDAY * ((DayNumber - tm->tm_wday + 7) % 7);
now += 7 * SECSPERDAY * (DayOrdinal <= 0 ? DayOrdinal : DayOrdinal - 1);
return DSTcorrect(Start, now);
}
static time_t
RelativeMonth(Start, RelMonth)
time_t Start;
time_t RelMonth;
{
struct tm *tm;
time_t Month;
time_t Year;
if (RelMonth == 0)
return 0;
tm = localtime(&Start);
Month = 12 * tm->tm_year + tm->tm_mon + RelMonth;
Year = Month / 12;
Month = Month % 12 + 1;
return DSTcorrect(Start,
Convert(Month, (time_t)tm->tm_mday, Year,
(time_t)tm->tm_hour, (time_t)tm->tm_min, (time_t)tm->tm_sec,
MER24, DSTmaybe));
}
static int
LookupWord(buff)
char *buff;
{
register char *p;
register char *q;
register const TABLE *tp;
int i;
int abbrev;
for (p = buff; *p; p++)
if (isupper(*p))
*p = tolower(*p);
if (strcmp(buff, "am") == 0 || strcmp(buff, "a.m.") == 0) {
yylval.Meridian = MERam;
return tMERIDIAN;
}
if (strcmp(buff, "pm") == 0 || strcmp(buff, "p.m.") == 0) {
yylval.Meridian = MERpm;
return tMERIDIAN;
}
if (strlen(buff) == 3)
abbrev = 1;
else if (strlen(buff) == 4 && buff[3] == '.') {
abbrev = 1;
buff[3] = '\0';
}
else
abbrev = 0;
for (tp = MonthDayTable; tp->name; tp++) {
if (abbrev) {
if (strncmp(buff, tp->name, 3) == 0) {
yylval.Number = tp->value;
return tp->type;
}
}
else if (strcmp(buff, tp->name) == 0) {
yylval.Number = tp->value;
return tp->type;
}
}
for (tp = TimezoneTable; tp->name; tp++)
if (strcmp(buff, tp->name) == 0) {
yylval.Number = tp->value;
return tp->type;
}
if (strcmp(buff, "dst") == 0)
return tDST;
for (tp = UnitsTable; tp->name; tp++)
if (strcmp(buff, tp->name) == 0) {
yylval.Number = tp->value;
return tp->type;
}
i = strlen(buff) - 1;
if (buff[i] == 's') {
buff[i] = '\0';
for (tp = UnitsTable; tp->name; tp++)
if (strcmp(buff, tp->name) == 0) {
yylval.Number = tp->value;
return tp->type;
}
buff[i] = 's';
}
for (tp = OtherTable; tp->name; tp++)
if (strcmp(buff, tp->name) == 0) {
yylval.Number = tp->value;
return tp->type;
}
if (buff[1] == '\0' && isalpha(*buff)) {
for (tp = MilitaryTable; tp->name; tp++)
if (strcmp(buff, tp->name) == 0) {
yylval.Number = tp->value;
return tp->type;
}
}
for (i = 0, p = q = buff; *q; q++)
if (*q != '.')
*p++ = *q;
else
i++;
*p = '\0';
if (i)
for (tp = TimezoneTable; tp->name; tp++)
if (strcmp(buff, tp->name) == 0) {
yylval.Number = tp->value;
return tp->type;
}
return tID;
}
static int
yylex()
{
register char c;
register char *p;
char buff[20];
int Count;
int sign;
for ( ; ; ) {
while (isspace(*yyInput))
yyInput++;
if (isdigit(c = *yyInput) || c == '-' || c == '+') {
if (c == '-' || c == '+') {
sign = c == '-' ? -1 : 1;
if (!isdigit(*++yyInput))
continue;
}
else
sign = 0;
for (yylval.Number = 0; isdigit(c = *yyInput++); )
yylval.Number = 10 * yylval.Number + c - '0';
yyInput--;
if (sign < 0)
yylval.Number = -yylval.Number;
return sign ? tSNUMBER : tUNUMBER;
}
if (isalpha(c)) {
for (p = buff; isalpha(c = *yyInput++) || c == '.'; )
if (p < &buff[sizeof buff - 1])
*p++ = c;
*p = '\0';
yyInput--;
return LookupWord(buff);
}
if (c != '(')
return *yyInput++;
Count = 0;
do {
c = *yyInput++;
if (c == '\0')
return c;
if (c == '(')
Count++;
else if (c == ')')
Count--;
} while (Count > 0);
}
}
#define TM_YEAR_ORIGIN 1900
static long
difftm (a, b)
struct tm *a, *b;
{
int ay = a->tm_year + (TM_YEAR_ORIGIN - 1);
int by = b->tm_year + (TM_YEAR_ORIGIN - 1);
int days = (
a->tm_yday - b->tm_yday
+ ((ay >> 2) - (by >> 2))
- (ay/100 - by/100)
+ ((ay/100 >> 2) - (by/100 >> 2))
+ (long)(ay-by) * 365
);
return (60*(60*(24*days + (a->tm_hour - b->tm_hour))
+ (a->tm_min - b->tm_min))
+ (a->tm_sec - b->tm_sec));
}
time_t
get_date(p, now)
char *p;
struct timeb *now;
{
struct tm *tm, gmt;
struct timeb ftz;
time_t Start;
time_t tod;
yyInput = p;
if (now == NULL) {
now = &ftz;
(void)time(&ftz.time);
if (! (tm = gmtime (&ftz.time)))
return -1;
gmt = *tm;
if (! (tm = localtime (&ftz.time)))
return -1;
ftz.timezone = difftm (&gmt, tm) / 60;
if(tm->tm_isdst)
ftz.timezone += 60;
}
tm = localtime(&now->time);
yyYear = tm->tm_year;
yyMonth = tm->tm_mon + 1;
yyDay = tm->tm_mday;
yyTimezone = now->timezone;
yyDSTmode = DSTmaybe;
yyHour = 0;
yyMinutes = 0;
yySeconds = 0;
yyMeridian = MER24;
yyRelSeconds = 0;
yyRelMonth = 0;
yyHaveDate = 0;
yyHaveDay = 0;
yyHaveRel = 0;
yyHaveTime = 0;
yyHaveZone = 0;
if (yyparse()
|| yyHaveTime > 1 || yyHaveZone > 1 || yyHaveDate > 1 || yyHaveDay > 1)
return -1;
if (yyHaveDate || yyHaveTime || yyHaveDay) {
Start = Convert(yyMonth, yyDay, yyYear, yyHour, yyMinutes, yySeconds,
yyMeridian, yyDSTmode);
if (Start < 0)
return -1;
}
else {
Start = now->time;
if (!yyHaveRel)
Start -= ((tm->tm_hour * 60L + tm->tm_min) * 60L) + tm->tm_sec;
}
Start += yyRelSeconds;
Start += RelativeMonth(Start, yyRelMonth);
if (yyHaveDay && !yyHaveDate) {
tod = RelativeDate(Start, yyDayOrdinal, yyDayNumber);
Start += tod;
}
return Start == -1 ? 0 : Start;
}
#if defined(TEST)
int
main(ac, av)
int ac;
char *av[];
{
char buff[128];
time_t d;
(void)printf("Enter date, or blank line to exit.\n\t> ");
(void)fflush(stdout);
while (gets(buff) && buff[0]) {
d = get_date(buff, (struct timeb *)NULL);
if (d == -1)
(void)printf("Bad format - couldn't convert.\n");
else
(void)printf("%s", ctime(&d));
(void)printf("\t> ");
(void)fflush(stdout);
}
exit(0);
}
#endif
int yyexca[] ={
-1, 1,
0, -1,
-2, 0,
};
# define YYNPROD 42
# define YYLAST 228
int yyact[]={
13, 11, 22, 28, 16, 12, 18, 17, 15, 9,
10, 38, 39, 20, 48, 44, 47, 46, 36, 43,
50, 32, 35, 34, 33, 29, 37, 31, 41, 45,
40, 30, 14, 8, 7, 6, 5, 4, 3, 2,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 49, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 21, 0, 0, 19, 25, 24, 27,
26, 23, 44, 0, 0, 0, 0, 42 };
int yypact[]={
-1000, -258, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -45,
-266, -1000, -242, -13, -230, -241, -1000, -1000, -1000, -1000,
-245, -1000, -249, -240, -255, -1000, -1000, -1000, -1000, -14,
-1000, -1000, -1000, -1000, -1000, -39, -18, -1000, -1000, -1000,
-250, -1000, -1000, -251, -1000, -253, -1000, -246, -1000, -1000,
-1000 };
int yypgo[]={
0, 28, 40, 39, 38, 37, 36, 35, 34, 33,
32 };
int yyr1[]={
0, 2, 2, 3, 3, 3, 3, 3, 3, 4,
4, 4, 4, 4, 5, 5, 5, 7, 7, 7,
6, 6, 6, 6, 6, 6, 6, 6, 8, 8,
10, 10, 10, 10, 10, 10, 10, 10, 10, 9,
1, 1 };
int yyr2[]={
0, 0, 4, 3, 3, 3, 3, 3, 2, 5,
9, 9, 13, 13, 3, 3, 5, 3, 5, 5,
7, 11, 7, 7, 5, 9, 5, 7, 5, 2,
5, 5, 3, 5, 5, 3, 5, 5, 3, 3,
1, 3 };
int yychk[]={
-1000, -2, -3, -4, -5, -6, -7, -8, -9, 267,
268, 259, 263, 258, -10, 266, 262, 265, 264, 261,
58, 258, 47, 266, 263, 262, 265, 264, 269, 267,
44, 257, 262, 265, 264, 267, 267, 266, 266, 267,
44, -1, 266, 58, 261, 47, 267, 267, 267, -1,
266 };
int yydef[]={
1, -2, 2, 3, 4, 5, 6, 7, 8, 39,
14, 15, 0, 17, 29, 0, 32, 35, 38, 9,
0, 19, 0, 0, 26, 30, 34, 37, 16, 24,
18, 28, 31, 33, 36, 40, 20, 22, 23, 27,
0, 10, 11, 0, 41, 0, 25, 40, 21, 12,
13 };
typedef struct { char *t_name; int t_val; } yytoktype;
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
yytoktype yytoks[] =
{
"tAGO", 257,
"tDAY", 258,
"tDAYZONE", 259,
"tID", 260,
"tMERIDIAN", 261,
"tMINUTE_UNIT", 262,
"tMONTH", 263,
"tMONTH_UNIT", 264,
"tSEC_UNIT", 265,
"tSNUMBER", 266,
"tUNUMBER", 267,
"tZONE", 268,
"tDST", 269,
"-unknown-", -1
};
char * yyreds[] =
{
"-no such reduction-",
"spec : /* empty */",
"spec : spec item",
"item : time",
"item : zone",
"item : date",
"item : day",
"item : rel",
"item : number",
"time : tUNUMBER tMERIDIAN",
"time : tUNUMBER ':' tUNUMBER o_merid",
"time : tUNUMBER ':' tUNUMBER tSNUMBER",
"time : tUNUMBER ':' tUNUMBER ':' tUNUMBER o_merid",
"time : tUNUMBER ':' tUNUMBER ':' tUNUMBER tSNUMBER",
"zone : tZONE",
"zone : tDAYZONE",
"zone : tZONE tDST",
"day : tDAY",
"day : tDAY ','",
"day : tUNUMBER tDAY",
"date : tUNUMBER '/' tUNUMBER",
"date : tUNUMBER '/' tUNUMBER '/' tUNUMBER",
"date : tUNUMBER tSNUMBER tSNUMBER",
"date : tUNUMBER tMONTH tSNUMBER",
"date : tMONTH tUNUMBER",
"date : tMONTH tUNUMBER ',' tUNUMBER",
"date : tUNUMBER tMONTH",
"date : tUNUMBER tMONTH tUNUMBER",
"rel : relunit tAGO",
"rel : relunit",
"relunit : tUNUMBER tMINUTE_UNIT",
"relunit : tSNUMBER tMINUTE_UNIT",
"relunit : tMINUTE_UNIT",
"relunit : tSNUMBER tSEC_UNIT",
"relunit : tUNUMBER tSEC_UNIT",
"relunit : tSEC_UNIT",
"relunit : tSNUMBER tMONTH_UNIT",
"relunit : tUNUMBER tMONTH_UNIT",
"relunit : tMONTH_UNIT",
"number : tUNUMBER",
"o_merid : /* empty */",
"o_merid : tMERIDIAN",
};
#endif
#define YYERROR goto yyerrlab
#define YYACCEPT { free(yys); free(yyv); return(0); }
#define YYABORT { free(yys); free(yyv); return(1); }
#define YYBACKUP( newtoken, newvalue )\
{\
if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
{\
yyerror( "syntax error - cannot backup" );\
goto yyerrlab;\
}\
yychar = newtoken;\
yystate = *yyps;\
yylval = newvalue;\
goto yynewstate;\
}
#define YYRECOVERING() (!!yyerrflag)
#ifndef YYDEBUG
# define YYDEBUG 1
#endif
int yydebug;
#define YYFLAG (-1000)
static YYSTYPE *yyv;
static int *yys;
static YYSTYPE *yypv;
static int *yyps;
static int yystate;
static int yytmp;
int yynerrs;
int yyerrflag;
int yychar;
int
yyparse()
{
register YYSTYPE *yypvt;
unsigned yymaxdepth = YYMAXDEPTH;
yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
yys = (int*)malloc(yymaxdepth*sizeof(int));
if (!yyv || !yys)
{
yyerror( "out of memory" );
return(1);
}
yypv = &yyv[-1];
yyps = &yys[-1];
yystate = 0;
yytmp = 0;
yynerrs = 0;
yyerrflag = 0;
yychar = -1;
goto yystack;
{
register YYSTYPE *yy_pv;
register int *yy_ps;
register int yy_state;
register int yy_n;
yynewstate:
yy_pv = yypv;
yy_ps = yyps;
yy_state = yystate;
goto yy_newstate;
yystack:
yy_pv = yypv;
yy_ps = yyps;
yy_state = yystate;
yy_stack:
#if YYDEBUG
if ( yydebug )
{
register int yy_i;
(void)printf( "State %d, token ", yy_state );
if ( yychar == 0 )
(void)printf( "end-of-file\n" );
else if ( yychar < 0 )
(void)printf( "-none-\n" );
else
{
for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
yy_i++ )
{
if ( yytoks[yy_i].t_val == yychar )
break;
}
(void)printf( "%s\n", yytoks[yy_i].t_name );
}
}
#endif
if ( ++yy_ps >= &yys[ yymaxdepth ] )
{
int yyps_index = (yy_ps - yys);
int yypv_index = (yy_pv - yyv);
int yypvt_index = (yypvt - yyv);
yymaxdepth += YYMAXDEPTH;
yyv = (YYSTYPE*)realloc((char*)yyv,
yymaxdepth * sizeof(YYSTYPE));
yys = (int*)realloc((char*)yys,
yymaxdepth * sizeof(int));
if (!yyv || !yys)
{
yyerror( "yacc stack overflow" );
return(1);
}
yy_ps = yys + yyps_index;
yy_pv = yyv + yypv_index;
yypvt = yyv + yypvt_index;
}
*yy_ps = yy_state;
*++yy_pv = yyval;
yy_newstate:
if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
goto yydefault;
#if YYDEBUG
yytmp = yychar < 0;
#endif
if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
yychar = 0;
#if YYDEBUG
if ( yydebug && yytmp )
{
register int yy_i;
(void)printf( "Received token " );
if ( yychar == 0 )
(void)printf( "end-of-file\n" );
else if ( yychar < 0 )
(void)printf( "-none-\n" );
else
{
for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
yy_i++ )
{
if ( yytoks[yy_i].t_val == yychar )
break;
}
(void)printf( "%s\n", yytoks[yy_i].t_name );
}
}
#endif
if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
goto yydefault;
if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )
{
yychar = -1;
yyval = yylval;
yy_state = yy_n;
if ( yyerrflag > 0 )
yyerrflag--;
goto yy_stack;
}
yydefault:
if ( ( yy_n = yydef[ yy_state ] ) == -2 )
{
#if YYDEBUG
yytmp = yychar < 0;
#endif
if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
yychar = 0;
#if YYDEBUG
if ( yydebug && yytmp )
{
register int yy_i;
(void)printf( "Received token " );
if ( yychar == 0 )
(void)printf( "end-of-file\n" );
else if ( yychar < 0 )
(void)printf( "-none-\n" );
else
{
for ( yy_i = 0;
yytoks[yy_i].t_val >= 0;
yy_i++ )
{
if ( yytoks[yy_i].t_val
== yychar )
{
break;
}
}
(void)printf( "%s\n", yytoks[yy_i].t_name );
}
}
#endif
{
register int *yyxi = yyexca;
while ( ( *yyxi != -1 ) ||
( yyxi[1] != yy_state ) )
{
yyxi += 2;
}
while ( ( *(yyxi += 2) >= 0 ) &&
( *yyxi != yychar ) )
;
if ( ( yy_n = yyxi[1] ) < 0 )
YYACCEPT;
}
}
if ( yy_n == 0 )
{
switch ( yyerrflag )
{
case 0:
yyerror( "syntax error" );
goto skip_init;
yyerrlab:
yy_pv = yypv;
yy_ps = yyps;
yy_state = yystate;
yynerrs++;
skip_init:
case 1:
case 2:
yyerrflag = 3;
while ( yy_ps >= yys )
{
yy_n = yypact[ *yy_ps ] + YYERRCODE;
if ( yy_n >= 0 && yy_n < YYLAST &&
yychk[yyact[yy_n]] == YYERRCODE) {
yy_state = yyact[ yy_n ];
goto yy_stack;
}
#if YYDEBUG
# define _POP_ "Error recovery pops state %d, uncovers state %d\n"
if ( yydebug )
(void)printf( _POP_, *yy_ps,
yy_ps[-1] );
# undef _POP_
#endif
yy_ps--;
yy_pv--;
}
YYABORT;
case 3:
#if YYDEBUG
if ( yydebug )
{
register int yy_i;
(void)printf( "Error recovery discards " );
if ( yychar == 0 )
(void)printf( "token end-of-file\n" );
else if ( yychar < 0 )
(void)printf( "token -none-\n" );
else
{
for ( yy_i = 0;
yytoks[yy_i].t_val >= 0;
yy_i++ )
{
if ( yytoks[yy_i].t_val
== yychar )
{
break;
}
}
(void)printf( "token %s\n",
yytoks[yy_i].t_name );
}
}
#endif
if ( yychar == 0 )
YYABORT;
yychar = -1;
goto yy_newstate;
}
}
#if YYDEBUG
if ( yydebug )
(void)printf( "Reduce by (%d) \"%s\"\n",
yy_n, yyreds[ yy_n ] );
#endif
yytmp = yy_n;
yypvt = yy_pv;
{
register int yy_len = yyr2[ yy_n ];
if ( !( yy_len & 01 ) )
{
yy_len >>= 1;
yyval = ( yy_pv -= yy_len )[1];
yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
*( yy_ps -= yy_len ) + 1;
if ( yy_state >= YYLAST ||
yychk[ yy_state =
yyact[ yy_state ] ] != -yy_n )
{
yy_state = yyact[ yypgo[ yy_n ] ];
}
goto yy_stack;
}
yy_len >>= 1;
yyval = ( yy_pv -= yy_len )[1];
yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
*( yy_ps -= yy_len ) + 1;
if ( yy_state >= YYLAST ||
yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
{
yy_state = yyact[ yypgo[ yy_n ] ];
}
}
yystate = yy_state;
yyps = yy_ps;
yypv = yy_pv;
}
switch( yytmp )
{
case 3:
{
yyHaveTime++;
} break;
case 4:
{
yyHaveZone++;
} break;
case 5:
{
yyHaveDate++;
} break;
case 6:
{
yyHaveDay++;
} break;
case 7:
{
yyHaveRel++;
} break;
case 9:
{
yyHour = yypvt[-1].Number;
yyMinutes = 0;
yySeconds = 0;
yyMeridian = yypvt[-0].Meridian;
} break;
case 10:
{
yyHour = yypvt[-3].Number;
yyMinutes = yypvt[-1].Number;
yySeconds = 0;
yyMeridian = yypvt[-0].Meridian;
} break;
case 11:
{
yyHour = yypvt[-3].Number;
yyMinutes = yypvt[-1].Number;
yyMeridian = MER24;
yyDSTmode = DSToff;
yyTimezone = - (yypvt[-0].Number % 100 + (yypvt[-0].Number / 100) * 60);
} break;
case 12:
{
yyHour = yypvt[-5].Number;
yyMinutes = yypvt[-3].Number;
yySeconds = yypvt[-1].Number;
yyMeridian = yypvt[-0].Meridian;
} break;
case 13:
{
yyHour = yypvt[-5].Number;
yyMinutes = yypvt[-3].Number;
yySeconds = yypvt[-1].Number;
yyMeridian = MER24;
yyDSTmode = DSToff;
yyTimezone = - (yypvt[-0].Number % 100 + (yypvt[-0].Number / 100) * 60);
} break;
case 14:
{
yyTimezone = yypvt[-0].Number;
yyDSTmode = DSToff;
} break;
case 15:
{
yyTimezone = yypvt[-0].Number;
yyDSTmode = DSTon;
} break;
case 16:
{
yyTimezone = yypvt[-1].Number;
yyDSTmode = DSTon;
} break;
case 17:
{
yyDayOrdinal = 1;
yyDayNumber = yypvt[-0].Number;
} break;
case 18:
{
yyDayOrdinal = 1;
yyDayNumber = yypvt[-1].Number;
} break;
case 19:
{
yyDayOrdinal = yypvt[-1].Number;
yyDayNumber = yypvt[-0].Number;
} break;
case 20:
{
yyMonth = yypvt[-2].Number;
yyDay = yypvt[-0].Number;
} break;
case 21:
{
yyMonth = yypvt[-4].Number;
yyDay = yypvt[-2].Number;
yyYear = yypvt[-0].Number;
} break;
case 22:
{
yyYear = yypvt[-2].Number;
yyMonth = -yypvt[-1].Number;
yyDay = -yypvt[-0].Number;
} break;
case 23:
{
yyDay = yypvt[-2].Number;
yyMonth = yypvt[-1].Number;
yyYear = -yypvt[-0].Number;
} break;
case 24:
{
yyMonth = yypvt[-1].Number;
yyDay = yypvt[-0].Number;
} break;
case 25:
{
yyMonth = yypvt[-3].Number;
yyDay = yypvt[-2].Number;
yyYear = yypvt[-0].Number;
} break;
case 26:
{
yyMonth = yypvt[-0].Number;
yyDay = yypvt[-1].Number;
} break;
case 27:
{
yyMonth = yypvt[-1].Number;
yyDay = yypvt[-2].Number;
yyYear = yypvt[-0].Number;
} break;
case 28:
{
yyRelSeconds = -yyRelSeconds;
yyRelMonth = -yyRelMonth;
} break;
case 30:
{
yyRelSeconds += yypvt[-1].Number * yypvt[-0].Number * 60L;
} break;
case 31:
{
yyRelSeconds += yypvt[-1].Number * yypvt[-0].Number * 60L;
} break;
case 32:
{
yyRelSeconds += yypvt[-0].Number * 60L;
} break;
case 33:
{
yyRelSeconds += yypvt[-1].Number;
} break;
case 34:
{
yyRelSeconds += yypvt[-1].Number;
} break;
case 35:
{
yyRelSeconds++;
} break;
case 36:
{
yyRelMonth += yypvt[-1].Number * yypvt[-0].Number;
} break;
case 37:
{
yyRelMonth += yypvt[-1].Number * yypvt[-0].Number;
} break;
case 38:
{
yyRelMonth += yypvt[-0].Number;
} break;
case 39:
{
if (yyHaveTime && yyHaveDate && !yyHaveRel)
yyYear = yypvt[-0].Number;
else {
if(yypvt[-0].Number>10000) {
yyHaveDate++;
yyDay= (yypvt[-0].Number)%100;
yyMonth= (yypvt[-0].Number/100)%100;
yyYear = yypvt[-0].Number/10000;
}
else {
yyHaveTime++;
if (yypvt[-0].Number < 100) {
yyHour = yypvt[-0].Number;
yyMinutes = 0;
}
else {
yyHour = yypvt[-0].Number / 100;
yyMinutes = yypvt[-0].Number % 100;
}
yySeconds = 0;
yyMeridian = MER24;
}
}
} break;
case 40:
{
yyval.Meridian = MER24;
} break;
case 41:
{
yyval.Meridian = yypvt[-0].Meridian;
} break;
}
goto yystack;
}