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