diff -r 000000000000 -r bde4ae8d615e os/persistentdata/persistentstorage/sqlite3api/TEST/TCL/tcldistribution/generic/tclDate.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/persistentdata/persistentstorage/sqlite3api/TEST/TCL/tcldistribution/generic/tclDate.c Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,1875 @@ +/* + * tclDate.c -- + * + * This file is generated from a yacc grammar defined in + * the file tclGetDate.y. It should not be edited directly. + * + * Copyright (c) 1992-1995 Karl Lehenbauer and Mark Diekhans. + * Copyright (c) 1995-1997 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * RCS: @(#) $Id: tclDate.c,v 1.20.4.3 2006/06/14 15:21:14 patthoyts Exp $ + */ + +#include "tclInt.h" +#include "tclPort.h" + +#if defined(MAC_TCL) && !defined(TCL_MAC_USE_MSL_EPOCH) +# define EPOCH 1904 +# define START_OF_TIME 1904 +# define END_OF_TIME 2039 +#else +# define EPOCH 1970 +# define START_OF_TIME 1902 +# define END_OF_TIME 2037 +#endif + +/* + * The offset of tm_year of struct tm returned by localtime, gmtime, etc. + * I don't know how universal this is; K&R II, the NetBSD manpages, and + * ../compat/strftime.c all agree that tm_year is the year-1900. However, + * some systems may have a different value. This #define should be the + * same as in ../compat/strftime.c. + */ +#define TM_YEAR_BASE 1900 + +#define HOUR(x) ((int) (60 * x)) +#define SECSPERDAY (24L * 60L * 60L) +#define IsLeapYear(x) ((x % 4 == 0) && (x % 100 != 0 || x % 400 == 0)) + +/* + * An entry in the lexical lookup table. + */ +typedef struct _TABLE { + char *name; + int type; + time_t value; +} TABLE; + + +/* + * Daylight-savings mode: on, off, or not yet known. + */ +typedef enum _DSTMODE { + DSTon, DSToff, DSTmaybe +} DSTMODE; + +/* + * Meridian: am, pm, or 24-hour style. + */ +typedef enum _MERIDIAN { + MERam, MERpm, MER24 +} MERIDIAN; + + +/* + * Global variables. We could get rid of most of these by using a good + * union as the yacc stack. (This routine was originally written before + * yacc had the %union construct.) Maybe someday; right now we only use + * the %union very rarely. + */ +static char *TclDateInput; +static DSTMODE TclDateDSTmode; +static time_t TclDateDayOrdinal; +static time_t TclDateDayNumber; +static time_t TclDateMonthOrdinal; +static int TclDateHaveDate; +static int TclDateHaveDay; +static int TclDateHaveOrdinalMonth; +static int TclDateHaveRel; +static int TclDateHaveTime; +static int TclDateHaveZone; +static time_t TclDateTimezone; +static time_t TclDateDay; +static time_t TclDateHour; +static time_t TclDateMinutes; +static time_t TclDateMonth; +static time_t TclDateSeconds; +static time_t TclDateYear; +static MERIDIAN TclDateMeridian; +static time_t TclDateRelMonth; +static time_t TclDateRelDay; +static time_t TclDateRelSeconds; +static time_t *TclDateRelPointer; + +/* + * Prototypes of internal functions. + */ +static void TclDateerror _ANSI_ARGS_((char *s)); +static time_t ToSeconds _ANSI_ARGS_((time_t Hours, time_t Minutes, + time_t Seconds, MERIDIAN Meridian)); +static int Convert _ANSI_ARGS_((time_t Month, time_t Day, time_t Year, + time_t Hours, time_t Minutes, time_t Seconds, + MERIDIAN Meridia, DSTMODE DSTmode, time_t *TimePtr)); +static time_t DSTcorrect _ANSI_ARGS_((time_t Start, time_t Future)); +static time_t NamedDay _ANSI_ARGS_((time_t Start, time_t DayOrdinal, + time_t DayNumber)); +static time_t NamedMonth _ANSI_ARGS_((time_t Start, time_t MonthOrdinal, + time_t MonthNumber)); +static int RelativeMonth _ANSI_ARGS_((time_t Start, time_t RelMonth, + time_t *TimePtr)); +static int RelativeDay _ANSI_ARGS_((time_t Start, time_t RelDay, + time_t *TimePtr)); +static int LookupWord _ANSI_ARGS_((char *buff)); +static int TclDatelex _ANSI_ARGS_((void)); + +int +TclDateparse _ANSI_ARGS_((void)); +typedef union +#ifdef __cplusplus + YYSTYPE +#endif + { + 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 tSTARDATE 265 +# define tSEC_UNIT 266 +# define tSNUMBER 267 +# define tUNUMBER 268 +# define tZONE 269 +# define tEPOCH 270 +# define tDST 271 +# define tISOBASE 272 +# define tDAY_UNIT 273 +# define tNEXT 274 + + + + +#if defined(__cplusplus) || defined(__STDC__) + +#if defined(__cplusplus) && defined(__EXTERN_C__) +extern "C" { +#endif +#ifndef TclDateerror +#if defined(__cplusplus) + void TclDateerror(CONST char *); +#endif +#endif +#ifndef TclDatelex + int TclDatelex(void); +#endif + int TclDateparse(void); +#if defined(__cplusplus) && defined(__EXTERN_C__) +} +#endif + +#endif + +#define TclDateclearin TclDatechar = -1 +#define TclDateerrok TclDateerrflag = 0 +extern int TclDatechar; +extern int TclDateerrflag; +YYSTYPE TclDatelval; +YYSTYPE TclDateval; +typedef int TclDatetabelem; +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 150 +#endif +#if YYMAXDEPTH > 0 +int TclDate_TclDates[YYMAXDEPTH], *TclDates = TclDate_TclDates; +YYSTYPE TclDate_TclDatev[YYMAXDEPTH], *TclDatev = TclDate_TclDatev; +#else /* user does initial allocation */ +int *TclDates; +YYSTYPE *TclDatev; +#endif +static int TclDatemaxdepth = YYMAXDEPTH; +# define YYERRCODE 256 + + +/* + * Month and day table. + */ +static TABLE 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 } +}; + +/* + * Time units table. + */ +static TABLE UnitsTable[] = { + { "year", tMONTH_UNIT, 12 }, + { "month", tMONTH_UNIT, 1 }, + { "fortnight", tDAY_UNIT, 14 }, + { "week", tDAY_UNIT, 7 }, + { "day", tDAY_UNIT, 1 }, + { "hour", tSEC_UNIT, 60 * 60 }, + { "minute", tSEC_UNIT, 60 }, + { "min", tSEC_UNIT, 60 }, + { "second", tSEC_UNIT, 1 }, + { "sec", tSEC_UNIT, 1 }, + { NULL } +}; + +/* + * Assorted relative-time words. + */ +static TABLE OtherTable[] = { + { "tomorrow", tDAY_UNIT, 1 }, + { "yesterday", tDAY_UNIT, -1 }, + { "today", tDAY_UNIT, 0 }, + { "now", tSEC_UNIT, 0 }, + { "last", tUNUMBER, -1 }, + { "this", tSEC_UNIT, 0 }, + { "next", tNEXT, 1 }, +#if 0 + { "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 }, +#endif + { "ago", tAGO, 1 }, + { "epoch", tEPOCH, 0 }, + { "stardate", tSTARDATE, 0}, + { NULL } +}; + +/* + * The timezone table. (Note: This table was modified to not use any floating + * point constants to work around an SGI compiler bug). + */ +static TABLE TimezoneTable[] = { + { "gmt", tZONE, HOUR( 0) }, /* Greenwich Mean */ + { "ut", tZONE, HOUR( 0) }, /* Universal (Coordinated) */ + { "utc", tZONE, HOUR( 0) }, + { "uct", tZONE, HOUR( 0) }, /* Universal Coordinated Time */ + { "wet", tZONE, HOUR( 0) }, /* Western European */ + { "bst", tDAYZONE, HOUR( 0) }, /* British Summer */ + { "wat", tZONE, HOUR( 1) }, /* West Africa */ + { "at", tZONE, HOUR( 2) }, /* Azores */ +#if 0 + /* For completeness. BST is also British Summer, and GST is + * also Guam Standard. */ + { "bst", tZONE, HOUR( 3) }, /* Brazil Standard */ + { "gst", tZONE, HOUR( 3) }, /* Greenland Standard */ +#endif + { "nft", tZONE, HOUR( 7/2) }, /* Newfoundland */ + { "nst", tZONE, HOUR( 7/2) }, /* Newfoundland Standard */ + { "ndt", tDAYZONE, HOUR( 7/2) }, /* Newfoundland Daylight */ + { "ast", tZONE, HOUR( 4) }, /* Atlantic Standard */ + { "adt", tDAYZONE, HOUR( 4) }, /* Atlantic Daylight */ + { "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 */ + { "yst", tZONE, HOUR( 9) }, /* Yukon Standard */ + { "ydt", tDAYZONE, HOUR( 9) }, /* Yukon Daylight */ + { "hst", tZONE, HOUR(10) }, /* Hawaii Standard */ + { "hdt", tDAYZONE, HOUR(10) }, /* Hawaii Daylight */ + { "cat", tZONE, HOUR(10) }, /* Central Alaska */ + { "ahst", tZONE, HOUR(10) }, /* Alaska-Hawaii Standard */ + { "nt", tZONE, HOUR(11) }, /* Nome */ + { "idlw", tZONE, HOUR(12) }, /* International Date Line West */ + { "cet", tZONE, -HOUR( 1) }, /* Central European */ + { "cest", tDAYZONE, -HOUR( 1) }, /* Central European Summer */ + { "met", tZONE, -HOUR( 1) }, /* Middle European */ + { "mewt", tZONE, -HOUR( 1) }, /* Middle European Winter */ + { "mest", tDAYZONE, -HOUR( 1) }, /* Middle European Summer */ + { "swt", tZONE, -HOUR( 1) }, /* Swedish Winter */ + { "sst", tDAYZONE, -HOUR( 1) }, /* Swedish Summer */ + { "fwt", tZONE, -HOUR( 1) }, /* French Winter */ + { "fst", tDAYZONE, -HOUR( 1) }, /* French Summer */ + { "eet", tZONE, -HOUR( 2) }, /* Eastern Europe, USSR Zone 1 */ + { "bt", tZONE, -HOUR( 3) }, /* Baghdad, USSR Zone 2 */ + { "it", tZONE, -HOUR( 7/2) }, /* Iran */ + { "zp4", tZONE, -HOUR( 4) }, /* USSR Zone 3 */ + { "zp5", tZONE, -HOUR( 5) }, /* USSR Zone 4 */ + { "ist", tZONE, -HOUR(11/2) }, /* Indian Standard */ + { "zp6", tZONE, -HOUR( 6) }, /* USSR Zone 5 */ +#if 0 + /* For completeness. NST is also Newfoundland Stanard, nad SST is + * also Swedish Summer. */ + { "nst", tZONE, -HOUR(13/2) }, /* North Sumatra */ + { "sst", tZONE, -HOUR( 7) }, /* South Sumatra, USSR Zone 6 */ +#endif /* 0 */ + { "wast", tZONE, -HOUR( 7) }, /* West Australian Standard */ + { "wadt", tDAYZONE, -HOUR( 7) }, /* West Australian Daylight */ + { "jt", tZONE, -HOUR(15/2) }, /* Java (3pm in Cronusland!) */ + { "cct", tZONE, -HOUR( 8) }, /* China Coast, USSR Zone 7 */ + { "jst", tZONE, -HOUR( 9) }, /* Japan Standard, USSR Zone 8 */ + { "jdt", tDAYZONE, -HOUR( 9) }, /* Japan Daylight */ + { "kst", tZONE, -HOUR( 9) }, /* Korea Standard */ + { "kdt", tDAYZONE, -HOUR( 9) }, /* Korea Daylight */ + { "cast", tZONE, -HOUR(19/2) }, /* Central Australian Standard */ + { "cadt", tDAYZONE, -HOUR(19/2) }, /* Central Australian Daylight */ + { "east", tZONE, -HOUR(10) }, /* Eastern Australian Standard */ + { "eadt", tDAYZONE, -HOUR(10) }, /* Eastern Australian Daylight */ + { "gst", tZONE, -HOUR(10) }, /* Guam Standard, USSR Zone 9 */ + { "nzt", tZONE, -HOUR(12) }, /* New Zealand */ + { "nzst", tZONE, -HOUR(12) }, /* New Zealand Standard */ + { "nzdt", tDAYZONE, -HOUR(12) }, /* New Zealand Daylight */ + { "idle", tZONE, -HOUR(12) }, /* International Date Line East */ + /* ADDED BY Marco Nijdam */ + { "dst", tDST, HOUR( 0) }, /* DST on (hour is ignored) */ + /* End ADDED */ + { NULL } +}; + +/* + * Military timezone table. + */ +static TABLE 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 } +}; + + +/* + * Dump error messages in the bit bucket. + */ +static void +TclDateerror(s) + char *s; +{ +} + + +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 % 12) * 60L + Minutes) * 60L + Seconds; + case MERpm: + if (Hours < 1 || Hours > 12) + return -1; + return (((Hours % 12) + 12) * 60L + Minutes) * 60L + Seconds; + } + return -1; /* Should never be reached */ +} + +/* + *----------------------------------------------------------------------------- + * + * Convert -- + * + * Convert a {month, day, year, hours, minutes, seconds, meridian, dst} + * tuple into a clock seconds value. + * + * Results: + * 0 or -1 indicating success or failure. + * + * Side effects: + * Fills TimePtr with the computed value. + * + *----------------------------------------------------------------------------- + */ +static int +Convert(Month, Day, Year, Hours, Minutes, Seconds, Meridian, DSTmode, TimePtr) + time_t Month; + time_t Day; + time_t Year; + time_t Hours; + time_t Minutes; + time_t Seconds; + MERIDIAN Meridian; + DSTMODE DSTmode; + time_t *TimePtr; +{ + static int DaysInMonth[12] = { + 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 + }; + time_t tod; + time_t Julian; + int i; + + /* Figure out how many days are in February for the given year. + * Every year divisible by 4 is a leap year. + * But, every year divisible by 100 is not a leap year. + * But, every year divisible by 400 is a leap year after all. + */ + DaysInMonth[1] = IsLeapYear(Year) ? 29 : 28; + + /* Check the inputs for validity */ + if (Month < 1 || Month > 12 + || Year < START_OF_TIME || Year > END_OF_TIME + || Day < 1 || Day > DaysInMonth[(int)--Month]) + return -1; + + /* Start computing the value. First determine the number of days + * represented by the date, then multiply by the number of seconds/day. + */ + for (Julian = Day - 1, i = 0; i < Month; i++) + Julian += DaysInMonth[i]; + if (Year >= EPOCH) { + for (i = EPOCH; i < Year; i++) + Julian += 365 + IsLeapYear(i); + } else { + for (i = (int)Year; i < EPOCH; i++) + Julian -= 365 + IsLeapYear(i); + } + Julian *= SECSPERDAY; + + /* Add the timezone offset ?? */ + Julian += TclDateTimezone * 60L; + + /* Add the number of seconds represented by the time component */ + if ((tod = ToSeconds(Hours, Minutes, Seconds, Meridian)) < 0) + return -1; + Julian += tod; + + /* Perform a preliminary DST compensation ?? */ + if (DSTmode == DSTon + || (DSTmode == DSTmaybe && TclpGetDate((TclpTime_t)&Julian, 0)->tm_isdst)) + Julian -= 60 * 60; + *TimePtr = Julian; + return 0; +} + + +static time_t +DSTcorrect(Start, Future) + time_t Start; + time_t Future; +{ + time_t StartDay; + time_t FutureDay; + StartDay = (TclpGetDate((TclpTime_t)&Start, 0)->tm_hour + 1) % 24; + FutureDay = (TclpGetDate((TclpTime_t)&Future, 0)->tm_hour + 1) % 24; + return (Future - Start) + (StartDay - FutureDay) * 60L * 60L; +} + + +static time_t +NamedDay(Start, DayOrdinal, DayNumber) + time_t Start; + time_t DayOrdinal; + time_t DayNumber; +{ + struct tm *tm; + time_t now; + + now = Start; + tm = TclpGetDate((TclpTime_t)&now, 0); + now += SECSPERDAY * ((DayNumber - tm->tm_wday + 7) % 7); + now += 7 * SECSPERDAY * (DayOrdinal <= 0 ? DayOrdinal : DayOrdinal - 1); + return DSTcorrect(Start, now); +} + +static time_t +NamedMonth(Start, MonthOrdinal, MonthNumber) + time_t Start; + time_t MonthOrdinal; + time_t MonthNumber; +{ + struct tm *tm; + time_t now; + int result; + + now = Start; + tm = TclpGetDate((TclpTime_t)&now, 0); + /* To compute the next n'th month, we use this alg: + * add n to year value + * if currentMonth < requestedMonth decrement year value by 1 (so that + * doing next february from january gives us february of the current year) + * set day to 1, time to 0 + */ + tm->tm_year += (int)MonthOrdinal; + if (tm->tm_mon < MonthNumber - 1) { + tm->tm_year--; + } + result = Convert(MonthNumber, (time_t) 1, tm->tm_year + TM_YEAR_BASE, + (time_t) 0, (time_t) 0, (time_t) 0, MER24, DSTmaybe, &now); + if (result < 0) { + return 0; + } + return DSTcorrect(Start, now); +} + +static int +RelativeMonth(Start, RelMonth, TimePtr) + time_t Start; + time_t RelMonth; + time_t *TimePtr; +{ + struct tm *tm; + time_t Month; + time_t Year; + time_t Julian; + int result; + + if (RelMonth == 0) { + *TimePtr = 0; + return 0; + } + tm = TclpGetDate((TclpTime_t)&Start, 0); + Month = 12 * (tm->tm_year + TM_YEAR_BASE) + tm->tm_mon + RelMonth; + Year = Month / 12; + Month = Month % 12 + 1; + result = 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, &Julian); + + /* + * The Julian time returned above is behind by one day, if "month" + * or "year" is used to specify relative time and the GMT flag is true. + * This problem occurs only when the current time is closer to + * midnight, the difference being not more than its time difference + * with GMT. For example, in US/Pacific time zone, the problem occurs + * whenever the current time is between midnight to 8:00am or 7:00amDST. + * See Bug# 413397 for more details and sample script. + * To resolve this bug, we simply add the number of seconds corresponding + * to timezone difference with GMT to Julian time, if GMT flag is true. + */ + + if (TclDateTimezone == 0) { + Julian += TclpGetTimeZone((unsigned long) Start) * 60L; + } + + /* + * The following iteration takes into account the case were we jump + * into a "short month". Far example, "one month from Jan 31" will + * fail because there is no Feb 31. The code below will reduce the + * day and try converting the date until we succed or the date equals + * 28 (which always works unless the date is bad in another way). + */ + + while ((result != 0) && (tm->tm_mday > 28)) { + tm->tm_mday--; + result = 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, &Julian); + } + if (result != 0) { + return -1; + } + *TimePtr = DSTcorrect(Start, Julian); + return 0; +} + + +/* + *----------------------------------------------------------------------------- + * + * RelativeDay -- + * + * Given a starting time and a number of days before or after, compute the + * DST corrected difference between those dates. + * + * Results: + * 1 or -1 indicating success or failure. + * + * Side effects: + * Fills TimePtr with the computed value. + * + *----------------------------------------------------------------------------- + */ + +static int +RelativeDay(Start, RelDay, TimePtr) + time_t Start; + time_t RelDay; + time_t *TimePtr; +{ + time_t new; + + new = Start + (RelDay * 60 * 60 * 24); + *TimePtr = DSTcorrect(Start, new); + return 1; +} + +static int +LookupWord(buff) + char *buff; +{ + register char *p; + register char *q; + register TABLE *tp; + int i; + int abbrev; + + /* + * Make it lowercase. + */ + + Tcl_UtfToLower(buff); + + if (strcmp(buff, "am") == 0 || strcmp(buff, "a.m.") == 0) { + TclDatelval.Meridian = MERam; + return tMERIDIAN; + } + if (strcmp(buff, "pm") == 0 || strcmp(buff, "p.m.") == 0) { + TclDatelval.Meridian = MERpm; + return tMERIDIAN; + } + + /* + * See if we have an abbreviation for a month. + */ + 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) { + TclDatelval.Number = tp->value; + return tp->type; + } + } else if (strcmp(buff, tp->name) == 0) { + TclDatelval.Number = tp->value; + return tp->type; + } + } + + for (tp = TimezoneTable; tp->name; tp++) { + if (strcmp(buff, tp->name) == 0) { + TclDatelval.Number = tp->value; + return tp->type; + } + } + + for (tp = UnitsTable; tp->name; tp++) { + if (strcmp(buff, tp->name) == 0) { + TclDatelval.Number = tp->value; + return tp->type; + } + } + + /* + * Strip off any plural and try the units table again. + */ + i = strlen(buff) - 1; + if (buff[i] == 's') { + buff[i] = '\0'; + for (tp = UnitsTable; tp->name; tp++) { + if (strcmp(buff, tp->name) == 0) { + TclDatelval.Number = tp->value; + return tp->type; + } + } + } + + for (tp = OtherTable; tp->name; tp++) { + if (strcmp(buff, tp->name) == 0) { + TclDatelval.Number = tp->value; + return tp->type; + } + } + + /* + * Military timezones. + */ + if (buff[1] == '\0' && !(*buff & 0x80) + && isalpha(UCHAR(*buff))) { /* INTL: ISO only */ + for (tp = MilitaryTable; tp->name; tp++) { + if (strcmp(buff, tp->name) == 0) { + TclDatelval.Number = tp->value; + return tp->type; + } + } + } + + /* + * Drop out any periods and try the timezone table again. + */ + 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) { + TclDatelval.Number = tp->value; + return tp->type; + } + } + } + + return tID; +} + + +static int +TclDatelex() +{ + register char c; + register char *p; + char buff[20]; + int Count; + + for ( ; ; ) { + while (isspace(UCHAR(*TclDateInput))) { + TclDateInput++; + } + + if (isdigit(UCHAR(c = *TclDateInput))) { /* INTL: digit */ + /* convert the string into a number; count the number of digits */ + Count = 0; + for (TclDatelval.Number = 0; + isdigit(UCHAR(c = *TclDateInput++)); ) { /* INTL: digit */ + TclDatelval.Number = 10 * TclDatelval.Number + c - '0'; + Count++; + } + TclDateInput--; + /* A number with 6 or more digits is considered an ISO 8601 base */ + if (Count >= 6) { + return tISOBASE; + } else { + return tUNUMBER; + } + } + if (!(c & 0x80) && isalpha(UCHAR(c))) { /* INTL: ISO only. */ + for (p = buff; isalpha(UCHAR(c = *TclDateInput++)) /* INTL: ISO only. */ + || c == '.'; ) { + if (p < &buff[sizeof buff - 1]) { + *p++ = c; + } + } + *p = '\0'; + TclDateInput--; + return LookupWord(buff); + } + if (c != '(') { + return *TclDateInput++; + } + Count = 0; + do { + c = *TclDateInput++; + if (c == '\0') { + return c; + } else if (c == '(') { + Count++; + } else if (c == ')') { + Count--; + } + } while (Count > 0); + } +} + +/* + * Specify zone is of -50000 to force GMT. (This allows BST to work). + */ + +int +TclGetDate(p, now, zone, timePtr) + char *p; + Tcl_WideInt now; + long zone; + Tcl_WideInt *timePtr; +{ + struct tm *tm; + time_t Start; + time_t Time; + time_t tod; + int thisyear; + + TclDateInput = p; + /* now has to be cast to a time_t for 64bit compliance */ + Start = (time_t) now; + tm = TclpGetDate((TclpTime_t) &Start, (zone == -50000)); + thisyear = tm->tm_year + TM_YEAR_BASE; + TclDateYear = thisyear; + TclDateMonth = tm->tm_mon + 1; + TclDateDay = tm->tm_mday; + TclDateTimezone = zone; + if (zone == -50000) { + TclDateDSTmode = DSToff; /* assume GMT */ + TclDateTimezone = 0; + } else { + TclDateDSTmode = DSTmaybe; + } + TclDateHour = 0; + TclDateMinutes = 0; + TclDateSeconds = 0; + TclDateMeridian = MER24; + TclDateRelSeconds = 0; + TclDateRelMonth = 0; + TclDateRelDay = 0; + TclDateRelPointer = NULL; + + TclDateHaveDate = 0; + TclDateHaveDay = 0; + TclDateHaveOrdinalMonth = 0; + TclDateHaveRel = 0; + TclDateHaveTime = 0; + TclDateHaveZone = 0; + + if (TclDateparse() || TclDateHaveTime > 1 || TclDateHaveZone > 1 || TclDateHaveDate > 1 || + TclDateHaveDay > 1 || TclDateHaveOrdinalMonth > 1) { + return -1; + } + + if (TclDateHaveDate || TclDateHaveTime || TclDateHaveDay) { + if (TclDateYear < 0) { + TclDateYear = -TclDateYear; + } + /* + * The following line handles years that are specified using + * only two digits. The line of code below implements a policy + * defined by the X/Open workgroup on the millinium rollover. + * Note: some of those dates may not actually be valid on some + * platforms. The POSIX standard startes that the dates 70-99 + * shall refer to 1970-1999 and 00-38 shall refer to 2000-2038. + * This later definition should work on all platforms. + */ + + if (TclDateYear < 100) { + if (TclDateYear >= 69) { + TclDateYear += 1900; + } else { + TclDateYear += 2000; + } + } + if (Convert(TclDateMonth, TclDateDay, TclDateYear, TclDateHour, TclDateMinutes, TclDateSeconds, + TclDateMeridian, TclDateDSTmode, &Start) < 0) { + return -1; + } + } else { + Start = (time_t) now; + if (!TclDateHaveRel) { + Start -= ((tm->tm_hour * 60L * 60L) + + tm->tm_min * 60L) + tm->tm_sec; + } + } + + Start += TclDateRelSeconds; + if (RelativeMonth(Start, TclDateRelMonth, &Time) < 0) { + return -1; + } + Start += Time; + + if (RelativeDay(Start, TclDateRelDay, &Time) < 0) { + return -1; + } + Start += Time; + + if (TclDateHaveDay && !TclDateHaveDate) { + tod = NamedDay(Start, TclDateDayOrdinal, TclDateDayNumber); + Start += tod; + } + + if (TclDateHaveOrdinalMonth) { + tod = NamedMonth(Start, TclDateMonthOrdinal, TclDateMonth); + Start += tod; + } + + *timePtr = Start; + return 0; +} +static CONST TclDatetabelem TclDateexca[] ={ +-1, 1, + 0, -1, + -2, 0, + }; +# define YYNPROD 56 +# define YYLAST 261 +static CONST TclDatetabelem TclDateact[]={ + + 24, 40, 23, 36, 54, 81, 41, 28, 53, 26, + 37, 42, 58, 38, 56, 28, 27, 26, 28, 33, + 26, 32, 61, 50, 27, 80, 76, 27, 51, 75, + 74, 73, 30, 72, 71, 70, 69, 52, 49, 48, + 47, 45, 39, 62, 78, 46, 79, 68, 25, 65, + 60, 67, 66, 55, 44, 21, 63, 11, 10, 9, + 8, 35, 7, 6, 5, 4, 3, 43, 2, 1, + 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 57, 0, 0, 59, 77, 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, 19, 14, 0, 0, 0, + 16, 28, 22, 26, 0, 12, 13, 17, 0, 15, + 27, 18, 31, 0, 0, 29, 0, 34, 28, 0, + 26, 0, 0, 0, 0, 0, 0, 27, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, + 64 }; +static CONST TclDatetabelem TclDatepact[]={ + +-10000000, -43,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, +-10000000,-10000000, -26, -268,-10000000, -259, -226,-10000000, -257, 10, + -227, -212, -228,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, + -229,-10000000, -230, -240, -231,-10000000,-10000000, -264,-10000000, 9, +-10000000,-10000000, -249,-10000000,-10000000, -246,-10000000, 4, -2, 2, + 7, 6,-10000000,-10000000, -11, -232,-10000000,-10000000,-10000000,-10000000, + -233,-10000000, -234, -235,-10000000, -237, -238, -239, -242,-10000000, +-10000000,-10000000, -1,-10000000,-10000000,-10000000, -12,-10000000, -243, -263, +-10000000,-10000000 }; +static CONST TclDatetabelem TclDatepgo[]={ + + 0, 48, 70, 22, 69, 68, 66, 65, 64, 63, + 62, 60, 59, 58, 57, 55 }; +static CONST TclDatetabelem TclDater1[]={ + + 0, 4, 4, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, + 10, 10, 10, 10, 10, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 9, 9, 12, 12, 12, + 13, 11, 11, 15, 15, 15, 15, 15, 2, 2, + 1, 1, 1, 14, 3, 3 }; +static CONST TclDatetabelem TclDater2[]={ + + 0, 0, 4, 3, 3, 3, 3, 3, 3, 3, + 3, 2, 5, 9, 11, 13, 15, 5, 3, 3, + 3, 5, 5, 7, 5, 7, 11, 3, 11, 11, + 5, 9, 5, 3, 7, 5, 7, 7, 15, 5, + 9, 5, 2, 7, 5, 5, 7, 3, 3, 3, + 3, 3, 3, 3, 1, 3 }; +static CONST TclDatetabelem TclDatechk[]={ + +-10000000, -4, -5, -6, -7, -8, -9, -10, -11, -12, + -13, -14, 268, 269, 259, 272, 263, 270, 274, 258, + -2, -15, 265, 45, 43, -1, 266, 273, 264, 261, + 58, 258, 47, 45, 263, -1, 271, 269, 272, 268, + 258, 263, 268, -1, 44, 268, 257, 268, 268, 268, + 263, 268, 268, 272, 268, 44, 263, -1, 258, -1, + 46, -3, 45, 58, 261, 47, 45, 45, 58, 268, + 268, 268, 268, 268, 268, 268, 268, -3, 45, 58, + 268, 268 }; +static CONST TclDatetabelem TclDatedef[]={ + + 1, -2, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 53, 18, 19, 27, 0, 33, 0, 20, + 0, 42, 0, 48, 49, 47, 50, 51, 52, 12, + 0, 22, 0, 0, 32, 44, 17, 0, 39, 30, + 24, 35, 0, 45, 21, 0, 41, 0, 54, 25, + 0, 0, 34, 37, 0, 0, 36, 46, 23, 43, + 0, 13, 0, 0, 55, 0, 0, 0, 0, 31, + 40, 14, 54, 26, 28, 29, 0, 15, 0, 0, + 16, 38 }; +typedef struct +#ifdef __cplusplus + TclDatetoktype +#endif +{ char *t_name; int t_val; } TclDatetoktype; +#ifndef YYDEBUG +# define YYDEBUG 0 /* don't allow debugging */ +#endif + +#if YYDEBUG + +TclDatetoktype TclDatetoks[] = +{ + "tAGO", 257, + "tDAY", 258, + "tDAYZONE", 259, + "tID", 260, + "tMERIDIAN", 261, + "tMINUTE_UNIT", 262, + "tMONTH", 263, + "tMONTH_UNIT", 264, + "tSTARDATE", 265, + "tSEC_UNIT", 266, + "tSNUMBER", 267, + "tUNUMBER", 268, + "tZONE", 269, + "tEPOCH", 270, + "tDST", 271, + "tISOBASE", 272, + "tDAY_UNIT", 273, + "tNEXT", 274, + "-unknown-", -1 /* ends search */ +}; + +char * TclDatereds[] = +{ + "-no such reduction-", + "spec : /* empty */", + "spec : spec item", + "item : time", + "item : zone", + "item : date", + "item : ordMonth", + "item : day", + "item : relspec", + "item : iso", + "item : trek", + "item : number", + "time : tUNUMBER tMERIDIAN", + "time : tUNUMBER ':' tUNUMBER o_merid", + "time : tUNUMBER ':' tUNUMBER '-' tUNUMBER", + "time : tUNUMBER ':' tUNUMBER ':' tUNUMBER o_merid", + "time : tUNUMBER ':' tUNUMBER ':' tUNUMBER '-' tUNUMBER", + "zone : tZONE tDST", + "zone : tZONE", + "zone : tDAYZONE", + "day : tDAY", + "day : tDAY ','", + "day : tUNUMBER tDAY", + "day : sign tUNUMBER tDAY", + "day : tNEXT tDAY", + "date : tUNUMBER '/' tUNUMBER", + "date : tUNUMBER '/' tUNUMBER '/' tUNUMBER", + "date : tISOBASE", + "date : tUNUMBER '-' tMONTH '-' tUNUMBER", + "date : tUNUMBER '-' tUNUMBER '-' tUNUMBER", + "date : tMONTH tUNUMBER", + "date : tMONTH tUNUMBER ',' tUNUMBER", + "date : tUNUMBER tMONTH", + "date : tEPOCH", + "date : tUNUMBER tMONTH tUNUMBER", + "ordMonth : tNEXT tMONTH", + "ordMonth : tNEXT tUNUMBER tMONTH", + "iso : tISOBASE tZONE tISOBASE", + "iso : tISOBASE tZONE tUNUMBER ':' tUNUMBER ':' tUNUMBER", + "iso : tISOBASE tISOBASE", + "trek : tSTARDATE tUNUMBER '.' tUNUMBER", + "relspec : relunits tAGO", + "relspec : relunits", + "relunits : sign tUNUMBER unit", + "relunits : tUNUMBER unit", + "relunits : tNEXT unit", + "relunits : tNEXT tUNUMBER unit", + "relunits : unit", + "sign : '-'", + "sign : '+'", + "unit : tSEC_UNIT", + "unit : tDAY_UNIT", + "unit : tMONTH_UNIT", + "number : tUNUMBER", + "o_merid : /* empty */", + "o_merid : tMERIDIAN", +}; +#endif /* YYDEBUG */ +/* + * Copyright (c) 1993 by Sun Microsystems, Inc. + */ + + +/* +** Skeleton parser driver for yacc output +*/ + +/* +** yacc user known macros and defines +*/ +#define YYERROR goto TclDateerrlab +#define YYACCEPT return(0) +#define YYABORT return(1) +#define YYBACKUP( newtoken, newvalue )\ +{\ + if ( TclDatechar >= 0 || ( TclDater2[ TclDatetmp ] >> 1 ) != 1 )\ + {\ + TclDateerror( "syntax error - cannot backup" );\ + goto TclDateerrlab;\ + }\ + TclDatechar = newtoken;\ + TclDatestate = *TclDateps;\ + TclDatelval = newvalue;\ + goto TclDatenewstate;\ +} +#define YYRECOVERING() (!!TclDateerrflag) +#define YYNEW(type) malloc(sizeof(type) * TclDatenewmax) +#define YYCOPY(to, from, type) \ + (type *) memcpy(to, (char *) from, TclDatemaxdepth * sizeof (type)) +#define YYENLARGE( from, type) \ + (type *) realloc((char *) from, TclDatenewmax * sizeof(type)) +#ifndef YYDEBUG +# define YYDEBUG 1 /* make debugging available */ +#endif + +/* +** user known globals +*/ +int TclDatedebug; /* set to 1 to get debugging */ + +/* +** driver internal defines +*/ +#define YYFLAG (-10000000) + +/* +** global variables used by the parser +*/ +YYSTYPE *TclDatepv; /* top of value stack */ +int *TclDateps; /* top of state stack */ + +int TclDatestate; /* current state */ +int TclDatetmp; /* extra var (lasts between blocks) */ + +int TclDatenerrs; /* number of errors */ +int TclDateerrflag; /* error recovery flag */ +int TclDatechar; /* current input token number */ + + + +#ifdef YYNMBCHARS +#define YYLEX() TclDatecvtok(TclDatelex()) +/* +** TclDatecvtok - return a token if i is a wchar_t value that exceeds 255. +** If i<255, i itself is the token. If i>255 but the neither +** of the 30th or 31st bit is on, i is already a token. +*/ +#if defined(__STDC__) || defined(__cplusplus) +int TclDatecvtok(int i) +#else +int TclDatecvtok(i) int i; +#endif +{ + int first = 0; + int last = YYNMBCHARS - 1; + int mid; + wchar_t j; + + if(i&0x60000000){/*Must convert to a token. */ + if( TclDatembchars[last].character < i ){ + return i;/*Giving up*/ + } + while ((last>=first)&&(first>=0)) {/*Binary search loop*/ + mid = (first+last)/2; + j = TclDatembchars[mid].character; + if( j==i ){/*Found*/ + return TclDatembchars[mid].tvalue; + }else if( j= 0; + TclDate_i++ ) + { + if ( TclDatetoks[TclDate_i].t_val == TclDatechar ) + break; + } + printf( "%s\n", TclDatetoks[TclDate_i].t_name ); + } + } +#endif /* YYDEBUG */ + if ( ++TclDate_ps >= &TclDates[ TclDatemaxdepth ] ) /* room on stack? */ + { + /* + ** reallocate and recover. Note that pointers + ** have to be reset, or bad things will happen + */ + long TclDateps_index = (TclDate_ps - TclDates); + long TclDatepv_index = (TclDate_pv - TclDatev); + long TclDatepvt_index = (TclDatepvt - TclDatev); + int TclDatenewmax; +#ifdef YYEXPAND + TclDatenewmax = YYEXPAND(TclDatemaxdepth); +#else + TclDatenewmax = 2 * TclDatemaxdepth; /* double table size */ + if (TclDatemaxdepth == YYMAXDEPTH) /* first time growth */ + { + char *newTclDates = (char *)YYNEW(int); + char *newTclDatev = (char *)YYNEW(YYSTYPE); + if (newTclDates != 0 && newTclDatev != 0) + { + TclDates = YYCOPY(newTclDates, TclDates, int); + TclDatev = YYCOPY(newTclDatev, TclDatev, YYSTYPE); + } + else + TclDatenewmax = 0; /* failed */ + } + else /* not first time */ + { + TclDates = YYENLARGE(TclDates, int); + TclDatev = YYENLARGE(TclDatev, YYSTYPE); + if (TclDates == 0 || TclDatev == 0) + TclDatenewmax = 0; /* failed */ + } +#endif + if (TclDatenewmax <= TclDatemaxdepth) /* tables not expanded */ + { + TclDateerror( "yacc stack overflow" ); + YYABORT; + } + TclDatemaxdepth = TclDatenewmax; + + TclDate_ps = TclDates + TclDateps_index; + TclDate_pv = TclDatev + TclDatepv_index; + TclDatepvt = TclDatev + TclDatepvt_index; + } + *TclDate_ps = TclDate_state; + *++TclDate_pv = TclDateval; + + /* + ** we have a new state - find out what to do + */ + TclDate_newstate: + if ( ( TclDate_n = TclDatepact[ TclDate_state ] ) <= YYFLAG ) + goto TclDatedefault; /* simple state */ +#if YYDEBUG + /* + ** if debugging, need to mark whether new token grabbed + */ + TclDatetmp = TclDatechar < 0; +#endif + if ( ( TclDatechar < 0 ) && ( ( TclDatechar = YYLEX() ) < 0 ) ) + TclDatechar = 0; /* reached EOF */ +#if YYDEBUG + if ( TclDatedebug && TclDatetmp ) + { + register int TclDate_i; + + printf( "Received token " ); + if ( TclDatechar == 0 ) + printf( "end-of-file\n" ); + else if ( TclDatechar < 0 ) + printf( "-none-\n" ); + else + { + for ( TclDate_i = 0; TclDatetoks[TclDate_i].t_val >= 0; + TclDate_i++ ) + { + if ( TclDatetoks[TclDate_i].t_val == TclDatechar ) + break; + } + printf( "%s\n", TclDatetoks[TclDate_i].t_name ); + } + } +#endif /* YYDEBUG */ + if ( ( ( TclDate_n += TclDatechar ) < 0 ) || ( TclDate_n >= YYLAST ) ) + goto TclDatedefault; + if ( TclDatechk[ TclDate_n = TclDateact[ TclDate_n ] ] == TclDatechar ) /*valid shift*/ + { + TclDatechar = -1; + TclDateval = TclDatelval; + TclDate_state = TclDate_n; + if ( TclDateerrflag > 0 ) + TclDateerrflag--; + goto TclDate_stack; + } + + TclDatedefault: + if ( ( TclDate_n = TclDatedef[ TclDate_state ] ) == -2 ) + { +#if YYDEBUG + TclDatetmp = TclDatechar < 0; +#endif + if ( ( TclDatechar < 0 ) && ( ( TclDatechar = YYLEX() ) < 0 ) ) + TclDatechar = 0; /* reached EOF */ +#if YYDEBUG + if ( TclDatedebug && TclDatetmp ) + { + register int TclDate_i; + + printf( "Received token " ); + if ( TclDatechar == 0 ) + printf( "end-of-file\n" ); + else if ( TclDatechar < 0 ) + printf( "-none-\n" ); + else + { + for ( TclDate_i = 0; + TclDatetoks[TclDate_i].t_val >= 0; + TclDate_i++ ) + { + if ( TclDatetoks[TclDate_i].t_val + == TclDatechar ) + { + break; + } + } + printf( "%s\n", TclDatetoks[TclDate_i].t_name ); + } + } +#endif /* YYDEBUG */ + /* + ** look through exception table + */ + { + register CONST int *TclDatexi = TclDateexca; + + while ( ( *TclDatexi != -1 ) || + ( TclDatexi[1] != TclDate_state ) ) + { + TclDatexi += 2; + } + while ( ( *(TclDatexi += 2) >= 0 ) && + ( *TclDatexi != TclDatechar ) ) + ; + if ( ( TclDate_n = TclDatexi[1] ) < 0 ) + YYACCEPT; + } + } + + /* + ** check for syntax error + */ + if ( TclDate_n == 0 ) /* have an error */ + { + /* no worry about speed here! */ + switch ( TclDateerrflag ) + { + case 0: /* new error */ + TclDateerror( "syntax error" ); + goto skip_init; + /* + ** get globals into registers. + ** we have a user generated syntax type error + */ + TclDate_pv = TclDatepv; + TclDate_ps = TclDateps; + TclDate_state = TclDatestate; + skip_init: + TclDatenerrs++; + /* FALLTHRU */ + case 1: + case 2: /* incompletely recovered error */ + /* try again... */ + TclDateerrflag = 3; + /* + ** find state where "error" is a legal + ** shift action + */ + while ( TclDate_ps >= TclDates ) + { + TclDate_n = TclDatepact[ *TclDate_ps ] + YYERRCODE; + if ( TclDate_n >= 0 && TclDate_n < YYLAST && + TclDatechk[TclDateact[TclDate_n]] == YYERRCODE) { + /* + ** simulate shift of "error" + */ + TclDate_state = TclDateact[ TclDate_n ]; + goto TclDate_stack; + } + /* + ** current state has no shift on + ** "error", pop stack + */ +#if YYDEBUG +# define _POP_ "Error recovery pops state %d, uncovers state %d\n" + if ( TclDatedebug ) + printf( _POP_, *TclDate_ps, + TclDate_ps[-1] ); +# undef _POP_ +#endif + TclDate_ps--; + TclDate_pv--; + } + /* + ** there is no state on stack with "error" as + ** a valid shift. give up. + */ + YYABORT; + case 3: /* no shift yet; eat a token */ +#if YYDEBUG + /* + ** if debugging, look up token in list of + ** pairs. 0 and negative shouldn't occur, + ** but since timing doesn't matter when + ** debugging, it doesn't hurt to leave the + ** tests here. + */ + if ( TclDatedebug ) + { + register int TclDate_i; + + printf( "Error recovery discards " ); + if ( TclDatechar == 0 ) + printf( "token end-of-file\n" ); + else if ( TclDatechar < 0 ) + printf( "token -none-\n" ); + else + { + for ( TclDate_i = 0; + TclDatetoks[TclDate_i].t_val >= 0; + TclDate_i++ ) + { + if ( TclDatetoks[TclDate_i].t_val + == TclDatechar ) + { + break; + } + } + printf( "token %s\n", + TclDatetoks[TclDate_i].t_name ); + } + } +#endif /* YYDEBUG */ + if ( TclDatechar == 0 ) /* reached EOF. quit */ + YYABORT; + TclDatechar = -1; + goto TclDate_newstate; + } + }/* end if ( TclDate_n == 0 ) */ + /* + ** reduction by production TclDate_n + ** put stack tops, etc. so things right after switch + */ +#if YYDEBUG + /* + ** if debugging, print the string that is the user's + ** specification of the reduction which is just about + ** to be done. + */ + if ( TclDatedebug ) + printf( "Reduce by (%d) \"%s\"\n", + TclDate_n, TclDatereds[ TclDate_n ] ); +#endif + TclDatetmp = TclDate_n; /* value to switch over */ + TclDatepvt = TclDate_pv; /* $vars top of value stack */ + /* + ** Look in goto table for next state + ** Sorry about using TclDate_state here as temporary + ** register variable, but why not, if it works... + ** If TclDater2[ TclDate_n ] doesn't have the low order bit + ** set, then there is no action to be done for + ** this reduction. So, no saving & unsaving of + ** registers done. The only difference between the + ** code just after the if and the body of the if is + ** the goto TclDate_stack in the body. This way the test + ** can be made before the choice of what to do is needed. + */ + { + /* length of production doubled with extra bit */ + register int TclDate_len = TclDater2[ TclDate_n ]; + + if ( !( TclDate_len & 01 ) ) + { + TclDate_len >>= 1; + TclDateval = ( TclDate_pv -= TclDate_len )[1]; /* $$ = $1 */ + TclDate_state = TclDatepgo[ TclDate_n = TclDater1[ TclDate_n ] ] + + *( TclDate_ps -= TclDate_len ) + 1; + if ( TclDate_state >= YYLAST || + TclDatechk[ TclDate_state = + TclDateact[ TclDate_state ] ] != -TclDate_n ) + { + TclDate_state = TclDateact[ TclDatepgo[ TclDate_n ] ]; + } + goto TclDate_stack; + } + TclDate_len >>= 1; + TclDateval = ( TclDate_pv -= TclDate_len )[1]; /* $$ = $1 */ + TclDate_state = TclDatepgo[ TclDate_n = TclDater1[ TclDate_n ] ] + + *( TclDate_ps -= TclDate_len ) + 1; + if ( TclDate_state >= YYLAST || + TclDatechk[ TclDate_state = TclDateact[ TclDate_state ] ] != -TclDate_n ) + { + TclDate_state = TclDateact[ TclDatepgo[ TclDate_n ] ]; + } + } + /* save until reenter driver code */ + TclDatestate = TclDate_state; + TclDateps = TclDate_ps; + TclDatepv = TclDate_pv; + } + /* + ** code supplied by user is placed in this switch + */ + switch( TclDatetmp ) + { + +case 3:{ + TclDateHaveTime++; + } break; +case 4:{ + TclDateHaveZone++; + } break; +case 5:{ + TclDateHaveDate++; + } break; +case 6:{ + TclDateHaveOrdinalMonth++; + } break; +case 7:{ + TclDateHaveDay++; + } break; +case 8:{ + TclDateHaveRel++; + } break; +case 9:{ + TclDateHaveTime++; + TclDateHaveDate++; + } break; +case 10:{ + TclDateHaveTime++; + TclDateHaveDate++; + TclDateHaveRel++; + } break; +case 12:{ + TclDateHour = TclDatepvt[-1].Number; + TclDateMinutes = 0; + TclDateSeconds = 0; + TclDateMeridian = TclDatepvt[-0].Meridian; + } break; +case 13:{ + TclDateHour = TclDatepvt[-3].Number; + TclDateMinutes = TclDatepvt[-1].Number; + TclDateSeconds = 0; + TclDateMeridian = TclDatepvt[-0].Meridian; + } break; +case 14:{ + TclDateHour = TclDatepvt[-4].Number; + TclDateMinutes = TclDatepvt[-2].Number; + TclDateMeridian = MER24; + TclDateDSTmode = DSToff; + TclDateTimezone = (TclDatepvt[-0].Number % 100 + (TclDatepvt[-0].Number / 100) * 60); + } break; +case 15:{ + TclDateHour = TclDatepvt[-5].Number; + TclDateMinutes = TclDatepvt[-3].Number; + TclDateSeconds = TclDatepvt[-1].Number; + TclDateMeridian = TclDatepvt[-0].Meridian; + } break; +case 16:{ + TclDateHour = TclDatepvt[-6].Number; + TclDateMinutes = TclDatepvt[-4].Number; + TclDateSeconds = TclDatepvt[-2].Number; + TclDateMeridian = MER24; + TclDateDSTmode = DSToff; + TclDateTimezone = (TclDatepvt[-0].Number % 100 + (TclDatepvt[-0].Number / 100) * 60); + } break; +case 17:{ + TclDateTimezone = TclDatepvt[-1].Number; + TclDateDSTmode = DSTon; + } break; +case 18:{ + TclDateTimezone = TclDatepvt[-0].Number; + TclDateDSTmode = DSToff; + } break; +case 19:{ + TclDateTimezone = TclDatepvt[-0].Number; + TclDateDSTmode = DSTon; + } break; +case 20:{ + TclDateDayOrdinal = 1; + TclDateDayNumber = TclDatepvt[-0].Number; + } break; +case 21:{ + TclDateDayOrdinal = 1; + TclDateDayNumber = TclDatepvt[-1].Number; + } break; +case 22:{ + TclDateDayOrdinal = TclDatepvt[-1].Number; + TclDateDayNumber = TclDatepvt[-0].Number; + } break; +case 23:{ + TclDateDayOrdinal = TclDatepvt[-2].Number * TclDatepvt[-1].Number; + TclDateDayNumber = TclDatepvt[-0].Number; + } break; +case 24:{ + TclDateDayOrdinal = 2; + TclDateDayNumber = TclDatepvt[-0].Number; + } break; +case 25:{ + TclDateMonth = TclDatepvt[-2].Number; + TclDateDay = TclDatepvt[-0].Number; + } break; +case 26:{ + TclDateMonth = TclDatepvt[-4].Number; + TclDateDay = TclDatepvt[-2].Number; + TclDateYear = TclDatepvt[-0].Number; + } break; +case 27:{ + TclDateYear = TclDatepvt[-0].Number / 10000; + TclDateMonth = (TclDatepvt[-0].Number % 10000)/100; + TclDateDay = TclDatepvt[-0].Number % 100; + } break; +case 28:{ + TclDateDay = TclDatepvt[-4].Number; + TclDateMonth = TclDatepvt[-2].Number; + TclDateYear = TclDatepvt[-0].Number; + } break; +case 29:{ + TclDateMonth = TclDatepvt[-2].Number; + TclDateDay = TclDatepvt[-0].Number; + TclDateYear = TclDatepvt[-4].Number; + } break; +case 30:{ + TclDateMonth = TclDatepvt[-1].Number; + TclDateDay = TclDatepvt[-0].Number; + } break; +case 31:{ + TclDateMonth = TclDatepvt[-3].Number; + TclDateDay = TclDatepvt[-2].Number; + TclDateYear = TclDatepvt[-0].Number; + } break; +case 32:{ + TclDateMonth = TclDatepvt[-0].Number; + TclDateDay = TclDatepvt[-1].Number; + } break; +case 33:{ + TclDateMonth = 1; + TclDateDay = 1; + TclDateYear = EPOCH; + } break; +case 34:{ + TclDateMonth = TclDatepvt[-1].Number; + TclDateDay = TclDatepvt[-2].Number; + TclDateYear = TclDatepvt[-0].Number; + } break; +case 35:{ + TclDateMonthOrdinal = 1; + TclDateMonth = TclDatepvt[-0].Number; + } break; +case 36:{ + TclDateMonthOrdinal = TclDatepvt[-1].Number; + TclDateMonth = TclDatepvt[-0].Number; + } break; +case 37:{ + if (TclDatepvt[-1].Number != HOUR(- 7)) YYABORT; + TclDateYear = TclDatepvt[-2].Number / 10000; + TclDateMonth = (TclDatepvt[-2].Number % 10000)/100; + TclDateDay = TclDatepvt[-2].Number % 100; + TclDateHour = TclDatepvt[-0].Number / 10000; + TclDateMinutes = (TclDatepvt[-0].Number % 10000)/100; + TclDateSeconds = TclDatepvt[-0].Number % 100; + } break; +case 38:{ + if (TclDatepvt[-5].Number != HOUR(- 7)) YYABORT; + TclDateYear = TclDatepvt[-6].Number / 10000; + TclDateMonth = (TclDatepvt[-6].Number % 10000)/100; + TclDateDay = TclDatepvt[-6].Number % 100; + TclDateHour = TclDatepvt[-4].Number; + TclDateMinutes = TclDatepvt[-2].Number; + TclDateSeconds = TclDatepvt[-0].Number; + } break; +case 39:{ + TclDateYear = TclDatepvt[-1].Number / 10000; + TclDateMonth = (TclDatepvt[-1].Number % 10000)/100; + TclDateDay = TclDatepvt[-1].Number % 100; + TclDateHour = TclDatepvt[-0].Number / 10000; + TclDateMinutes = (TclDatepvt[-0].Number % 10000)/100; + TclDateSeconds = TclDatepvt[-0].Number % 100; + } break; +case 40:{ + /* + * Offset computed year by -377 so that the returned years will + * be in a range accessible with a 32 bit clock seconds value + */ + TclDateYear = TclDatepvt[-2].Number/1000 + 2323 - 377; + TclDateDay = 1; + TclDateMonth = 1; + TclDateRelDay += ((TclDatepvt[-2].Number%1000)*(365 + IsLeapYear(TclDateYear)))/1000; + TclDateRelSeconds += TclDatepvt[-0].Number * 144 * 60; + } break; +case 41:{ + TclDateRelSeconds *= -1; + TclDateRelMonth *= -1; + TclDateRelDay *= -1; + } break; +case 43:{ *TclDateRelPointer += TclDatepvt[-2].Number * TclDatepvt[-1].Number * TclDatepvt[-0].Number; } break; +case 44:{ *TclDateRelPointer += TclDatepvt[-1].Number * TclDatepvt[-0].Number; } break; +case 45:{ *TclDateRelPointer += TclDatepvt[-0].Number; } break; +case 46:{ *TclDateRelPointer += TclDatepvt[-1].Number * TclDatepvt[-0].Number; } break; +case 47:{ *TclDateRelPointer += TclDatepvt[-0].Number; } break; +case 48:{ TclDateval.Number = -1; } break; +case 49:{ TclDateval.Number = 1; } break; +case 50:{ TclDateval.Number = TclDatepvt[-0].Number; TclDateRelPointer = &TclDateRelSeconds; } break; +case 51:{ TclDateval.Number = TclDatepvt[-0].Number; TclDateRelPointer = &TclDateRelDay; } break; +case 52:{ TclDateval.Number = TclDatepvt[-0].Number; TclDateRelPointer = &TclDateRelMonth; } break; +case 53:{ + if (TclDateHaveTime && TclDateHaveDate && !TclDateHaveRel) { + TclDateYear = TclDatepvt[-0].Number; + } else { + TclDateHaveTime++; + if (TclDatepvt[-0].Number < 100) { + TclDateHour = TclDatepvt[-0].Number; + TclDateMinutes = 0; + } else { + TclDateHour = TclDatepvt[-0].Number / 100; + TclDateMinutes = TclDatepvt[-0].Number % 100; + } + TclDateSeconds = 0; + TclDateMeridian = MER24; + } + } break; +case 54:{ + TclDateval.Meridian = MER24; + } break; +case 55:{ + TclDateval.Meridian = TclDatepvt[-0].Meridian; + } break; + } + goto TclDatestack; /* reset registers in driver code */ +} +