/* * 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.1.1.1 2007/07/10 15:04:23 duncan 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 */ }