/*
|
/*
|
* tclDate.c --
|
* tclDate.c --
|
*
|
*
|
* This file is generated from a yacc grammar defined in
|
* This file is generated from a yacc grammar defined in
|
* the file tclGetDate.y. It should not be edited directly.
|
* the file tclGetDate.y. It should not be edited directly.
|
*
|
*
|
* Copyright (c) 1992-1995 Karl Lehenbauer and Mark Diekhans.
|
* Copyright (c) 1992-1995 Karl Lehenbauer and Mark Diekhans.
|
* Copyright (c) 1995-1997 Sun Microsystems, Inc.
|
* Copyright (c) 1995-1997 Sun Microsystems, Inc.
|
*
|
*
|
* See the file "license.terms" for information on usage and redistribution
|
* See the file "license.terms" for information on usage and redistribution
|
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
*
|
*
|
* RCS: @(#) $Id: tclDate.c,v 1.1.1.1 2002-01-16 10:25:26 markom Exp $
|
* RCS: @(#) $Id: tclDate.c,v 1.1.1.1 2002-01-16 10:25:26 markom Exp $
|
*/
|
*/
|
|
|
#include "tclInt.h"
|
#include "tclInt.h"
|
#include "tclPort.h"
|
#include "tclPort.h"
|
|
|
#ifdef MAC_TCL
|
#ifdef MAC_TCL
|
# define EPOCH 1904
|
# define EPOCH 1904
|
# define START_OF_TIME 1904
|
# define START_OF_TIME 1904
|
# define END_OF_TIME 2039
|
# define END_OF_TIME 2039
|
#else
|
#else
|
# define EPOCH 1970
|
# define EPOCH 1970
|
# define START_OF_TIME 1902
|
# define START_OF_TIME 1902
|
# define END_OF_TIME 2037
|
# define END_OF_TIME 2037
|
#endif
|
#endif
|
|
|
/*
|
/*
|
* The offset of tm_year of struct tm returned by localtime, gmtime, etc.
|
* 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
|
* 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,
|
* ../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
|
* some systems may have a different value. This #define should be the
|
* same as in ../compat/strftime.c.
|
* same as in ../compat/strftime.c.
|
*/
|
*/
|
#define TM_YEAR_BASE 1900
|
#define TM_YEAR_BASE 1900
|
|
|
#define HOUR(x) ((int) (60 * x))
|
#define HOUR(x) ((int) (60 * x))
|
#define SECSPERDAY (24L * 60L * 60L)
|
#define SECSPERDAY (24L * 60L * 60L)
|
|
|
|
|
/*
|
/*
|
* An entry in the lexical lookup table.
|
* An entry in the lexical lookup table.
|
*/
|
*/
|
typedef struct _TABLE {
|
typedef struct _TABLE {
|
char *name;
|
char *name;
|
int type;
|
int type;
|
time_t value;
|
time_t value;
|
} TABLE;
|
} TABLE;
|
|
|
|
|
/*
|
/*
|
* Daylight-savings mode: on, off, or not yet known.
|
* Daylight-savings mode: on, off, or not yet known.
|
*/
|
*/
|
typedef enum _DSTMODE {
|
typedef enum _DSTMODE {
|
DSTon, DSToff, DSTmaybe
|
DSTon, DSToff, DSTmaybe
|
} DSTMODE;
|
} DSTMODE;
|
|
|
/*
|
/*
|
* Meridian: am, pm, or 24-hour style.
|
* Meridian: am, pm, or 24-hour style.
|
*/
|
*/
|
typedef enum _MERIDIAN {
|
typedef enum _MERIDIAN {
|
MERam, MERpm, MER24
|
MERam, MERpm, MER24
|
} MERIDIAN;
|
} MERIDIAN;
|
|
|
|
|
/*
|
/*
|
* Global variables. We could get rid of most of these by using a good
|
* 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
|
* union as the yacc stack. (This routine was originally written before
|
* yacc had the %union construct.) Maybe someday; right now we only use
|
* yacc had the %union construct.) Maybe someday; right now we only use
|
* the %union very rarely.
|
* the %union very rarely.
|
*/
|
*/
|
static char *TclDateInput;
|
static char *TclDateInput;
|
static DSTMODE TclDateDSTmode;
|
static DSTMODE TclDateDSTmode;
|
static time_t TclDateDayOrdinal;
|
static time_t TclDateDayOrdinal;
|
static time_t TclDateDayNumber;
|
static time_t TclDateDayNumber;
|
static int TclDateHaveDate;
|
static int TclDateHaveDate;
|
static int TclDateHaveDay;
|
static int TclDateHaveDay;
|
static int TclDateHaveRel;
|
static int TclDateHaveRel;
|
static int TclDateHaveTime;
|
static int TclDateHaveTime;
|
static int TclDateHaveZone;
|
static int TclDateHaveZone;
|
static time_t TclDateTimezone;
|
static time_t TclDateTimezone;
|
static time_t TclDateDay;
|
static time_t TclDateDay;
|
static time_t TclDateHour;
|
static time_t TclDateHour;
|
static time_t TclDateMinutes;
|
static time_t TclDateMinutes;
|
static time_t TclDateMonth;
|
static time_t TclDateMonth;
|
static time_t TclDateSeconds;
|
static time_t TclDateSeconds;
|
static time_t TclDateYear;
|
static time_t TclDateYear;
|
static MERIDIAN TclDateMeridian;
|
static MERIDIAN TclDateMeridian;
|
static time_t TclDateRelMonth;
|
static time_t TclDateRelMonth;
|
static time_t TclDateRelSeconds;
|
static time_t TclDateRelSeconds;
|
|
|
|
|
/*
|
/*
|
* Prototypes of internal functions.
|
* Prototypes of internal functions.
|
*/
|
*/
|
static void TclDateerror _ANSI_ARGS_((char *s));
|
static void TclDateerror _ANSI_ARGS_((char *s));
|
static time_t ToSeconds _ANSI_ARGS_((time_t Hours, time_t Minutes,
|
static time_t ToSeconds _ANSI_ARGS_((time_t Hours, time_t Minutes,
|
time_t Seconds, MERIDIAN Meridian));
|
time_t Seconds, MERIDIAN Meridian));
|
static int Convert _ANSI_ARGS_((time_t Month, time_t Day, time_t Year,
|
static int Convert _ANSI_ARGS_((time_t Month, time_t Day, time_t Year,
|
time_t Hours, time_t Minutes, time_t Seconds,
|
time_t Hours, time_t Minutes, time_t Seconds,
|
MERIDIAN Meridia, DSTMODE DSTmode, time_t *TimePtr));
|
MERIDIAN Meridia, DSTMODE DSTmode, time_t *TimePtr));
|
static time_t DSTcorrect _ANSI_ARGS_((time_t Start, time_t Future));
|
static time_t DSTcorrect _ANSI_ARGS_((time_t Start, time_t Future));
|
static time_t RelativeDate _ANSI_ARGS_((time_t Start, time_t DayOrdinal,
|
static time_t RelativeDate _ANSI_ARGS_((time_t Start, time_t DayOrdinal,
|
time_t DayNumber));
|
time_t DayNumber));
|
static int RelativeMonth _ANSI_ARGS_((time_t Start, time_t RelMonth,
|
static int RelativeMonth _ANSI_ARGS_((time_t Start, time_t RelMonth,
|
time_t *TimePtr));
|
time_t *TimePtr));
|
static int LookupWord _ANSI_ARGS_((char *buff));
|
static int LookupWord _ANSI_ARGS_((char *buff));
|
static int TclDatelex _ANSI_ARGS_((void));
|
static int TclDatelex _ANSI_ARGS_((void));
|
|
|
int
|
int
|
TclDateparse _ANSI_ARGS_((void));
|
TclDateparse _ANSI_ARGS_((void));
|
typedef union
|
typedef union
|
#ifdef __cplusplus
|
#ifdef __cplusplus
|
YYSTYPE
|
YYSTYPE
|
#endif
|
#endif
|
{
|
{
|
time_t Number;
|
time_t Number;
|
enum _MERIDIAN Meridian;
|
enum _MERIDIAN Meridian;
|
} YYSTYPE;
|
} YYSTYPE;
|
# define tAGO 257
|
# define tAGO 257
|
# define tDAY 258
|
# define tDAY 258
|
# define tDAYZONE 259
|
# define tDAYZONE 259
|
# define tID 260
|
# define tID 260
|
# define tMERIDIAN 261
|
# define tMERIDIAN 261
|
# define tMINUTE_UNIT 262
|
# define tMINUTE_UNIT 262
|
# define tMONTH 263
|
# define tMONTH 263
|
# define tMONTH_UNIT 264
|
# define tMONTH_UNIT 264
|
# define tSEC_UNIT 265
|
# define tSEC_UNIT 265
|
# define tSNUMBER 266
|
# define tSNUMBER 266
|
# define tUNUMBER 267
|
# define tUNUMBER 267
|
# define tZONE 268
|
# define tZONE 268
|
# define tEPOCH 269
|
# define tEPOCH 269
|
# define tDST 270
|
# define tDST 270
|
|
|
|
|
|
|
#ifdef __cplusplus
|
#ifdef __cplusplus
|
|
|
#ifndef TclDateerror
|
#ifndef TclDateerror
|
void TclDateerror(const char *);
|
void TclDateerror(const char *);
|
#endif
|
#endif
|
|
|
#ifndef TclDatelex
|
#ifndef TclDatelex
|
#ifdef __EXTERN_C__
|
#ifdef __EXTERN_C__
|
extern "C" { int TclDatelex(void); }
|
extern "C" { int TclDatelex(void); }
|
#else
|
#else
|
int TclDatelex(void);
|
int TclDatelex(void);
|
#endif
|
#endif
|
#endif
|
#endif
|
int TclDateparse(void);
|
int TclDateparse(void);
|
|
|
#endif
|
#endif
|
#define TclDateclearin TclDatechar = -1
|
#define TclDateclearin TclDatechar = -1
|
#define TclDateerrok TclDateerrflag = 0
|
#define TclDateerrok TclDateerrflag = 0
|
extern int TclDatechar;
|
extern int TclDatechar;
|
extern int TclDateerrflag;
|
extern int TclDateerrflag;
|
YYSTYPE TclDatelval;
|
YYSTYPE TclDatelval;
|
YYSTYPE TclDateval;
|
YYSTYPE TclDateval;
|
typedef int TclDatetabelem;
|
typedef int TclDatetabelem;
|
#ifndef YYMAXDEPTH
|
#ifndef YYMAXDEPTH
|
#define YYMAXDEPTH 150
|
#define YYMAXDEPTH 150
|
#endif
|
#endif
|
#if YYMAXDEPTH > 0
|
#if YYMAXDEPTH > 0
|
int TclDate_TclDates[YYMAXDEPTH], *TclDates = TclDate_TclDates;
|
int TclDate_TclDates[YYMAXDEPTH], *TclDates = TclDate_TclDates;
|
YYSTYPE TclDate_TclDatev[YYMAXDEPTH], *TclDatev = TclDate_TclDatev;
|
YYSTYPE TclDate_TclDatev[YYMAXDEPTH], *TclDatev = TclDate_TclDatev;
|
#else /* user does initial allocation */
|
#else /* user does initial allocation */
|
int *TclDates;
|
int *TclDates;
|
YYSTYPE *TclDatev;
|
YYSTYPE *TclDatev;
|
#endif
|
#endif
|
static int TclDatemaxdepth = YYMAXDEPTH;
|
static int TclDatemaxdepth = YYMAXDEPTH;
|
# define YYERRCODE 256
|
# define YYERRCODE 256
|
|
|
|
|
/*
|
/*
|
* Month and day table.
|
* Month and day table.
|
*/
|
*/
|
static TABLE MonthDayTable[] = {
|
static TABLE MonthDayTable[] = {
|
{ "january", tMONTH, 1 },
|
{ "january", tMONTH, 1 },
|
{ "february", tMONTH, 2 },
|
{ "february", tMONTH, 2 },
|
{ "march", tMONTH, 3 },
|
{ "march", tMONTH, 3 },
|
{ "april", tMONTH, 4 },
|
{ "april", tMONTH, 4 },
|
{ "may", tMONTH, 5 },
|
{ "may", tMONTH, 5 },
|
{ "june", tMONTH, 6 },
|
{ "june", tMONTH, 6 },
|
{ "july", tMONTH, 7 },
|
{ "july", tMONTH, 7 },
|
{ "august", tMONTH, 8 },
|
{ "august", tMONTH, 8 },
|
{ "september", tMONTH, 9 },
|
{ "september", tMONTH, 9 },
|
{ "sept", tMONTH, 9 },
|
{ "sept", tMONTH, 9 },
|
{ "october", tMONTH, 10 },
|
{ "october", tMONTH, 10 },
|
{ "november", tMONTH, 11 },
|
{ "november", tMONTH, 11 },
|
{ "december", tMONTH, 12 },
|
{ "december", tMONTH, 12 },
|
{ "sunday", tDAY, 0 },
|
{ "sunday", tDAY, 0 },
|
{ "monday", tDAY, 1 },
|
{ "monday", tDAY, 1 },
|
{ "tuesday", tDAY, 2 },
|
{ "tuesday", tDAY, 2 },
|
{ "tues", tDAY, 2 },
|
{ "tues", tDAY, 2 },
|
{ "wednesday", tDAY, 3 },
|
{ "wednesday", tDAY, 3 },
|
{ "wednes", tDAY, 3 },
|
{ "wednes", tDAY, 3 },
|
{ "thursday", tDAY, 4 },
|
{ "thursday", tDAY, 4 },
|
{ "thur", tDAY, 4 },
|
{ "thur", tDAY, 4 },
|
{ "thurs", tDAY, 4 },
|
{ "thurs", tDAY, 4 },
|
{ "friday", tDAY, 5 },
|
{ "friday", tDAY, 5 },
|
{ "saturday", tDAY, 6 },
|
{ "saturday", tDAY, 6 },
|
{ NULL }
|
{ NULL }
|
};
|
};
|
|
|
/*
|
/*
|
* Time units table.
|
* Time units table.
|
*/
|
*/
|
static TABLE UnitsTable[] = {
|
static TABLE UnitsTable[] = {
|
{ "year", tMONTH_UNIT, 12 },
|
{ "year", tMONTH_UNIT, 12 },
|
{ "month", tMONTH_UNIT, 1 },
|
{ "month", tMONTH_UNIT, 1 },
|
{ "fortnight", tMINUTE_UNIT, 14 * 24 * 60 },
|
{ "fortnight", tMINUTE_UNIT, 14 * 24 * 60 },
|
{ "week", tMINUTE_UNIT, 7 * 24 * 60 },
|
{ "week", tMINUTE_UNIT, 7 * 24 * 60 },
|
{ "day", tMINUTE_UNIT, 1 * 24 * 60 },
|
{ "day", tMINUTE_UNIT, 1 * 24 * 60 },
|
{ "hour", tMINUTE_UNIT, 60 },
|
{ "hour", tMINUTE_UNIT, 60 },
|
{ "minute", tMINUTE_UNIT, 1 },
|
{ "minute", tMINUTE_UNIT, 1 },
|
{ "min", tMINUTE_UNIT, 1 },
|
{ "min", tMINUTE_UNIT, 1 },
|
{ "second", tSEC_UNIT, 1 },
|
{ "second", tSEC_UNIT, 1 },
|
{ "sec", tSEC_UNIT, 1 },
|
{ "sec", tSEC_UNIT, 1 },
|
{ NULL }
|
{ NULL }
|
};
|
};
|
|
|
/*
|
/*
|
* Assorted relative-time words.
|
* Assorted relative-time words.
|
*/
|
*/
|
static TABLE OtherTable[] = {
|
static TABLE OtherTable[] = {
|
{ "tomorrow", tMINUTE_UNIT, 1 * 24 * 60 },
|
{ "tomorrow", tMINUTE_UNIT, 1 * 24 * 60 },
|
{ "yesterday", tMINUTE_UNIT, -1 * 24 * 60 },
|
{ "yesterday", tMINUTE_UNIT, -1 * 24 * 60 },
|
{ "today", tMINUTE_UNIT, 0 },
|
{ "today", tMINUTE_UNIT, 0 },
|
{ "now", tMINUTE_UNIT, 0 },
|
{ "now", tMINUTE_UNIT, 0 },
|
{ "last", tUNUMBER, -1 },
|
{ "last", tUNUMBER, -1 },
|
{ "this", tMINUTE_UNIT, 0 },
|
{ "this", tMINUTE_UNIT, 0 },
|
{ "next", tUNUMBER, 2 },
|
{ "next", tUNUMBER, 2 },
|
#if 0
|
#if 0
|
{ "first", tUNUMBER, 1 },
|
{ "first", tUNUMBER, 1 },
|
/* { "second", tUNUMBER, 2 }, */
|
/* { "second", tUNUMBER, 2 }, */
|
{ "third", tUNUMBER, 3 },
|
{ "third", tUNUMBER, 3 },
|
{ "fourth", tUNUMBER, 4 },
|
{ "fourth", tUNUMBER, 4 },
|
{ "fifth", tUNUMBER, 5 },
|
{ "fifth", tUNUMBER, 5 },
|
{ "sixth", tUNUMBER, 6 },
|
{ "sixth", tUNUMBER, 6 },
|
{ "seventh", tUNUMBER, 7 },
|
{ "seventh", tUNUMBER, 7 },
|
{ "eighth", tUNUMBER, 8 },
|
{ "eighth", tUNUMBER, 8 },
|
{ "ninth", tUNUMBER, 9 },
|
{ "ninth", tUNUMBER, 9 },
|
{ "tenth", tUNUMBER, 10 },
|
{ "tenth", tUNUMBER, 10 },
|
{ "eleventh", tUNUMBER, 11 },
|
{ "eleventh", tUNUMBER, 11 },
|
{ "twelfth", tUNUMBER, 12 },
|
{ "twelfth", tUNUMBER, 12 },
|
#endif
|
#endif
|
{ "ago", tAGO, 1 },
|
{ "ago", tAGO, 1 },
|
{ "epoch", tEPOCH, 0 },
|
{ "epoch", tEPOCH, 0 },
|
{ NULL }
|
{ NULL }
|
};
|
};
|
|
|
/*
|
/*
|
* The timezone table. (Note: This table was modified to not use any floating
|
* The timezone table. (Note: This table was modified to not use any floating
|
* point constants to work around an SGI compiler bug).
|
* point constants to work around an SGI compiler bug).
|
*/
|
*/
|
static TABLE TimezoneTable[] = {
|
static TABLE TimezoneTable[] = {
|
{ "gmt", tZONE, HOUR( 0) }, /* Greenwich Mean */
|
{ "gmt", tZONE, HOUR( 0) }, /* Greenwich Mean */
|
{ "ut", tZONE, HOUR( 0) }, /* Universal (Coordinated) */
|
{ "ut", tZONE, HOUR( 0) }, /* Universal (Coordinated) */
|
{ "utc", tZONE, HOUR( 0) },
|
{ "utc", tZONE, HOUR( 0) },
|
{ "wet", tZONE, HOUR( 0) } , /* Western European */
|
{ "wet", tZONE, HOUR( 0) } , /* Western European */
|
{ "bst", tDAYZONE, HOUR( 0) }, /* British Summer */
|
{ "bst", tDAYZONE, HOUR( 0) }, /* British Summer */
|
{ "wat", tZONE, HOUR( 1) }, /* West Africa */
|
{ "wat", tZONE, HOUR( 1) }, /* West Africa */
|
{ "at", tZONE, HOUR( 2) }, /* Azores */
|
{ "at", tZONE, HOUR( 2) }, /* Azores */
|
#if 0
|
#if 0
|
/* For completeness. BST is also British Summer, and GST is
|
/* For completeness. BST is also British Summer, and GST is
|
* also Guam Standard. */
|
* also Guam Standard. */
|
{ "bst", tZONE, HOUR( 3) }, /* Brazil Standard */
|
{ "bst", tZONE, HOUR( 3) }, /* Brazil Standard */
|
{ "gst", tZONE, HOUR( 3) }, /* Greenland Standard */
|
{ "gst", tZONE, HOUR( 3) }, /* Greenland Standard */
|
#endif
|
#endif
|
{ "nft", tZONE, HOUR( 7/2) }, /* Newfoundland */
|
{ "nft", tZONE, HOUR( 7/2) }, /* Newfoundland */
|
{ "nst", tZONE, HOUR( 7/2) }, /* Newfoundland Standard */
|
{ "nst", tZONE, HOUR( 7/2) }, /* Newfoundland Standard */
|
{ "ndt", tDAYZONE, HOUR( 7/2) }, /* Newfoundland Daylight */
|
{ "ndt", tDAYZONE, HOUR( 7/2) }, /* Newfoundland Daylight */
|
{ "ast", tZONE, HOUR( 4) }, /* Atlantic Standard */
|
{ "ast", tZONE, HOUR( 4) }, /* Atlantic Standard */
|
{ "adt", tDAYZONE, HOUR( 4) }, /* Atlantic Daylight */
|
{ "adt", tDAYZONE, HOUR( 4) }, /* Atlantic Daylight */
|
{ "est", tZONE, HOUR( 5) }, /* Eastern Standard */
|
{ "est", tZONE, HOUR( 5) }, /* Eastern Standard */
|
{ "edt", tDAYZONE, HOUR( 5) }, /* Eastern Daylight */
|
{ "edt", tDAYZONE, HOUR( 5) }, /* Eastern Daylight */
|
{ "cst", tZONE, HOUR( 6) }, /* Central Standard */
|
{ "cst", tZONE, HOUR( 6) }, /* Central Standard */
|
{ "cdt", tDAYZONE, HOUR( 6) }, /* Central Daylight */
|
{ "cdt", tDAYZONE, HOUR( 6) }, /* Central Daylight */
|
{ "mst", tZONE, HOUR( 7) }, /* Mountain Standard */
|
{ "mst", tZONE, HOUR( 7) }, /* Mountain Standard */
|
{ "mdt", tDAYZONE, HOUR( 7) }, /* Mountain Daylight */
|
{ "mdt", tDAYZONE, HOUR( 7) }, /* Mountain Daylight */
|
{ "pst", tZONE, HOUR( 8) }, /* Pacific Standard */
|
{ "pst", tZONE, HOUR( 8) }, /* Pacific Standard */
|
{ "pdt", tDAYZONE, HOUR( 8) }, /* Pacific Daylight */
|
{ "pdt", tDAYZONE, HOUR( 8) }, /* Pacific Daylight */
|
{ "yst", tZONE, HOUR( 9) }, /* Yukon Standard */
|
{ "yst", tZONE, HOUR( 9) }, /* Yukon Standard */
|
{ "ydt", tDAYZONE, HOUR( 9) }, /* Yukon Daylight */
|
{ "ydt", tDAYZONE, HOUR( 9) }, /* Yukon Daylight */
|
{ "hst", tZONE, HOUR(10) }, /* Hawaii Standard */
|
{ "hst", tZONE, HOUR(10) }, /* Hawaii Standard */
|
{ "hdt", tDAYZONE, HOUR(10) }, /* Hawaii Daylight */
|
{ "hdt", tDAYZONE, HOUR(10) }, /* Hawaii Daylight */
|
{ "cat", tZONE, HOUR(10) }, /* Central Alaska */
|
{ "cat", tZONE, HOUR(10) }, /* Central Alaska */
|
{ "ahst", tZONE, HOUR(10) }, /* Alaska-Hawaii Standard */
|
{ "ahst", tZONE, HOUR(10) }, /* Alaska-Hawaii Standard */
|
{ "nt", tZONE, HOUR(11) }, /* Nome */
|
{ "nt", tZONE, HOUR(11) }, /* Nome */
|
{ "idlw", tZONE, HOUR(12) }, /* International Date Line West */
|
{ "idlw", tZONE, HOUR(12) }, /* International Date Line West */
|
{ "cet", tZONE, -HOUR( 1) }, /* Central European */
|
{ "cet", tZONE, -HOUR( 1) }, /* Central European */
|
{ "met", tZONE, -HOUR( 1) }, /* Middle European */
|
{ "met", tZONE, -HOUR( 1) }, /* Middle European */
|
{ "mewt", tZONE, -HOUR( 1) }, /* Middle European Winter */
|
{ "mewt", tZONE, -HOUR( 1) }, /* Middle European Winter */
|
{ "mest", tDAYZONE, -HOUR( 1) }, /* Middle European Summer */
|
{ "mest", tDAYZONE, -HOUR( 1) }, /* Middle European Summer */
|
{ "swt", tZONE, -HOUR( 1) }, /* Swedish Winter */
|
{ "swt", tZONE, -HOUR( 1) }, /* Swedish Winter */
|
{ "sst", tDAYZONE, -HOUR( 1) }, /* Swedish Summer */
|
{ "sst", tDAYZONE, -HOUR( 1) }, /* Swedish Summer */
|
{ "fwt", tZONE, -HOUR( 1) }, /* French Winter */
|
{ "fwt", tZONE, -HOUR( 1) }, /* French Winter */
|
{ "fst", tDAYZONE, -HOUR( 1) }, /* French Summer */
|
{ "fst", tDAYZONE, -HOUR( 1) }, /* French Summer */
|
{ "eet", tZONE, -HOUR( 2) }, /* Eastern Europe, USSR Zone 1 */
|
{ "eet", tZONE, -HOUR( 2) }, /* Eastern Europe, USSR Zone 1 */
|
{ "bt", tZONE, -HOUR( 3) }, /* Baghdad, USSR Zone 2 */
|
{ "bt", tZONE, -HOUR( 3) }, /* Baghdad, USSR Zone 2 */
|
{ "it", tZONE, -HOUR( 7/2) }, /* Iran */
|
{ "it", tZONE, -HOUR( 7/2) }, /* Iran */
|
{ "zp4", tZONE, -HOUR( 4) }, /* USSR Zone 3 */
|
{ "zp4", tZONE, -HOUR( 4) }, /* USSR Zone 3 */
|
{ "zp5", tZONE, -HOUR( 5) }, /* USSR Zone 4 */
|
{ "zp5", tZONE, -HOUR( 5) }, /* USSR Zone 4 */
|
{ "ist", tZONE, -HOUR(11/2) }, /* Indian Standard */
|
{ "ist", tZONE, -HOUR(11/2) }, /* Indian Standard */
|
{ "zp6", tZONE, -HOUR( 6) }, /* USSR Zone 5 */
|
{ "zp6", tZONE, -HOUR( 6) }, /* USSR Zone 5 */
|
#if 0
|
#if 0
|
/* For completeness. NST is also Newfoundland Stanard, nad SST is
|
/* For completeness. NST is also Newfoundland Stanard, nad SST is
|
* also Swedish Summer. */
|
* also Swedish Summer. */
|
{ "nst", tZONE, -HOUR(13/2) }, /* North Sumatra */
|
{ "nst", tZONE, -HOUR(13/2) }, /* North Sumatra */
|
{ "sst", tZONE, -HOUR( 7) }, /* South Sumatra, USSR Zone 6 */
|
{ "sst", tZONE, -HOUR( 7) }, /* South Sumatra, USSR Zone 6 */
|
#endif /* 0 */
|
#endif /* 0 */
|
{ "wast", tZONE, -HOUR( 7) }, /* West Australian Standard */
|
{ "wast", tZONE, -HOUR( 7) }, /* West Australian Standard */
|
{ "wadt", tDAYZONE, -HOUR( 7) }, /* West Australian Daylight */
|
{ "wadt", tDAYZONE, -HOUR( 7) }, /* West Australian Daylight */
|
{ "jt", tZONE, -HOUR(15/2) }, /* Java (3pm in Cronusland!) */
|
{ "jt", tZONE, -HOUR(15/2) }, /* Java (3pm in Cronusland!) */
|
{ "cct", tZONE, -HOUR( 8) }, /* China Coast, USSR Zone 7 */
|
{ "cct", tZONE, -HOUR( 8) }, /* China Coast, USSR Zone 7 */
|
{ "jst", tZONE, -HOUR( 9) }, /* Japan Standard, USSR Zone 8 */
|
{ "jst", tZONE, -HOUR( 9) }, /* Japan Standard, USSR Zone 8 */
|
{ "cast", tZONE, -HOUR(19/2) }, /* Central Australian Standard */
|
{ "cast", tZONE, -HOUR(19/2) }, /* Central Australian Standard */
|
{ "cadt", tDAYZONE, -HOUR(19/2) }, /* Central Australian Daylight */
|
{ "cadt", tDAYZONE, -HOUR(19/2) }, /* Central Australian Daylight */
|
{ "east", tZONE, -HOUR(10) }, /* Eastern Australian Standard */
|
{ "east", tZONE, -HOUR(10) }, /* Eastern Australian Standard */
|
{ "eadt", tDAYZONE, -HOUR(10) }, /* Eastern Australian Daylight */
|
{ "eadt", tDAYZONE, -HOUR(10) }, /* Eastern Australian Daylight */
|
{ "gst", tZONE, -HOUR(10) }, /* Guam Standard, USSR Zone 9 */
|
{ "gst", tZONE, -HOUR(10) }, /* Guam Standard, USSR Zone 9 */
|
{ "nzt", tZONE, -HOUR(12) }, /* New Zealand */
|
{ "nzt", tZONE, -HOUR(12) }, /* New Zealand */
|
{ "nzst", tZONE, -HOUR(12) }, /* New Zealand Standard */
|
{ "nzst", tZONE, -HOUR(12) }, /* New Zealand Standard */
|
{ "nzdt", tDAYZONE, -HOUR(12) }, /* New Zealand Daylight */
|
{ "nzdt", tDAYZONE, -HOUR(12) }, /* New Zealand Daylight */
|
{ "idle", tZONE, -HOUR(12) }, /* International Date Line East */
|
{ "idle", tZONE, -HOUR(12) }, /* International Date Line East */
|
/* ADDED BY Marco Nijdam */
|
/* ADDED BY Marco Nijdam */
|
{ "dst", tDST, HOUR( 0) }, /* DST on (hour is ignored) */
|
{ "dst", tDST, HOUR( 0) }, /* DST on (hour is ignored) */
|
/* End ADDED */
|
/* End ADDED */
|
{ NULL }
|
{ NULL }
|
};
|
};
|
|
|
/*
|
/*
|
* Military timezone table.
|
* Military timezone table.
|
*/
|
*/
|
static TABLE MilitaryTable[] = {
|
static TABLE MilitaryTable[] = {
|
{ "a", tZONE, HOUR( 1) },
|
{ "a", tZONE, HOUR( 1) },
|
{ "b", tZONE, HOUR( 2) },
|
{ "b", tZONE, HOUR( 2) },
|
{ "c", tZONE, HOUR( 3) },
|
{ "c", tZONE, HOUR( 3) },
|
{ "d", tZONE, HOUR( 4) },
|
{ "d", tZONE, HOUR( 4) },
|
{ "e", tZONE, HOUR( 5) },
|
{ "e", tZONE, HOUR( 5) },
|
{ "f", tZONE, HOUR( 6) },
|
{ "f", tZONE, HOUR( 6) },
|
{ "g", tZONE, HOUR( 7) },
|
{ "g", tZONE, HOUR( 7) },
|
{ "h", tZONE, HOUR( 8) },
|
{ "h", tZONE, HOUR( 8) },
|
{ "i", tZONE, HOUR( 9) },
|
{ "i", tZONE, HOUR( 9) },
|
{ "k", tZONE, HOUR( 10) },
|
{ "k", tZONE, HOUR( 10) },
|
{ "l", tZONE, HOUR( 11) },
|
{ "l", tZONE, HOUR( 11) },
|
{ "m", tZONE, HOUR( 12) },
|
{ "m", tZONE, HOUR( 12) },
|
{ "n", tZONE, HOUR(- 1) },
|
{ "n", tZONE, HOUR(- 1) },
|
{ "o", tZONE, HOUR(- 2) },
|
{ "o", tZONE, HOUR(- 2) },
|
{ "p", tZONE, HOUR(- 3) },
|
{ "p", tZONE, HOUR(- 3) },
|
{ "q", tZONE, HOUR(- 4) },
|
{ "q", tZONE, HOUR(- 4) },
|
{ "r", tZONE, HOUR(- 5) },
|
{ "r", tZONE, HOUR(- 5) },
|
{ "s", tZONE, HOUR(- 6) },
|
{ "s", tZONE, HOUR(- 6) },
|
{ "t", tZONE, HOUR(- 7) },
|
{ "t", tZONE, HOUR(- 7) },
|
{ "u", tZONE, HOUR(- 8) },
|
{ "u", tZONE, HOUR(- 8) },
|
{ "v", tZONE, HOUR(- 9) },
|
{ "v", tZONE, HOUR(- 9) },
|
{ "w", tZONE, HOUR(-10) },
|
{ "w", tZONE, HOUR(-10) },
|
{ "x", tZONE, HOUR(-11) },
|
{ "x", tZONE, HOUR(-11) },
|
{ "y", tZONE, HOUR(-12) },
|
{ "y", tZONE, HOUR(-12) },
|
{ "z", tZONE, HOUR( 0) },
|
{ "z", tZONE, HOUR( 0) },
|
{ NULL }
|
{ NULL }
|
};
|
};
|
|
|
|
|
/*
|
/*
|
* Dump error messages in the bit bucket.
|
* Dump error messages in the bit bucket.
|
*/
|
*/
|
static void
|
static void
|
TclDateerror(s)
|
TclDateerror(s)
|
char *s;
|
char *s;
|
{
|
{
|
}
|
}
|
|
|
|
|
static time_t
|
static time_t
|
ToSeconds(Hours, Minutes, Seconds, Meridian)
|
ToSeconds(Hours, Minutes, Seconds, Meridian)
|
time_t Hours;
|
time_t Hours;
|
time_t Minutes;
|
time_t Minutes;
|
time_t Seconds;
|
time_t Seconds;
|
MERIDIAN Meridian;
|
MERIDIAN Meridian;
|
{
|
{
|
if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 59)
|
if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 59)
|
return -1;
|
return -1;
|
switch (Meridian) {
|
switch (Meridian) {
|
case MER24:
|
case MER24:
|
if (Hours < 0 || Hours > 23)
|
if (Hours < 0 || Hours > 23)
|
return -1;
|
return -1;
|
return (Hours * 60L + Minutes) * 60L + Seconds;
|
return (Hours * 60L + Minutes) * 60L + Seconds;
|
case MERam:
|
case MERam:
|
if (Hours < 1 || Hours > 12)
|
if (Hours < 1 || Hours > 12)
|
return -1;
|
return -1;
|
return ((Hours % 12) * 60L + Minutes) * 60L + Seconds;
|
return ((Hours % 12) * 60L + Minutes) * 60L + Seconds;
|
case MERpm:
|
case MERpm:
|
if (Hours < 1 || Hours > 12)
|
if (Hours < 1 || Hours > 12)
|
return -1;
|
return -1;
|
return (((Hours % 12) + 12) * 60L + Minutes) * 60L + Seconds;
|
return (((Hours % 12) + 12) * 60L + Minutes) * 60L + Seconds;
|
}
|
}
|
return -1; /* Should never be reached */
|
return -1; /* Should never be reached */
|
}
|
}
|
|
|
|
|
static int
|
static int
|
Convert(Month, Day, Year, Hours, Minutes, Seconds, Meridian, DSTmode, TimePtr)
|
Convert(Month, Day, Year, Hours, Minutes, Seconds, Meridian, DSTmode, TimePtr)
|
time_t Month;
|
time_t Month;
|
time_t Day;
|
time_t Day;
|
time_t Year;
|
time_t Year;
|
time_t Hours;
|
time_t Hours;
|
time_t Minutes;
|
time_t Minutes;
|
time_t Seconds;
|
time_t Seconds;
|
MERIDIAN Meridian;
|
MERIDIAN Meridian;
|
DSTMODE DSTmode;
|
DSTMODE DSTmode;
|
time_t *TimePtr;
|
time_t *TimePtr;
|
{
|
{
|
static int DaysInMonth[12] = {
|
static int DaysInMonth[12] = {
|
31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
|
31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
|
};
|
};
|
time_t tod;
|
time_t tod;
|
time_t Julian;
|
time_t Julian;
|
int i;
|
int i;
|
|
|
DaysInMonth[1] = Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0)
|
DaysInMonth[1] = Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0)
|
? 29 : 28;
|
? 29 : 28;
|
if (Month < 1 || Month > 12
|
if (Month < 1 || Month > 12
|
|| Year < START_OF_TIME || Year > END_OF_TIME
|
|| Year < START_OF_TIME || Year > END_OF_TIME
|
|| Day < 1 || Day > DaysInMonth[(int)--Month])
|
|| Day < 1 || Day > DaysInMonth[(int)--Month])
|
return -1;
|
return -1;
|
|
|
for (Julian = Day - 1, i = 0; i < Month; i++)
|
for (Julian = Day - 1, i = 0; i < Month; i++)
|
Julian += DaysInMonth[i];
|
Julian += DaysInMonth[i];
|
if (Year >= EPOCH) {
|
if (Year >= EPOCH) {
|
for (i = EPOCH; i < Year; i++)
|
for (i = EPOCH; i < Year; i++)
|
Julian += 365 + (i % 4 == 0);
|
Julian += 365 + (i % 4 == 0);
|
} else {
|
} else {
|
for (i = Year; i < EPOCH; i++)
|
for (i = Year; i < EPOCH; i++)
|
Julian -= 365 + (i % 4 == 0);
|
Julian -= 365 + (i % 4 == 0);
|
}
|
}
|
Julian *= SECSPERDAY;
|
Julian *= SECSPERDAY;
|
Julian += TclDateTimezone * 60L;
|
Julian += TclDateTimezone * 60L;
|
if ((tod = ToSeconds(Hours, Minutes, Seconds, Meridian)) < 0)
|
if ((tod = ToSeconds(Hours, Minutes, Seconds, Meridian)) < 0)
|
return -1;
|
return -1;
|
Julian += tod;
|
Julian += tod;
|
if (DSTmode == DSTon
|
if (DSTmode == DSTon
|
|| (DSTmode == DSTmaybe && TclpGetDate(&Julian, 0)->tm_isdst))
|
|| (DSTmode == DSTmaybe && TclpGetDate(&Julian, 0)->tm_isdst))
|
Julian -= 60 * 60;
|
Julian -= 60 * 60;
|
*TimePtr = Julian;
|
*TimePtr = Julian;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
static time_t
|
static time_t
|
DSTcorrect(Start, Future)
|
DSTcorrect(Start, Future)
|
time_t Start;
|
time_t Start;
|
time_t Future;
|
time_t Future;
|
{
|
{
|
time_t StartDay;
|
time_t StartDay;
|
time_t FutureDay;
|
time_t FutureDay;
|
|
|
StartDay = (TclpGetDate(&Start, 0)->tm_hour + 1) % 24;
|
StartDay = (TclpGetDate(&Start, 0)->tm_hour + 1) % 24;
|
FutureDay = (TclpGetDate(&Future, 0)->tm_hour + 1) % 24;
|
FutureDay = (TclpGetDate(&Future, 0)->tm_hour + 1) % 24;
|
return (Future - Start) + (StartDay - FutureDay) * 60L * 60L;
|
return (Future - Start) + (StartDay - FutureDay) * 60L * 60L;
|
}
|
}
|
|
|
|
|
static time_t
|
static time_t
|
RelativeDate(Start, DayOrdinal, DayNumber)
|
RelativeDate(Start, DayOrdinal, DayNumber)
|
time_t Start;
|
time_t Start;
|
time_t DayOrdinal;
|
time_t DayOrdinal;
|
time_t DayNumber;
|
time_t DayNumber;
|
{
|
{
|
struct tm *tm;
|
struct tm *tm;
|
time_t now;
|
time_t now;
|
|
|
now = Start;
|
now = Start;
|
tm = TclpGetDate(&now, 0);
|
tm = TclpGetDate(&now, 0);
|
now += SECSPERDAY * ((DayNumber - tm->tm_wday + 7) % 7);
|
now += SECSPERDAY * ((DayNumber - tm->tm_wday + 7) % 7);
|
now += 7 * SECSPERDAY * (DayOrdinal <= 0 ? DayOrdinal : DayOrdinal - 1);
|
now += 7 * SECSPERDAY * (DayOrdinal <= 0 ? DayOrdinal : DayOrdinal - 1);
|
return DSTcorrect(Start, now);
|
return DSTcorrect(Start, now);
|
}
|
}
|
|
|
|
|
static int
|
static int
|
RelativeMonth(Start, RelMonth, TimePtr)
|
RelativeMonth(Start, RelMonth, TimePtr)
|
time_t Start;
|
time_t Start;
|
time_t RelMonth;
|
time_t RelMonth;
|
time_t *TimePtr;
|
time_t *TimePtr;
|
{
|
{
|
struct tm *tm;
|
struct tm *tm;
|
time_t Month;
|
time_t Month;
|
time_t Year;
|
time_t Year;
|
time_t Julian;
|
time_t Julian;
|
int result;
|
int result;
|
|
|
if (RelMonth == 0) {
|
if (RelMonth == 0) {
|
*TimePtr = 0;
|
*TimePtr = 0;
|
return 0;
|
return 0;
|
}
|
}
|
tm = TclpGetDate(&Start, 0);
|
tm = TclpGetDate(&Start, 0);
|
Month = 12 * (tm->tm_year + TM_YEAR_BASE) + tm->tm_mon + RelMonth;
|
Month = 12 * (tm->tm_year + TM_YEAR_BASE) + tm->tm_mon + RelMonth;
|
Year = Month / 12;
|
Year = Month / 12;
|
Month = Month % 12 + 1;
|
Month = Month % 12 + 1;
|
result = Convert(Month, (time_t) tm->tm_mday, Year,
|
result = Convert(Month, (time_t) tm->tm_mday, Year,
|
(time_t) tm->tm_hour, (time_t) tm->tm_min, (time_t) tm->tm_sec,
|
(time_t) tm->tm_hour, (time_t) tm->tm_min, (time_t) tm->tm_sec,
|
MER24, DSTmaybe, &Julian);
|
MER24, DSTmaybe, &Julian);
|
/*
|
/*
|
* The following iteration takes into account the case were we jump
|
* The following iteration takes into account the case were we jump
|
* into a "short month". Far example, "one month from Jan 31" will
|
* 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
|
* 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
|
* 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).
|
* 28 (which always works unless the date is bad in another way).
|
*/
|
*/
|
|
|
while ((result != 0) && (tm->tm_mday > 28)) {
|
while ((result != 0) && (tm->tm_mday > 28)) {
|
tm->tm_mday--;
|
tm->tm_mday--;
|
result = Convert(Month, (time_t) tm->tm_mday, Year,
|
result = Convert(Month, (time_t) tm->tm_mday, Year,
|
(time_t) tm->tm_hour, (time_t) tm->tm_min, (time_t) tm->tm_sec,
|
(time_t) tm->tm_hour, (time_t) tm->tm_min, (time_t) tm->tm_sec,
|
MER24, DSTmaybe, &Julian);
|
MER24, DSTmaybe, &Julian);
|
}
|
}
|
if (result != 0) {
|
if (result != 0) {
|
return -1;
|
return -1;
|
}
|
}
|
*TimePtr = DSTcorrect(Start, Julian);
|
*TimePtr = DSTcorrect(Start, Julian);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
static int
|
static int
|
LookupWord(buff)
|
LookupWord(buff)
|
char *buff;
|
char *buff;
|
{
|
{
|
register char *p;
|
register char *p;
|
register char *q;
|
register char *q;
|
register TABLE *tp;
|
register TABLE *tp;
|
int i;
|
int i;
|
int abbrev;
|
int abbrev;
|
|
|
/*
|
/*
|
* Make it lowercase.
|
* Make it lowercase.
|
*/
|
*/
|
for (p = buff; *p; p++) {
|
for (p = buff; *p; p++) {
|
if (isupper(UCHAR(*p))) {
|
if (isupper(UCHAR(*p))) {
|
*p = (char) tolower(UCHAR(*p));
|
*p = (char) tolower(UCHAR(*p));
|
}
|
}
|
}
|
}
|
|
|
if (strcmp(buff, "am") == 0 || strcmp(buff, "a.m.") == 0) {
|
if (strcmp(buff, "am") == 0 || strcmp(buff, "a.m.") == 0) {
|
TclDatelval.Meridian = MERam;
|
TclDatelval.Meridian = MERam;
|
return tMERIDIAN;
|
return tMERIDIAN;
|
}
|
}
|
if (strcmp(buff, "pm") == 0 || strcmp(buff, "p.m.") == 0) {
|
if (strcmp(buff, "pm") == 0 || strcmp(buff, "p.m.") == 0) {
|
TclDatelval.Meridian = MERpm;
|
TclDatelval.Meridian = MERpm;
|
return tMERIDIAN;
|
return tMERIDIAN;
|
}
|
}
|
|
|
/*
|
/*
|
* See if we have an abbreviation for a month.
|
* See if we have an abbreviation for a month.
|
*/
|
*/
|
if (strlen(buff) == 3) {
|
if (strlen(buff) == 3) {
|
abbrev = 1;
|
abbrev = 1;
|
} else if (strlen(buff) == 4 && buff[3] == '.') {
|
} else if (strlen(buff) == 4 && buff[3] == '.') {
|
abbrev = 1;
|
abbrev = 1;
|
buff[3] = '\0';
|
buff[3] = '\0';
|
} else {
|
} else {
|
abbrev = 0;
|
abbrev = 0;
|
}
|
}
|
|
|
for (tp = MonthDayTable; tp->name; tp++) {
|
for (tp = MonthDayTable; tp->name; tp++) {
|
if (abbrev) {
|
if (abbrev) {
|
if (strncmp(buff, tp->name, 3) == 0) {
|
if (strncmp(buff, tp->name, 3) == 0) {
|
TclDatelval.Number = tp->value;
|
TclDatelval.Number = tp->value;
|
return tp->type;
|
return tp->type;
|
}
|
}
|
} else if (strcmp(buff, tp->name) == 0) {
|
} else if (strcmp(buff, tp->name) == 0) {
|
TclDatelval.Number = tp->value;
|
TclDatelval.Number = tp->value;
|
return tp->type;
|
return tp->type;
|
}
|
}
|
}
|
}
|
|
|
for (tp = TimezoneTable; tp->name; tp++) {
|
for (tp = TimezoneTable; tp->name; tp++) {
|
if (strcmp(buff, tp->name) == 0) {
|
if (strcmp(buff, tp->name) == 0) {
|
TclDatelval.Number = tp->value;
|
TclDatelval.Number = tp->value;
|
return tp->type;
|
return tp->type;
|
}
|
}
|
}
|
}
|
|
|
for (tp = UnitsTable; tp->name; tp++) {
|
for (tp = UnitsTable; tp->name; tp++) {
|
if (strcmp(buff, tp->name) == 0) {
|
if (strcmp(buff, tp->name) == 0) {
|
TclDatelval.Number = tp->value;
|
TclDatelval.Number = tp->value;
|
return tp->type;
|
return tp->type;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Strip off any plural and try the units table again.
|
* Strip off any plural and try the units table again.
|
*/
|
*/
|
i = strlen(buff) - 1;
|
i = strlen(buff) - 1;
|
if (buff[i] == 's') {
|
if (buff[i] == 's') {
|
buff[i] = '\0';
|
buff[i] = '\0';
|
for (tp = UnitsTable; tp->name; tp++) {
|
for (tp = UnitsTable; tp->name; tp++) {
|
if (strcmp(buff, tp->name) == 0) {
|
if (strcmp(buff, tp->name) == 0) {
|
TclDatelval.Number = tp->value;
|
TclDatelval.Number = tp->value;
|
return tp->type;
|
return tp->type;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
for (tp = OtherTable; tp->name; tp++) {
|
for (tp = OtherTable; tp->name; tp++) {
|
if (strcmp(buff, tp->name) == 0) {
|
if (strcmp(buff, tp->name) == 0) {
|
TclDatelval.Number = tp->value;
|
TclDatelval.Number = tp->value;
|
return tp->type;
|
return tp->type;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Military timezones.
|
* Military timezones.
|
*/
|
*/
|
if (buff[1] == '\0' && isalpha(UCHAR(*buff))) {
|
if (buff[1] == '\0' && isalpha(UCHAR(*buff))) {
|
for (tp = MilitaryTable; tp->name; tp++) {
|
for (tp = MilitaryTable; tp->name; tp++) {
|
if (strcmp(buff, tp->name) == 0) {
|
if (strcmp(buff, tp->name) == 0) {
|
TclDatelval.Number = tp->value;
|
TclDatelval.Number = tp->value;
|
return tp->type;
|
return tp->type;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Drop out any periods and try the timezone table again.
|
* Drop out any periods and try the timezone table again.
|
*/
|
*/
|
for (i = 0, p = q = buff; *q; q++)
|
for (i = 0, p = q = buff; *q; q++)
|
if (*q != '.') {
|
if (*q != '.') {
|
*p++ = *q;
|
*p++ = *q;
|
} else {
|
} else {
|
i++;
|
i++;
|
}
|
}
|
*p = '\0';
|
*p = '\0';
|
if (i) {
|
if (i) {
|
for (tp = TimezoneTable; tp->name; tp++) {
|
for (tp = TimezoneTable; tp->name; tp++) {
|
if (strcmp(buff, tp->name) == 0) {
|
if (strcmp(buff, tp->name) == 0) {
|
TclDatelval.Number = tp->value;
|
TclDatelval.Number = tp->value;
|
return tp->type;
|
return tp->type;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
return tID;
|
return tID;
|
}
|
}
|
|
|
|
|
static int
|
static int
|
TclDatelex()
|
TclDatelex()
|
{
|
{
|
register char c;
|
register char c;
|
register char *p;
|
register char *p;
|
char buff[20];
|
char buff[20];
|
int Count;
|
int Count;
|
int sign;
|
int sign;
|
|
|
for ( ; ; ) {
|
for ( ; ; ) {
|
while (isspace((unsigned char) (*TclDateInput))) {
|
while (isspace((unsigned char) (*TclDateInput))) {
|
TclDateInput++;
|
TclDateInput++;
|
}
|
}
|
|
|
if (isdigit(c = *TclDateInput) || c == '-' || c == '+') {
|
if (isdigit(c = *TclDateInput) || c == '-' || c == '+') {
|
if (c == '-' || c == '+') {
|
if (c == '-' || c == '+') {
|
sign = c == '-' ? -1 : 1;
|
sign = c == '-' ? -1 : 1;
|
if (!isdigit(*++TclDateInput)) {
|
if (!isdigit(*++TclDateInput)) {
|
/*
|
/*
|
* skip the '-' sign
|
* skip the '-' sign
|
*/
|
*/
|
continue;
|
continue;
|
}
|
}
|
} else {
|
} else {
|
sign = 0;
|
sign = 0;
|
}
|
}
|
for (TclDatelval.Number = 0; isdigit(c = *TclDateInput++); ) {
|
for (TclDatelval.Number = 0; isdigit(c = *TclDateInput++); ) {
|
TclDatelval.Number = 10 * TclDatelval.Number + c - '0';
|
TclDatelval.Number = 10 * TclDatelval.Number + c - '0';
|
}
|
}
|
TclDateInput--;
|
TclDateInput--;
|
if (sign < 0) {
|
if (sign < 0) {
|
TclDatelval.Number = -TclDatelval.Number;
|
TclDatelval.Number = -TclDatelval.Number;
|
}
|
}
|
return sign ? tSNUMBER : tUNUMBER;
|
return sign ? tSNUMBER : tUNUMBER;
|
}
|
}
|
if (isalpha(UCHAR(c))) {
|
if (isalpha(UCHAR(c))) {
|
for (p = buff; isalpha(c = *TclDateInput++) || c == '.'; ) {
|
for (p = buff; isalpha(c = *TclDateInput++) || c == '.'; ) {
|
if (p < &buff[sizeof buff - 1]) {
|
if (p < &buff[sizeof buff - 1]) {
|
*p++ = c;
|
*p++ = c;
|
}
|
}
|
}
|
}
|
*p = '\0';
|
*p = '\0';
|
TclDateInput--;
|
TclDateInput--;
|
return LookupWord(buff);
|
return LookupWord(buff);
|
}
|
}
|
if (c != '(') {
|
if (c != '(') {
|
return *TclDateInput++;
|
return *TclDateInput++;
|
}
|
}
|
Count = 0;
|
Count = 0;
|
do {
|
do {
|
c = *TclDateInput++;
|
c = *TclDateInput++;
|
if (c == '\0') {
|
if (c == '\0') {
|
return c;
|
return c;
|
} else if (c == '(') {
|
} else if (c == '(') {
|
Count++;
|
Count++;
|
} else if (c == ')') {
|
} else if (c == ')') {
|
Count--;
|
Count--;
|
}
|
}
|
} while (Count > 0);
|
} while (Count > 0);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Specify zone is of -50000 to force GMT. (This allows BST to work).
|
* Specify zone is of -50000 to force GMT. (This allows BST to work).
|
*/
|
*/
|
|
|
int
|
int
|
TclGetDate(p, now, zone, timePtr)
|
TclGetDate(p, now, zone, timePtr)
|
char *p;
|
char *p;
|
unsigned long now;
|
unsigned long now;
|
long zone;
|
long zone;
|
unsigned long *timePtr;
|
unsigned long *timePtr;
|
{
|
{
|
struct tm *tm;
|
struct tm *tm;
|
time_t Start;
|
time_t Start;
|
time_t Time;
|
time_t Time;
|
time_t tod;
|
time_t tod;
|
int thisyear;
|
int thisyear;
|
|
|
TclDateInput = p;
|
TclDateInput = p;
|
tm = TclpGetDate((time_t *) &now, 0);
|
tm = TclpGetDate((time_t *) &now, 0);
|
thisyear = tm->tm_year + TM_YEAR_BASE;
|
thisyear = tm->tm_year + TM_YEAR_BASE;
|
TclDateYear = thisyear;
|
TclDateYear = thisyear;
|
TclDateMonth = tm->tm_mon + 1;
|
TclDateMonth = tm->tm_mon + 1;
|
TclDateDay = tm->tm_mday;
|
TclDateDay = tm->tm_mday;
|
TclDateTimezone = zone;
|
TclDateTimezone = zone;
|
if (zone == -50000) {
|
if (zone == -50000) {
|
TclDateDSTmode = DSToff; /* assume GMT */
|
TclDateDSTmode = DSToff; /* assume GMT */
|
TclDateTimezone = 0;
|
TclDateTimezone = 0;
|
} else {
|
} else {
|
TclDateDSTmode = DSTmaybe;
|
TclDateDSTmode = DSTmaybe;
|
}
|
}
|
TclDateHour = 0;
|
TclDateHour = 0;
|
TclDateMinutes = 0;
|
TclDateMinutes = 0;
|
TclDateSeconds = 0;
|
TclDateSeconds = 0;
|
TclDateMeridian = MER24;
|
TclDateMeridian = MER24;
|
TclDateRelSeconds = 0;
|
TclDateRelSeconds = 0;
|
TclDateRelMonth = 0;
|
TclDateRelMonth = 0;
|
TclDateHaveDate = 0;
|
TclDateHaveDate = 0;
|
TclDateHaveDay = 0;
|
TclDateHaveDay = 0;
|
TclDateHaveRel = 0;
|
TclDateHaveRel = 0;
|
TclDateHaveTime = 0;
|
TclDateHaveTime = 0;
|
TclDateHaveZone = 0;
|
TclDateHaveZone = 0;
|
|
|
if (TclDateparse() || TclDateHaveTime > 1 || TclDateHaveZone > 1 || TclDateHaveDate > 1 ||
|
if (TclDateparse() || TclDateHaveTime > 1 || TclDateHaveZone > 1 || TclDateHaveDate > 1 ||
|
TclDateHaveDay > 1) {
|
TclDateHaveDay > 1) {
|
return -1;
|
return -1;
|
}
|
}
|
|
|
if (TclDateHaveDate || TclDateHaveTime || TclDateHaveDay) {
|
if (TclDateHaveDate || TclDateHaveTime || TclDateHaveDay) {
|
if (TclDateYear < 0) {
|
if (TclDateYear < 0) {
|
TclDateYear = -TclDateYear;
|
TclDateYear = -TclDateYear;
|
}
|
}
|
/*
|
/*
|
* The following line handles years that are specified using
|
* The following line handles years that are specified using
|
* only two digits. The line of code below implements a policy
|
* only two digits. The line of code below implements a policy
|
* defined by the X/Open workgroup on the millinium rollover.
|
* defined by the X/Open workgroup on the millinium rollover.
|
* Note: some of those dates may not actually be valid on some
|
* Note: some of those dates may not actually be valid on some
|
* platforms. The POSIX standard startes that the dates 70-99
|
* platforms. The POSIX standard startes that the dates 70-99
|
* shall refer to 1970-1999 and 00-38 shall refer to 2000-2038.
|
* shall refer to 1970-1999 and 00-38 shall refer to 2000-2038.
|
* This later definition should work on all platforms.
|
* This later definition should work on all platforms.
|
*/
|
*/
|
|
|
if (TclDateYear < 100) {
|
if (TclDateYear < 100) {
|
if (TclDateYear >= 69) {
|
if (TclDateYear >= 69) {
|
TclDateYear += 1900;
|
TclDateYear += 1900;
|
} else {
|
} else {
|
TclDateYear += 2000;
|
TclDateYear += 2000;
|
}
|
}
|
}
|
}
|
if (Convert(TclDateMonth, TclDateDay, TclDateYear, TclDateHour, TclDateMinutes, TclDateSeconds,
|
if (Convert(TclDateMonth, TclDateDay, TclDateYear, TclDateHour, TclDateMinutes, TclDateSeconds,
|
TclDateMeridian, TclDateDSTmode, &Start) < 0) {
|
TclDateMeridian, TclDateDSTmode, &Start) < 0) {
|
return -1;
|
return -1;
|
}
|
}
|
} else {
|
} else {
|
Start = now;
|
Start = now;
|
if (!TclDateHaveRel) {
|
if (!TclDateHaveRel) {
|
Start -= ((tm->tm_hour * 60L) + tm->tm_min * 60L) + tm->tm_sec;
|
Start -= ((tm->tm_hour * 60L) + tm->tm_min * 60L) + tm->tm_sec;
|
}
|
}
|
}
|
}
|
|
|
Start += TclDateRelSeconds;
|
Start += TclDateRelSeconds;
|
if (RelativeMonth(Start, TclDateRelMonth, &Time) < 0) {
|
if (RelativeMonth(Start, TclDateRelMonth, &Time) < 0) {
|
return -1;
|
return -1;
|
}
|
}
|
Start += Time;
|
Start += Time;
|
|
|
if (TclDateHaveDay && !TclDateHaveDate) {
|
if (TclDateHaveDay && !TclDateHaveDate) {
|
tod = RelativeDate(Start, TclDateDayOrdinal, TclDateDayNumber);
|
tod = RelativeDate(Start, TclDateDayOrdinal, TclDateDayNumber);
|
Start += tod;
|
Start += tod;
|
}
|
}
|
|
|
*timePtr = Start;
|
*timePtr = Start;
|
return 0;
|
return 0;
|
}
|
}
|
TclDatetabelem TclDateexca[] ={
|
TclDatetabelem TclDateexca[] ={
|
-1, 1,
|
-1, 1,
|
0, -1,
|
0, -1,
|
-2, 0,
|
-2, 0,
|
};
|
};
|
# define YYNPROD 41
|
# define YYNPROD 41
|
# define YYLAST 227
|
# define YYLAST 227
|
TclDatetabelem TclDateact[]={
|
TclDatetabelem TclDateact[]={
|
|
|
14, 11, 23, 28, 17, 12, 19, 18, 16, 9,
|
14, 11, 23, 28, 17, 12, 19, 18, 16, 9,
|
10, 13, 42, 21, 46, 45, 44, 48, 41, 37,
|
10, 13, 42, 21, 46, 45, 44, 48, 41, 37,
|
36, 35, 32, 29, 34, 33, 31, 43, 39, 38,
|
36, 35, 32, 29, 34, 33, 31, 43, 39, 38,
|
30, 15, 8, 7, 6, 5, 4, 3, 2, 1,
|
30, 15, 8, 7, 6, 5, 4, 3, 2, 1,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 47, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 47, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
0, 0, 0, 22, 0, 0, 20, 25, 24, 27,
|
0, 0, 0, 22, 0, 0, 20, 25, 24, 27,
|
26, 42, 0, 0, 0, 0, 40 };
|
26, 42, 0, 0, 0, 0, 40 };
|
TclDatetabelem TclDatepact[]={
|
TclDatetabelem TclDatepact[]={
|
|
|
-10000000, -258,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -45,
|
-10000000, -258,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -45,
|
-267,-10000000, -244,-10000000, -14, -231, -240,-10000000,-10000000,-10000000,
|
-267,-10000000, -244,-10000000, -14, -231, -240,-10000000,-10000000,-10000000,
|
-10000000, -246,-10000000, -247, -248,-10000000,-10000000,-10000000,-10000000, -15,
|
-10000000, -246,-10000000, -247, -248,-10000000,-10000000,-10000000,-10000000, -15,
|
-10000000,-10000000,-10000000,-10000000,-10000000, -40, -20,-10000000, -251,-10000000,
|
-10000000,-10000000,-10000000,-10000000,-10000000, -40, -20,-10000000, -251,-10000000,
|
-10000000, -252,-10000000, -253,-10000000, -249,-10000000,-10000000,-10000000 };
|
-10000000, -252,-10000000, -253,-10000000, -249,-10000000,-10000000,-10000000 };
|
TclDatetabelem TclDatepgo[]={
|
TclDatetabelem TclDatepgo[]={
|
|
|
0, 28, 39, 38, 37, 36, 35, 34, 33, 32,
|
0, 28, 39, 38, 37, 36, 35, 34, 33, 32,
|
31 };
|
31 };
|
TclDatetabelem TclDater1[]={
|
TclDatetabelem TclDater1[]={
|
|
|
0, 2, 2, 3, 3, 3, 3, 3, 3, 4,
|
0, 2, 2, 3, 3, 3, 3, 3, 3, 4,
|
4, 4, 4, 4, 5, 5, 5, 7, 7, 7,
|
4, 4, 4, 4, 5, 5, 5, 7, 7, 7,
|
6, 6, 6, 6, 6, 6, 6, 8, 8, 10,
|
6, 6, 6, 6, 6, 6, 6, 8, 8, 10,
|
10, 10, 10, 10, 10, 10, 10, 10, 9, 1,
|
10, 10, 10, 10, 10, 10, 10, 10, 9, 1,
|
1 };
|
1 };
|
TclDatetabelem TclDater2[]={
|
TclDatetabelem TclDater2[]={
|
|
|
0, 0, 4, 3, 3, 3, 3, 3, 2, 5,
|
0, 0, 4, 3, 3, 3, 3, 3, 2, 5,
|
9, 9, 13, 13, 5, 3, 3, 3, 5, 5,
|
9, 9, 13, 13, 5, 3, 3, 3, 5, 5,
|
7, 11, 5, 9, 5, 3, 7, 5, 2, 5,
|
7, 11, 5, 9, 5, 3, 7, 5, 2, 5,
|
5, 3, 5, 5, 3, 5, 5, 3, 3, 1,
|
5, 3, 5, 5, 3, 5, 5, 3, 3, 1,
|
3 };
|
3 };
|
TclDatetabelem TclDatechk[]={
|
TclDatetabelem TclDatechk[]={
|
|
|
-10000000, -2, -3, -4, -5, -6, -7, -8, -9, 267,
|
-10000000, -2, -3, -4, -5, -6, -7, -8, -9, 267,
|
268, 259, 263, 269, 258, -10, 266, 262, 265, 264,
|
268, 259, 263, 269, 258, -10, 266, 262, 265, 264,
|
261, 58, 258, 47, 263, 262, 265, 264, 270, 267,
|
261, 58, 258, 47, 263, 262, 265, 264, 270, 267,
|
44, 257, 262, 265, 264, 267, 267, 267, 44, -1,
|
44, 257, 262, 265, 264, 267, 267, 267, 44, -1,
|
266, 58, 261, 47, 267, 267, 267, -1, 266 };
|
266, 58, 261, 47, 267, 267, 267, -1, 266 };
|
TclDatetabelem TclDatedef[]={
|
TclDatetabelem TclDatedef[]={
|
|
|
1, -2, 2, 3, 4, 5, 6, 7, 8, 38,
|
1, -2, 2, 3, 4, 5, 6, 7, 8, 38,
|
15, 16, 0, 25, 17, 28, 0, 31, 34, 37,
|
15, 16, 0, 25, 17, 28, 0, 31, 34, 37,
|
9, 0, 19, 0, 24, 29, 33, 36, 14, 22,
|
9, 0, 19, 0, 24, 29, 33, 36, 14, 22,
|
18, 27, 30, 32, 35, 39, 20, 26, 0, 10,
|
18, 27, 30, 32, 35, 39, 20, 26, 0, 10,
|
11, 0, 40, 0, 23, 39, 21, 12, 13 };
|
11, 0, 40, 0, 23, 39, 21, 12, 13 };
|
typedef struct
|
typedef struct
|
#ifdef __cplusplus
|
#ifdef __cplusplus
|
TclDatetoktype
|
TclDatetoktype
|
#endif
|
#endif
|
{ char *t_name; int t_val; } TclDatetoktype;
|
{ char *t_name; int t_val; } TclDatetoktype;
|
#ifndef YYDEBUG
|
#ifndef YYDEBUG
|
# define YYDEBUG 0 /* don't allow debugging */
|
# define YYDEBUG 0 /* don't allow debugging */
|
#endif
|
#endif
|
|
|
#if YYDEBUG
|
#if YYDEBUG
|
|
|
TclDatetoktype TclDatetoks[] =
|
TclDatetoktype TclDatetoks[] =
|
{
|
{
|
"tAGO", 257,
|
"tAGO", 257,
|
"tDAY", 258,
|
"tDAY", 258,
|
"tDAYZONE", 259,
|
"tDAYZONE", 259,
|
"tID", 260,
|
"tID", 260,
|
"tMERIDIAN", 261,
|
"tMERIDIAN", 261,
|
"tMINUTE_UNIT", 262,
|
"tMINUTE_UNIT", 262,
|
"tMONTH", 263,
|
"tMONTH", 263,
|
"tMONTH_UNIT", 264,
|
"tMONTH_UNIT", 264,
|
"tSEC_UNIT", 265,
|
"tSEC_UNIT", 265,
|
"tSNUMBER", 266,
|
"tSNUMBER", 266,
|
"tUNUMBER", 267,
|
"tUNUMBER", 267,
|
"tZONE", 268,
|
"tZONE", 268,
|
"tEPOCH", 269,
|
"tEPOCH", 269,
|
"tDST", 270,
|
"tDST", 270,
|
"-unknown-", -1 /* ends search */
|
"-unknown-", -1 /* ends search */
|
};
|
};
|
|
|
char * TclDatereds[] =
|
char * TclDatereds[] =
|
{
|
{
|
"-no such reduction-",
|
"-no such reduction-",
|
"spec : /* empty */",
|
"spec : /* empty */",
|
"spec : spec item",
|
"spec : spec item",
|
"item : time",
|
"item : time",
|
"item : zone",
|
"item : zone",
|
"item : date",
|
"item : date",
|
"item : day",
|
"item : day",
|
"item : rel",
|
"item : rel",
|
"item : number",
|
"item : number",
|
"time : tUNUMBER tMERIDIAN",
|
"time : tUNUMBER tMERIDIAN",
|
"time : tUNUMBER ':' tUNUMBER o_merid",
|
"time : tUNUMBER ':' tUNUMBER o_merid",
|
"time : tUNUMBER ':' tUNUMBER tSNUMBER",
|
"time : tUNUMBER ':' tUNUMBER tSNUMBER",
|
"time : tUNUMBER ':' tUNUMBER ':' tUNUMBER o_merid",
|
"time : tUNUMBER ':' tUNUMBER ':' tUNUMBER o_merid",
|
"time : tUNUMBER ':' tUNUMBER ':' tUNUMBER tSNUMBER",
|
"time : tUNUMBER ':' tUNUMBER ':' tUNUMBER tSNUMBER",
|
"zone : tZONE tDST",
|
"zone : tZONE tDST",
|
"zone : tZONE",
|
"zone : tZONE",
|
"zone : tDAYZONE",
|
"zone : tDAYZONE",
|
"day : tDAY",
|
"day : tDAY",
|
"day : tDAY ','",
|
"day : tDAY ','",
|
"day : tUNUMBER tDAY",
|
"day : tUNUMBER tDAY",
|
"date : tUNUMBER '/' tUNUMBER",
|
"date : tUNUMBER '/' tUNUMBER",
|
"date : tUNUMBER '/' tUNUMBER '/' tUNUMBER",
|
"date : tUNUMBER '/' tUNUMBER '/' tUNUMBER",
|
"date : tMONTH tUNUMBER",
|
"date : tMONTH tUNUMBER",
|
"date : tMONTH tUNUMBER ',' tUNUMBER",
|
"date : tMONTH tUNUMBER ',' tUNUMBER",
|
"date : tUNUMBER tMONTH",
|
"date : tUNUMBER tMONTH",
|
"date : tEPOCH",
|
"date : tEPOCH",
|
"date : tUNUMBER tMONTH tUNUMBER",
|
"date : tUNUMBER tMONTH tUNUMBER",
|
"rel : relunit tAGO",
|
"rel : relunit tAGO",
|
"rel : relunit",
|
"rel : relunit",
|
"relunit : tUNUMBER tMINUTE_UNIT",
|
"relunit : tUNUMBER tMINUTE_UNIT",
|
"relunit : tSNUMBER tMINUTE_UNIT",
|
"relunit : tSNUMBER tMINUTE_UNIT",
|
"relunit : tMINUTE_UNIT",
|
"relunit : tMINUTE_UNIT",
|
"relunit : tSNUMBER tSEC_UNIT",
|
"relunit : tSNUMBER tSEC_UNIT",
|
"relunit : tUNUMBER tSEC_UNIT",
|
"relunit : tUNUMBER tSEC_UNIT",
|
"relunit : tSEC_UNIT",
|
"relunit : tSEC_UNIT",
|
"relunit : tSNUMBER tMONTH_UNIT",
|
"relunit : tSNUMBER tMONTH_UNIT",
|
"relunit : tUNUMBER tMONTH_UNIT",
|
"relunit : tUNUMBER tMONTH_UNIT",
|
"relunit : tMONTH_UNIT",
|
"relunit : tMONTH_UNIT",
|
"number : tUNUMBER",
|
"number : tUNUMBER",
|
"o_merid : /* empty */",
|
"o_merid : /* empty */",
|
"o_merid : tMERIDIAN",
|
"o_merid : tMERIDIAN",
|
};
|
};
|
#endif /* YYDEBUG */
|
#endif /* YYDEBUG */
|
/*
|
/*
|
* Copyright (c) 1993 by Sun Microsystems, Inc.
|
* Copyright (c) 1993 by Sun Microsystems, Inc.
|
*/
|
*/
|
|
|
|
|
/*
|
/*
|
** Skeleton parser driver for yacc output
|
** Skeleton parser driver for yacc output
|
*/
|
*/
|
|
|
/*
|
/*
|
** yacc user known macros and defines
|
** yacc user known macros and defines
|
*/
|
*/
|
#define YYERROR goto TclDateerrlab
|
#define YYERROR goto TclDateerrlab
|
#define YYACCEPT return(0)
|
#define YYACCEPT return(0)
|
#define YYABORT return(1)
|
#define YYABORT return(1)
|
#define YYBACKUP( newtoken, newvalue )\
|
#define YYBACKUP( newtoken, newvalue )\
|
{\
|
{\
|
if ( TclDatechar >= 0 || ( TclDater2[ TclDatetmp ] >> 1 ) != 1 )\
|
if ( TclDatechar >= 0 || ( TclDater2[ TclDatetmp ] >> 1 ) != 1 )\
|
{\
|
{\
|
TclDateerror( "syntax error - cannot backup" );\
|
TclDateerror( "syntax error - cannot backup" );\
|
goto TclDateerrlab;\
|
goto TclDateerrlab;\
|
}\
|
}\
|
TclDatechar = newtoken;\
|
TclDatechar = newtoken;\
|
TclDatestate = *TclDateps;\
|
TclDatestate = *TclDateps;\
|
TclDatelval = newvalue;\
|
TclDatelval = newvalue;\
|
goto TclDatenewstate;\
|
goto TclDatenewstate;\
|
}
|
}
|
#define YYRECOVERING() (!!TclDateerrflag)
|
#define YYRECOVERING() (!!TclDateerrflag)
|
#define YYNEW(type) malloc(sizeof(type) * TclDatenewmax)
|
#define YYNEW(type) malloc(sizeof(type) * TclDatenewmax)
|
#define YYCOPY(to, from, type) \
|
#define YYCOPY(to, from, type) \
|
(type *) memcpy(to, (char *) from, TclDatenewmax * sizeof(type))
|
(type *) memcpy(to, (char *) from, TclDatenewmax * sizeof(type))
|
#define YYENLARGE( from, type) \
|
#define YYENLARGE( from, type) \
|
(type *) realloc((char *) from, TclDatenewmax * sizeof(type))
|
(type *) realloc((char *) from, TclDatenewmax * sizeof(type))
|
#ifndef YYDEBUG
|
#ifndef YYDEBUG
|
# define YYDEBUG 1 /* make debugging available */
|
# define YYDEBUG 1 /* make debugging available */
|
#endif
|
#endif
|
|
|
/*
|
/*
|
** user known globals
|
** user known globals
|
*/
|
*/
|
int TclDatedebug; /* set to 1 to get debugging */
|
int TclDatedebug; /* set to 1 to get debugging */
|
|
|
/*
|
/*
|
** driver internal defines
|
** driver internal defines
|
*/
|
*/
|
#define YYFLAG (-10000000)
|
#define YYFLAG (-10000000)
|
|
|
/*
|
/*
|
** global variables used by the parser
|
** global variables used by the parser
|
*/
|
*/
|
YYSTYPE *TclDatepv; /* top of value stack */
|
YYSTYPE *TclDatepv; /* top of value stack */
|
int *TclDateps; /* top of state stack */
|
int *TclDateps; /* top of state stack */
|
|
|
int TclDatestate; /* current state */
|
int TclDatestate; /* current state */
|
int TclDatetmp; /* extra var (lasts between blocks) */
|
int TclDatetmp; /* extra var (lasts between blocks) */
|
|
|
int TclDatenerrs; /* number of errors */
|
int TclDatenerrs; /* number of errors */
|
int TclDateerrflag; /* error recovery flag */
|
int TclDateerrflag; /* error recovery flag */
|
int TclDatechar; /* current input token number */
|
int TclDatechar; /* current input token number */
|
|
|
|
|
|
|
#ifdef YYNMBCHARS
|
#ifdef YYNMBCHARS
|
#define YYLEX() TclDatecvtok(TclDatelex())
|
#define YYLEX() TclDatecvtok(TclDatelex())
|
/*
|
/*
|
** TclDatecvtok - return a token if i is a wchar_t value that exceeds 255.
|
** 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
|
** 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.
|
** of the 30th or 31st bit is on, i is already a token.
|
*/
|
*/
|
#if defined(__STDC__) || defined(__cplusplus)
|
#if defined(__STDC__) || defined(__cplusplus)
|
int TclDatecvtok(int i)
|
int TclDatecvtok(int i)
|
#else
|
#else
|
int TclDatecvtok(i) int i;
|
int TclDatecvtok(i) int i;
|
#endif
|
#endif
|
{
|
{
|
int first = 0;
|
int first = 0;
|
int last = YYNMBCHARS - 1;
|
int last = YYNMBCHARS - 1;
|
int mid;
|
int mid;
|
wchar_t j;
|
wchar_t j;
|
|
|
if(i&0x60000000){/*Must convert to a token. */
|
if(i&0x60000000){/*Must convert to a token. */
|
if( TclDatembchars[last].character < i ){
|
if( TclDatembchars[last].character < i ){
|
return i;/*Giving up*/
|
return i;/*Giving up*/
|
}
|
}
|
while ((last>=first)&&(first>=0)) {/*Binary search loop*/
|
while ((last>=first)&&(first>=0)) {/*Binary search loop*/
|
mid = (first+last)/2;
|
mid = (first+last)/2;
|
j = TclDatembchars[mid].character;
|
j = TclDatembchars[mid].character;
|
if( j==i ){/*Found*/
|
if( j==i ){/*Found*/
|
return TclDatembchars[mid].tvalue;
|
return TclDatembchars[mid].tvalue;
|
}else if( j<i ){
|
}else if( j<i ){
|
first = mid + 1;
|
first = mid + 1;
|
}else{
|
}else{
|
last = mid -1;
|
last = mid -1;
|
}
|
}
|
}
|
}
|
/*No entry in the table.*/
|
/*No entry in the table.*/
|
return i;/* Giving up.*/
|
return i;/* Giving up.*/
|
}else{/* i is already a token. */
|
}else{/* i is already a token. */
|
return i;
|
return i;
|
}
|
}
|
}
|
}
|
#else/*!YYNMBCHARS*/
|
#else/*!YYNMBCHARS*/
|
#define YYLEX() TclDatelex()
|
#define YYLEX() TclDatelex()
|
#endif/*!YYNMBCHARS*/
|
#endif/*!YYNMBCHARS*/
|
|
|
/*
|
/*
|
** TclDateparse - return 0 if worked, 1 if syntax error not recovered from
|
** TclDateparse - return 0 if worked, 1 if syntax error not recovered from
|
*/
|
*/
|
#if defined(__STDC__) || defined(__cplusplus)
|
#if defined(__STDC__) || defined(__cplusplus)
|
int TclDateparse(void)
|
int TclDateparse(void)
|
#else
|
#else
|
int TclDateparse()
|
int TclDateparse()
|
#endif
|
#endif
|
{
|
{
|
register YYSTYPE *TclDatepvt; /* top of value stack for $vars */
|
register YYSTYPE *TclDatepvt; /* top of value stack for $vars */
|
|
|
#if defined(__cplusplus) || defined(lint)
|
#if defined(__cplusplus) || defined(lint)
|
/*
|
/*
|
hacks to please C++ and lint - goto's inside switch should never be
|
hacks to please C++ and lint - goto's inside switch should never be
|
executed; TclDatepvt is set to 0 to avoid "used before set" warning.
|
executed; TclDatepvt is set to 0 to avoid "used before set" warning.
|
*/
|
*/
|
static int __yaccpar_lint_hack__ = 0;
|
static int __yaccpar_lint_hack__ = 0;
|
switch (__yaccpar_lint_hack__)
|
switch (__yaccpar_lint_hack__)
|
{
|
{
|
case 1: goto TclDateerrlab;
|
case 1: goto TclDateerrlab;
|
case 2: goto TclDatenewstate;
|
case 2: goto TclDatenewstate;
|
}
|
}
|
TclDatepvt = 0;
|
TclDatepvt = 0;
|
#endif
|
#endif
|
|
|
/*
|
/*
|
** Initialize externals - TclDateparse may be called more than once
|
** Initialize externals - TclDateparse may be called more than once
|
*/
|
*/
|
TclDatepv = &TclDatev[-1];
|
TclDatepv = &TclDatev[-1];
|
TclDateps = &TclDates[-1];
|
TclDateps = &TclDates[-1];
|
TclDatestate = 0;
|
TclDatestate = 0;
|
TclDatetmp = 0;
|
TclDatetmp = 0;
|
TclDatenerrs = 0;
|
TclDatenerrs = 0;
|
TclDateerrflag = 0;
|
TclDateerrflag = 0;
|
TclDatechar = -1;
|
TclDatechar = -1;
|
|
|
#if YYMAXDEPTH <= 0
|
#if YYMAXDEPTH <= 0
|
if (TclDatemaxdepth <= 0)
|
if (TclDatemaxdepth <= 0)
|
{
|
{
|
if ((TclDatemaxdepth = YYEXPAND(0)) <= 0)
|
if ((TclDatemaxdepth = YYEXPAND(0)) <= 0)
|
{
|
{
|
TclDateerror("yacc initialization error");
|
TclDateerror("yacc initialization error");
|
YYABORT;
|
YYABORT;
|
}
|
}
|
}
|
}
|
#endif
|
#endif
|
|
|
{
|
{
|
register YYSTYPE *TclDate_pv; /* top of value stack */
|
register YYSTYPE *TclDate_pv; /* top of value stack */
|
register int *TclDate_ps; /* top of state stack */
|
register int *TclDate_ps; /* top of state stack */
|
register int TclDate_state; /* current state */
|
register int TclDate_state; /* current state */
|
register int TclDate_n; /* internal state number info */
|
register int TclDate_n; /* internal state number info */
|
goto TclDatestack; /* moved from 6 lines above to here to please C++ */
|
goto TclDatestack; /* moved from 6 lines above to here to please C++ */
|
|
|
/*
|
/*
|
** get globals into registers.
|
** get globals into registers.
|
** branch to here only if YYBACKUP was called.
|
** branch to here only if YYBACKUP was called.
|
*/
|
*/
|
TclDate_pv = TclDatepv;
|
TclDate_pv = TclDatepv;
|
TclDate_ps = TclDateps;
|
TclDate_ps = TclDateps;
|
TclDate_state = TclDatestate;
|
TclDate_state = TclDatestate;
|
goto TclDate_newstate;
|
goto TclDate_newstate;
|
|
|
/*
|
/*
|
** get globals into registers.
|
** get globals into registers.
|
** either we just started, or we just finished a reduction
|
** either we just started, or we just finished a reduction
|
*/
|
*/
|
TclDatestack:
|
TclDatestack:
|
TclDate_pv = TclDatepv;
|
TclDate_pv = TclDatepv;
|
TclDate_ps = TclDateps;
|
TclDate_ps = TclDateps;
|
TclDate_state = TclDatestate;
|
TclDate_state = TclDatestate;
|
|
|
/*
|
/*
|
** top of for (;;) loop while no reductions done
|
** top of for (;;) loop while no reductions done
|
*/
|
*/
|
TclDate_stack:
|
TclDate_stack:
|
/*
|
/*
|
** put a state and value onto the stacks
|
** put a state and value onto the stacks
|
*/
|
*/
|
#if YYDEBUG
|
#if YYDEBUG
|
/*
|
/*
|
** if debugging, look up token value in list of value vs.
|
** if debugging, look up token value in list of value vs.
|
** name pairs. 0 and negative (-1) are special values.
|
** name pairs. 0 and negative (-1) are special values.
|
** Note: linear search is used since time is not a real
|
** Note: linear search is used since time is not a real
|
** consideration while debugging.
|
** consideration while debugging.
|
*/
|
*/
|
if ( TclDatedebug )
|
if ( TclDatedebug )
|
{
|
{
|
register int TclDate_i;
|
register int TclDate_i;
|
|
|
printf( "State %d, token ", TclDate_state );
|
printf( "State %d, token ", TclDate_state );
|
if ( TclDatechar == 0 )
|
if ( TclDatechar == 0 )
|
printf( "end-of-file\n" );
|
printf( "end-of-file\n" );
|
else if ( TclDatechar < 0 )
|
else if ( TclDatechar < 0 )
|
printf( "-none-\n" );
|
printf( "-none-\n" );
|
else
|
else
|
{
|
{
|
for ( TclDate_i = 0; TclDatetoks[TclDate_i].t_val >= 0;
|
for ( TclDate_i = 0; TclDatetoks[TclDate_i].t_val >= 0;
|
TclDate_i++ )
|
TclDate_i++ )
|
{
|
{
|
if ( TclDatetoks[TclDate_i].t_val == TclDatechar )
|
if ( TclDatetoks[TclDate_i].t_val == TclDatechar )
|
break;
|
break;
|
}
|
}
|
printf( "%s\n", TclDatetoks[TclDate_i].t_name );
|
printf( "%s\n", TclDatetoks[TclDate_i].t_name );
|
}
|
}
|
}
|
}
|
#endif /* YYDEBUG */
|
#endif /* YYDEBUG */
|
if ( ++TclDate_ps >= &TclDates[ TclDatemaxdepth ] ) /* room on stack? */
|
if ( ++TclDate_ps >= &TclDates[ TclDatemaxdepth ] ) /* room on stack? */
|
{
|
{
|
/*
|
/*
|
** reallocate and recover. Note that pointers
|
** reallocate and recover. Note that pointers
|
** have to be reset, or bad things will happen
|
** have to be reset, or bad things will happen
|
*/
|
*/
|
int TclDateps_index = (TclDate_ps - TclDates);
|
int TclDateps_index = (TclDate_ps - TclDates);
|
int TclDatepv_index = (TclDate_pv - TclDatev);
|
int TclDatepv_index = (TclDate_pv - TclDatev);
|
int TclDatepvt_index = (TclDatepvt - TclDatev);
|
int TclDatepvt_index = (TclDatepvt - TclDatev);
|
int TclDatenewmax;
|
int TclDatenewmax;
|
#ifdef YYEXPAND
|
#ifdef YYEXPAND
|
TclDatenewmax = YYEXPAND(TclDatemaxdepth);
|
TclDatenewmax = YYEXPAND(TclDatemaxdepth);
|
#else
|
#else
|
TclDatenewmax = 2 * TclDatemaxdepth; /* double table size */
|
TclDatenewmax = 2 * TclDatemaxdepth; /* double table size */
|
if (TclDatemaxdepth == YYMAXDEPTH) /* first time growth */
|
if (TclDatemaxdepth == YYMAXDEPTH) /* first time growth */
|
{
|
{
|
char *newTclDates = (char *)YYNEW(int);
|
char *newTclDates = (char *)YYNEW(int);
|
char *newTclDatev = (char *)YYNEW(YYSTYPE);
|
char *newTclDatev = (char *)YYNEW(YYSTYPE);
|
if (newTclDates != 0 && newTclDatev != 0)
|
if (newTclDates != 0 && newTclDatev != 0)
|
{
|
{
|
TclDates = YYCOPY(newTclDates, TclDates, int);
|
TclDates = YYCOPY(newTclDates, TclDates, int);
|
TclDatev = YYCOPY(newTclDatev, TclDatev, YYSTYPE);
|
TclDatev = YYCOPY(newTclDatev, TclDatev, YYSTYPE);
|
}
|
}
|
else
|
else
|
TclDatenewmax = 0; /* failed */
|
TclDatenewmax = 0; /* failed */
|
}
|
}
|
else /* not first time */
|
else /* not first time */
|
{
|
{
|
TclDates = YYENLARGE(TclDates, int);
|
TclDates = YYENLARGE(TclDates, int);
|
TclDatev = YYENLARGE(TclDatev, YYSTYPE);
|
TclDatev = YYENLARGE(TclDatev, YYSTYPE);
|
if (TclDates == 0 || TclDatev == 0)
|
if (TclDates == 0 || TclDatev == 0)
|
TclDatenewmax = 0; /* failed */
|
TclDatenewmax = 0; /* failed */
|
}
|
}
|
#endif
|
#endif
|
if (TclDatenewmax <= TclDatemaxdepth) /* tables not expanded */
|
if (TclDatenewmax <= TclDatemaxdepth) /* tables not expanded */
|
{
|
{
|
TclDateerror( "yacc stack overflow" );
|
TclDateerror( "yacc stack overflow" );
|
YYABORT;
|
YYABORT;
|
}
|
}
|
TclDatemaxdepth = TclDatenewmax;
|
TclDatemaxdepth = TclDatenewmax;
|
|
|
TclDate_ps = TclDates + TclDateps_index;
|
TclDate_ps = TclDates + TclDateps_index;
|
TclDate_pv = TclDatev + TclDatepv_index;
|
TclDate_pv = TclDatev + TclDatepv_index;
|
TclDatepvt = TclDatev + TclDatepvt_index;
|
TclDatepvt = TclDatev + TclDatepvt_index;
|
}
|
}
|
*TclDate_ps = TclDate_state;
|
*TclDate_ps = TclDate_state;
|
*++TclDate_pv = TclDateval;
|
*++TclDate_pv = TclDateval;
|
|
|
/*
|
/*
|
** we have a new state - find out what to do
|
** we have a new state - find out what to do
|
*/
|
*/
|
TclDate_newstate:
|
TclDate_newstate:
|
if ( ( TclDate_n = TclDatepact[ TclDate_state ] ) <= YYFLAG )
|
if ( ( TclDate_n = TclDatepact[ TclDate_state ] ) <= YYFLAG )
|
goto TclDatedefault; /* simple state */
|
goto TclDatedefault; /* simple state */
|
#if YYDEBUG
|
#if YYDEBUG
|
/*
|
/*
|
** if debugging, need to mark whether new token grabbed
|
** if debugging, need to mark whether new token grabbed
|
*/
|
*/
|
TclDatetmp = TclDatechar < 0;
|
TclDatetmp = TclDatechar < 0;
|
#endif
|
#endif
|
if ( ( TclDatechar < 0 ) && ( ( TclDatechar = YYLEX() ) < 0 ) )
|
if ( ( TclDatechar < 0 ) && ( ( TclDatechar = YYLEX() ) < 0 ) )
|
TclDatechar = 0; /* reached EOF */
|
TclDatechar = 0; /* reached EOF */
|
#if YYDEBUG
|
#if YYDEBUG
|
if ( TclDatedebug && TclDatetmp )
|
if ( TclDatedebug && TclDatetmp )
|
{
|
{
|
register int TclDate_i;
|
register int TclDate_i;
|
|
|
printf( "Received token " );
|
printf( "Received token " );
|
if ( TclDatechar == 0 )
|
if ( TclDatechar == 0 )
|
printf( "end-of-file\n" );
|
printf( "end-of-file\n" );
|
else if ( TclDatechar < 0 )
|
else if ( TclDatechar < 0 )
|
printf( "-none-\n" );
|
printf( "-none-\n" );
|
else
|
else
|
{
|
{
|
for ( TclDate_i = 0; TclDatetoks[TclDate_i].t_val >= 0;
|
for ( TclDate_i = 0; TclDatetoks[TclDate_i].t_val >= 0;
|
TclDate_i++ )
|
TclDate_i++ )
|
{
|
{
|
if ( TclDatetoks[TclDate_i].t_val == TclDatechar )
|
if ( TclDatetoks[TclDate_i].t_val == TclDatechar )
|
break;
|
break;
|
}
|
}
|
printf( "%s\n", TclDatetoks[TclDate_i].t_name );
|
printf( "%s\n", TclDatetoks[TclDate_i].t_name );
|
}
|
}
|
}
|
}
|
#endif /* YYDEBUG */
|
#endif /* YYDEBUG */
|
if ( ( ( TclDate_n += TclDatechar ) < 0 ) || ( TclDate_n >= YYLAST ) )
|
if ( ( ( TclDate_n += TclDatechar ) < 0 ) || ( TclDate_n >= YYLAST ) )
|
goto TclDatedefault;
|
goto TclDatedefault;
|
if ( TclDatechk[ TclDate_n = TclDateact[ TclDate_n ] ] == TclDatechar ) /*valid shift*/
|
if ( TclDatechk[ TclDate_n = TclDateact[ TclDate_n ] ] == TclDatechar ) /*valid shift*/
|
{
|
{
|
TclDatechar = -1;
|
TclDatechar = -1;
|
TclDateval = TclDatelval;
|
TclDateval = TclDatelval;
|
TclDate_state = TclDate_n;
|
TclDate_state = TclDate_n;
|
if ( TclDateerrflag > 0 )
|
if ( TclDateerrflag > 0 )
|
TclDateerrflag--;
|
TclDateerrflag--;
|
goto TclDate_stack;
|
goto TclDate_stack;
|
}
|
}
|
|
|
TclDatedefault:
|
TclDatedefault:
|
if ( ( TclDate_n = TclDatedef[ TclDate_state ] ) == -2 )
|
if ( ( TclDate_n = TclDatedef[ TclDate_state ] ) == -2 )
|
{
|
{
|
#if YYDEBUG
|
#if YYDEBUG
|
TclDatetmp = TclDatechar < 0;
|
TclDatetmp = TclDatechar < 0;
|
#endif
|
#endif
|
if ( ( TclDatechar < 0 ) && ( ( TclDatechar = YYLEX() ) < 0 ) )
|
if ( ( TclDatechar < 0 ) && ( ( TclDatechar = YYLEX() ) < 0 ) )
|
TclDatechar = 0; /* reached EOF */
|
TclDatechar = 0; /* reached EOF */
|
#if YYDEBUG
|
#if YYDEBUG
|
if ( TclDatedebug && TclDatetmp )
|
if ( TclDatedebug && TclDatetmp )
|
{
|
{
|
register int TclDate_i;
|
register int TclDate_i;
|
|
|
printf( "Received token " );
|
printf( "Received token " );
|
if ( TclDatechar == 0 )
|
if ( TclDatechar == 0 )
|
printf( "end-of-file\n" );
|
printf( "end-of-file\n" );
|
else if ( TclDatechar < 0 )
|
else if ( TclDatechar < 0 )
|
printf( "-none-\n" );
|
printf( "-none-\n" );
|
else
|
else
|
{
|
{
|
for ( TclDate_i = 0;
|
for ( TclDate_i = 0;
|
TclDatetoks[TclDate_i].t_val >= 0;
|
TclDatetoks[TclDate_i].t_val >= 0;
|
TclDate_i++ )
|
TclDate_i++ )
|
{
|
{
|
if ( TclDatetoks[TclDate_i].t_val
|
if ( TclDatetoks[TclDate_i].t_val
|
== TclDatechar )
|
== TclDatechar )
|
{
|
{
|
break;
|
break;
|
}
|
}
|
}
|
}
|
printf( "%s\n", TclDatetoks[TclDate_i].t_name );
|
printf( "%s\n", TclDatetoks[TclDate_i].t_name );
|
}
|
}
|
}
|
}
|
#endif /* YYDEBUG */
|
#endif /* YYDEBUG */
|
/*
|
/*
|
** look through exception table
|
** look through exception table
|
*/
|
*/
|
{
|
{
|
register int *TclDatexi = TclDateexca;
|
register int *TclDatexi = TclDateexca;
|
|
|
while ( ( *TclDatexi != -1 ) ||
|
while ( ( *TclDatexi != -1 ) ||
|
( TclDatexi[1] != TclDate_state ) )
|
( TclDatexi[1] != TclDate_state ) )
|
{
|
{
|
TclDatexi += 2;
|
TclDatexi += 2;
|
}
|
}
|
while ( ( *(TclDatexi += 2) >= 0 ) &&
|
while ( ( *(TclDatexi += 2) >= 0 ) &&
|
( *TclDatexi != TclDatechar ) )
|
( *TclDatexi != TclDatechar ) )
|
;
|
;
|
if ( ( TclDate_n = TclDatexi[1] ) < 0 )
|
if ( ( TclDate_n = TclDatexi[1] ) < 0 )
|
YYACCEPT;
|
YYACCEPT;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
** check for syntax error
|
** check for syntax error
|
*/
|
*/
|
if ( TclDate_n == 0 ) /* have an error */
|
if ( TclDate_n == 0 ) /* have an error */
|
{
|
{
|
/* no worry about speed here! */
|
/* no worry about speed here! */
|
switch ( TclDateerrflag )
|
switch ( TclDateerrflag )
|
{
|
{
|
case 0: /* new error */
|
case 0: /* new error */
|
TclDateerror( "syntax error" );
|
TclDateerror( "syntax error" );
|
goto skip_init;
|
goto skip_init;
|
/*
|
/*
|
** get globals into registers.
|
** get globals into registers.
|
** we have a user generated syntax type error
|
** we have a user generated syntax type error
|
*/
|
*/
|
TclDate_pv = TclDatepv;
|
TclDate_pv = TclDatepv;
|
TclDate_ps = TclDateps;
|
TclDate_ps = TclDateps;
|
TclDate_state = TclDatestate;
|
TclDate_state = TclDatestate;
|
skip_init:
|
skip_init:
|
TclDatenerrs++;
|
TclDatenerrs++;
|
/* FALLTHRU */
|
/* FALLTHRU */
|
case 1:
|
case 1:
|
case 2: /* incompletely recovered error */
|
case 2: /* incompletely recovered error */
|
/* try again... */
|
/* try again... */
|
TclDateerrflag = 3;
|
TclDateerrflag = 3;
|
/*
|
/*
|
** find state where "error" is a legal
|
** find state where "error" is a legal
|
** shift action
|
** shift action
|
*/
|
*/
|
while ( TclDate_ps >= TclDates )
|
while ( TclDate_ps >= TclDates )
|
{
|
{
|
TclDate_n = TclDatepact[ *TclDate_ps ] + YYERRCODE;
|
TclDate_n = TclDatepact[ *TclDate_ps ] + YYERRCODE;
|
if ( TclDate_n >= 0 && TclDate_n < YYLAST &&
|
if ( TclDate_n >= 0 && TclDate_n < YYLAST &&
|
TclDatechk[TclDateact[TclDate_n]] == YYERRCODE) {
|
TclDatechk[TclDateact[TclDate_n]] == YYERRCODE) {
|
/*
|
/*
|
** simulate shift of "error"
|
** simulate shift of "error"
|
*/
|
*/
|
TclDate_state = TclDateact[ TclDate_n ];
|
TclDate_state = TclDateact[ TclDate_n ];
|
goto TclDate_stack;
|
goto TclDate_stack;
|
}
|
}
|
/*
|
/*
|
** current state has no shift on
|
** current state has no shift on
|
** "error", pop stack
|
** "error", pop stack
|
*/
|
*/
|
#if YYDEBUG
|
#if YYDEBUG
|
# define _POP_ "Error recovery pops state %d, uncovers state %d\n"
|
# define _POP_ "Error recovery pops state %d, uncovers state %d\n"
|
if ( TclDatedebug )
|
if ( TclDatedebug )
|
printf( _POP_, *TclDate_ps,
|
printf( _POP_, *TclDate_ps,
|
TclDate_ps[-1] );
|
TclDate_ps[-1] );
|
# undef _POP_
|
# undef _POP_
|
#endif
|
#endif
|
TclDate_ps--;
|
TclDate_ps--;
|
TclDate_pv--;
|
TclDate_pv--;
|
}
|
}
|
/*
|
/*
|
** there is no state on stack with "error" as
|
** there is no state on stack with "error" as
|
** a valid shift. give up.
|
** a valid shift. give up.
|
*/
|
*/
|
YYABORT;
|
YYABORT;
|
case 3: /* no shift yet; eat a token */
|
case 3: /* no shift yet; eat a token */
|
#if YYDEBUG
|
#if YYDEBUG
|
/*
|
/*
|
** if debugging, look up token in list of
|
** if debugging, look up token in list of
|
** pairs. 0 and negative shouldn't occur,
|
** pairs. 0 and negative shouldn't occur,
|
** but since timing doesn't matter when
|
** but since timing doesn't matter when
|
** debugging, it doesn't hurt to leave the
|
** debugging, it doesn't hurt to leave the
|
** tests here.
|
** tests here.
|
*/
|
*/
|
if ( TclDatedebug )
|
if ( TclDatedebug )
|
{
|
{
|
register int TclDate_i;
|
register int TclDate_i;
|
|
|
printf( "Error recovery discards " );
|
printf( "Error recovery discards " );
|
if ( TclDatechar == 0 )
|
if ( TclDatechar == 0 )
|
printf( "token end-of-file\n" );
|
printf( "token end-of-file\n" );
|
else if ( TclDatechar < 0 )
|
else if ( TclDatechar < 0 )
|
printf( "token -none-\n" );
|
printf( "token -none-\n" );
|
else
|
else
|
{
|
{
|
for ( TclDate_i = 0;
|
for ( TclDate_i = 0;
|
TclDatetoks[TclDate_i].t_val >= 0;
|
TclDatetoks[TclDate_i].t_val >= 0;
|
TclDate_i++ )
|
TclDate_i++ )
|
{
|
{
|
if ( TclDatetoks[TclDate_i].t_val
|
if ( TclDatetoks[TclDate_i].t_val
|
== TclDatechar )
|
== TclDatechar )
|
{
|
{
|
break;
|
break;
|
}
|
}
|
}
|
}
|
printf( "token %s\n",
|
printf( "token %s\n",
|
TclDatetoks[TclDate_i].t_name );
|
TclDatetoks[TclDate_i].t_name );
|
}
|
}
|
}
|
}
|
#endif /* YYDEBUG */
|
#endif /* YYDEBUG */
|
if ( TclDatechar == 0 ) /* reached EOF. quit */
|
if ( TclDatechar == 0 ) /* reached EOF. quit */
|
YYABORT;
|
YYABORT;
|
TclDatechar = -1;
|
TclDatechar = -1;
|
goto TclDate_newstate;
|
goto TclDate_newstate;
|
}
|
}
|
}/* end if ( TclDate_n == 0 ) */
|
}/* end if ( TclDate_n == 0 ) */
|
/*
|
/*
|
** reduction by production TclDate_n
|
** reduction by production TclDate_n
|
** put stack tops, etc. so things right after switch
|
** put stack tops, etc. so things right after switch
|
*/
|
*/
|
#if YYDEBUG
|
#if YYDEBUG
|
/*
|
/*
|
** if debugging, print the string that is the user's
|
** if debugging, print the string that is the user's
|
** specification of the reduction which is just about
|
** specification of the reduction which is just about
|
** to be done.
|
** to be done.
|
*/
|
*/
|
if ( TclDatedebug )
|
if ( TclDatedebug )
|
printf( "Reduce by (%d) \"%s\"\n",
|
printf( "Reduce by (%d) \"%s\"\n",
|
TclDate_n, TclDatereds[ TclDate_n ] );
|
TclDate_n, TclDatereds[ TclDate_n ] );
|
#endif
|
#endif
|
TclDatetmp = TclDate_n; /* value to switch over */
|
TclDatetmp = TclDate_n; /* value to switch over */
|
TclDatepvt = TclDate_pv; /* $vars top of value stack */
|
TclDatepvt = TclDate_pv; /* $vars top of value stack */
|
/*
|
/*
|
** Look in goto table for next state
|
** Look in goto table for next state
|
** Sorry about using TclDate_state here as temporary
|
** Sorry about using TclDate_state here as temporary
|
** register variable, but why not, if it works...
|
** register variable, but why not, if it works...
|
** If TclDater2[ TclDate_n ] doesn't have the low order bit
|
** If TclDater2[ TclDate_n ] doesn't have the low order bit
|
** set, then there is no action to be done for
|
** set, then there is no action to be done for
|
** this reduction. So, no saving & unsaving of
|
** this reduction. So, no saving & unsaving of
|
** registers done. The only difference between the
|
** registers done. The only difference between the
|
** code just after the if and the body of the if is
|
** code just after the if and the body of the if is
|
** the goto TclDate_stack in the body. This way the test
|
** the goto TclDate_stack in the body. This way the test
|
** can be made before the choice of what to do is needed.
|
** can be made before the choice of what to do is needed.
|
*/
|
*/
|
{
|
{
|
/* length of production doubled with extra bit */
|
/* length of production doubled with extra bit */
|
register int TclDate_len = TclDater2[ TclDate_n ];
|
register int TclDate_len = TclDater2[ TclDate_n ];
|
|
|
if ( !( TclDate_len & 01 ) )
|
if ( !( TclDate_len & 01 ) )
|
{
|
{
|
TclDate_len >>= 1;
|
TclDate_len >>= 1;
|
TclDateval = ( TclDate_pv -= TclDate_len )[1]; /* $$ = $1 */
|
TclDateval = ( TclDate_pv -= TclDate_len )[1]; /* $$ = $1 */
|
TclDate_state = TclDatepgo[ TclDate_n = TclDater1[ TclDate_n ] ] +
|
TclDate_state = TclDatepgo[ TclDate_n = TclDater1[ TclDate_n ] ] +
|
*( TclDate_ps -= TclDate_len ) + 1;
|
*( TclDate_ps -= TclDate_len ) + 1;
|
if ( TclDate_state >= YYLAST ||
|
if ( TclDate_state >= YYLAST ||
|
TclDatechk[ TclDate_state =
|
TclDatechk[ TclDate_state =
|
TclDateact[ TclDate_state ] ] != -TclDate_n )
|
TclDateact[ TclDate_state ] ] != -TclDate_n )
|
{
|
{
|
TclDate_state = TclDateact[ TclDatepgo[ TclDate_n ] ];
|
TclDate_state = TclDateact[ TclDatepgo[ TclDate_n ] ];
|
}
|
}
|
goto TclDate_stack;
|
goto TclDate_stack;
|
}
|
}
|
TclDate_len >>= 1;
|
TclDate_len >>= 1;
|
TclDateval = ( TclDate_pv -= TclDate_len )[1]; /* $$ = $1 */
|
TclDateval = ( TclDate_pv -= TclDate_len )[1]; /* $$ = $1 */
|
TclDate_state = TclDatepgo[ TclDate_n = TclDater1[ TclDate_n ] ] +
|
TclDate_state = TclDatepgo[ TclDate_n = TclDater1[ TclDate_n ] ] +
|
*( TclDate_ps -= TclDate_len ) + 1;
|
*( TclDate_ps -= TclDate_len ) + 1;
|
if ( TclDate_state >= YYLAST ||
|
if ( TclDate_state >= YYLAST ||
|
TclDatechk[ TclDate_state = TclDateact[ TclDate_state ] ] != -TclDate_n )
|
TclDatechk[ TclDate_state = TclDateact[ TclDate_state ] ] != -TclDate_n )
|
{
|
{
|
TclDate_state = TclDateact[ TclDatepgo[ TclDate_n ] ];
|
TclDate_state = TclDateact[ TclDatepgo[ TclDate_n ] ];
|
}
|
}
|
}
|
}
|
/* save until reenter driver code */
|
/* save until reenter driver code */
|
TclDatestate = TclDate_state;
|
TclDatestate = TclDate_state;
|
TclDateps = TclDate_ps;
|
TclDateps = TclDate_ps;
|
TclDatepv = TclDate_pv;
|
TclDatepv = TclDate_pv;
|
}
|
}
|
/*
|
/*
|
** code supplied by user is placed in this switch
|
** code supplied by user is placed in this switch
|
*/
|
*/
|
switch( TclDatetmp )
|
switch( TclDatetmp )
|
{
|
{
|
|
|
case 3:{
|
case 3:{
|
TclDateHaveTime++;
|
TclDateHaveTime++;
|
} break;
|
} break;
|
case 4:{
|
case 4:{
|
TclDateHaveZone++;
|
TclDateHaveZone++;
|
} break;
|
} break;
|
case 5:{
|
case 5:{
|
TclDateHaveDate++;
|
TclDateHaveDate++;
|
} break;
|
} break;
|
case 6:{
|
case 6:{
|
TclDateHaveDay++;
|
TclDateHaveDay++;
|
} break;
|
} break;
|
case 7:{
|
case 7:{
|
TclDateHaveRel++;
|
TclDateHaveRel++;
|
} break;
|
} break;
|
case 9:{
|
case 9:{
|
TclDateHour = TclDatepvt[-1].Number;
|
TclDateHour = TclDatepvt[-1].Number;
|
TclDateMinutes = 0;
|
TclDateMinutes = 0;
|
TclDateSeconds = 0;
|
TclDateSeconds = 0;
|
TclDateMeridian = TclDatepvt[-0].Meridian;
|
TclDateMeridian = TclDatepvt[-0].Meridian;
|
} break;
|
} break;
|
case 10:{
|
case 10:{
|
TclDateHour = TclDatepvt[-3].Number;
|
TclDateHour = TclDatepvt[-3].Number;
|
TclDateMinutes = TclDatepvt[-1].Number;
|
TclDateMinutes = TclDatepvt[-1].Number;
|
TclDateSeconds = 0;
|
TclDateSeconds = 0;
|
TclDateMeridian = TclDatepvt[-0].Meridian;
|
TclDateMeridian = TclDatepvt[-0].Meridian;
|
} break;
|
} break;
|
case 11:{
|
case 11:{
|
TclDateHour = TclDatepvt[-3].Number;
|
TclDateHour = TclDatepvt[-3].Number;
|
TclDateMinutes = TclDatepvt[-1].Number;
|
TclDateMinutes = TclDatepvt[-1].Number;
|
TclDateMeridian = MER24;
|
TclDateMeridian = MER24;
|
TclDateDSTmode = DSToff;
|
TclDateDSTmode = DSToff;
|
TclDateTimezone = - (TclDatepvt[-0].Number % 100 + (TclDatepvt[-0].Number / 100) * 60);
|
TclDateTimezone = - (TclDatepvt[-0].Number % 100 + (TclDatepvt[-0].Number / 100) * 60);
|
} break;
|
} break;
|
case 12:{
|
case 12:{
|
TclDateHour = TclDatepvt[-5].Number;
|
TclDateHour = TclDatepvt[-5].Number;
|
TclDateMinutes = TclDatepvt[-3].Number;
|
TclDateMinutes = TclDatepvt[-3].Number;
|
TclDateSeconds = TclDatepvt[-1].Number;
|
TclDateSeconds = TclDatepvt[-1].Number;
|
TclDateMeridian = TclDatepvt[-0].Meridian;
|
TclDateMeridian = TclDatepvt[-0].Meridian;
|
} break;
|
} break;
|
case 13:{
|
case 13:{
|
TclDateHour = TclDatepvt[-5].Number;
|
TclDateHour = TclDatepvt[-5].Number;
|
TclDateMinutes = TclDatepvt[-3].Number;
|
TclDateMinutes = TclDatepvt[-3].Number;
|
TclDateSeconds = TclDatepvt[-1].Number;
|
TclDateSeconds = TclDatepvt[-1].Number;
|
TclDateMeridian = MER24;
|
TclDateMeridian = MER24;
|
TclDateDSTmode = DSToff;
|
TclDateDSTmode = DSToff;
|
TclDateTimezone = - (TclDatepvt[-0].Number % 100 + (TclDatepvt[-0].Number / 100) * 60);
|
TclDateTimezone = - (TclDatepvt[-0].Number % 100 + (TclDatepvt[-0].Number / 100) * 60);
|
} break;
|
} break;
|
case 14:{
|
case 14:{
|
TclDateTimezone = TclDatepvt[-1].Number;
|
TclDateTimezone = TclDatepvt[-1].Number;
|
TclDateDSTmode = DSTon;
|
TclDateDSTmode = DSTon;
|
} break;
|
} break;
|
case 15:{
|
case 15:{
|
TclDateTimezone = TclDatepvt[-0].Number;
|
TclDateTimezone = TclDatepvt[-0].Number;
|
TclDateDSTmode = DSToff;
|
TclDateDSTmode = DSToff;
|
} break;
|
} break;
|
case 16:{
|
case 16:{
|
TclDateTimezone = TclDatepvt[-0].Number;
|
TclDateTimezone = TclDatepvt[-0].Number;
|
TclDateDSTmode = DSTon;
|
TclDateDSTmode = DSTon;
|
} break;
|
} break;
|
case 17:{
|
case 17:{
|
TclDateDayOrdinal = 1;
|
TclDateDayOrdinal = 1;
|
TclDateDayNumber = TclDatepvt[-0].Number;
|
TclDateDayNumber = TclDatepvt[-0].Number;
|
} break;
|
} break;
|
case 18:{
|
case 18:{
|
TclDateDayOrdinal = 1;
|
TclDateDayOrdinal = 1;
|
TclDateDayNumber = TclDatepvt[-1].Number;
|
TclDateDayNumber = TclDatepvt[-1].Number;
|
} break;
|
} break;
|
case 19:{
|
case 19:{
|
TclDateDayOrdinal = TclDatepvt[-1].Number;
|
TclDateDayOrdinal = TclDatepvt[-1].Number;
|
TclDateDayNumber = TclDatepvt[-0].Number;
|
TclDateDayNumber = TclDatepvt[-0].Number;
|
} break;
|
} break;
|
case 20:{
|
case 20:{
|
TclDateMonth = TclDatepvt[-2].Number;
|
TclDateMonth = TclDatepvt[-2].Number;
|
TclDateDay = TclDatepvt[-0].Number;
|
TclDateDay = TclDatepvt[-0].Number;
|
} break;
|
} break;
|
case 21:{
|
case 21:{
|
TclDateMonth = TclDatepvt[-4].Number;
|
TclDateMonth = TclDatepvt[-4].Number;
|
TclDateDay = TclDatepvt[-2].Number;
|
TclDateDay = TclDatepvt[-2].Number;
|
TclDateYear = TclDatepvt[-0].Number;
|
TclDateYear = TclDatepvt[-0].Number;
|
} break;
|
} break;
|
case 22:{
|
case 22:{
|
TclDateMonth = TclDatepvt[-1].Number;
|
TclDateMonth = TclDatepvt[-1].Number;
|
TclDateDay = TclDatepvt[-0].Number;
|
TclDateDay = TclDatepvt[-0].Number;
|
} break;
|
} break;
|
case 23:{
|
case 23:{
|
TclDateMonth = TclDatepvt[-3].Number;
|
TclDateMonth = TclDatepvt[-3].Number;
|
TclDateDay = TclDatepvt[-2].Number;
|
TclDateDay = TclDatepvt[-2].Number;
|
TclDateYear = TclDatepvt[-0].Number;
|
TclDateYear = TclDatepvt[-0].Number;
|
} break;
|
} break;
|
case 24:{
|
case 24:{
|
TclDateMonth = TclDatepvt[-0].Number;
|
TclDateMonth = TclDatepvt[-0].Number;
|
TclDateDay = TclDatepvt[-1].Number;
|
TclDateDay = TclDatepvt[-1].Number;
|
} break;
|
} break;
|
case 25:{
|
case 25:{
|
TclDateMonth = 1;
|
TclDateMonth = 1;
|
TclDateDay = 1;
|
TclDateDay = 1;
|
TclDateYear = EPOCH;
|
TclDateYear = EPOCH;
|
} break;
|
} break;
|
case 26:{
|
case 26:{
|
TclDateMonth = TclDatepvt[-1].Number;
|
TclDateMonth = TclDatepvt[-1].Number;
|
TclDateDay = TclDatepvt[-2].Number;
|
TclDateDay = TclDatepvt[-2].Number;
|
TclDateYear = TclDatepvt[-0].Number;
|
TclDateYear = TclDatepvt[-0].Number;
|
} break;
|
} break;
|
case 27:{
|
case 27:{
|
TclDateRelSeconds = -TclDateRelSeconds;
|
TclDateRelSeconds = -TclDateRelSeconds;
|
TclDateRelMonth = -TclDateRelMonth;
|
TclDateRelMonth = -TclDateRelMonth;
|
} break;
|
} break;
|
case 29:{
|
case 29:{
|
TclDateRelSeconds += TclDatepvt[-1].Number * TclDatepvt[-0].Number * 60L;
|
TclDateRelSeconds += TclDatepvt[-1].Number * TclDatepvt[-0].Number * 60L;
|
} break;
|
} break;
|
case 30:{
|
case 30:{
|
TclDateRelSeconds += TclDatepvt[-1].Number * TclDatepvt[-0].Number * 60L;
|
TclDateRelSeconds += TclDatepvt[-1].Number * TclDatepvt[-0].Number * 60L;
|
} break;
|
} break;
|
case 31:{
|
case 31:{
|
TclDateRelSeconds += TclDatepvt[-0].Number * 60L;
|
TclDateRelSeconds += TclDatepvt[-0].Number * 60L;
|
} break;
|
} break;
|
case 32:{
|
case 32:{
|
TclDateRelSeconds += TclDatepvt[-1].Number;
|
TclDateRelSeconds += TclDatepvt[-1].Number;
|
} break;
|
} break;
|
case 33:{
|
case 33:{
|
TclDateRelSeconds += TclDatepvt[-1].Number;
|
TclDateRelSeconds += TclDatepvt[-1].Number;
|
} break;
|
} break;
|
case 34:{
|
case 34:{
|
TclDateRelSeconds++;
|
TclDateRelSeconds++;
|
} break;
|
} break;
|
case 35:{
|
case 35:{
|
TclDateRelMonth += TclDatepvt[-1].Number * TclDatepvt[-0].Number;
|
TclDateRelMonth += TclDatepvt[-1].Number * TclDatepvt[-0].Number;
|
} break;
|
} break;
|
case 36:{
|
case 36:{
|
TclDateRelMonth += TclDatepvt[-1].Number * TclDatepvt[-0].Number;
|
TclDateRelMonth += TclDatepvt[-1].Number * TclDatepvt[-0].Number;
|
} break;
|
} break;
|
case 37:{
|
case 37:{
|
TclDateRelMonth += TclDatepvt[-0].Number;
|
TclDateRelMonth += TclDatepvt[-0].Number;
|
} break;
|
} break;
|
case 38:{
|
case 38:{
|
if (TclDateHaveTime && TclDateHaveDate && !TclDateHaveRel) {
|
if (TclDateHaveTime && TclDateHaveDate && !TclDateHaveRel) {
|
TclDateYear = TclDatepvt[-0].Number;
|
TclDateYear = TclDatepvt[-0].Number;
|
} else {
|
} else {
|
TclDateHaveTime++;
|
TclDateHaveTime++;
|
if (TclDatepvt[-0].Number < 100) {
|
if (TclDatepvt[-0].Number < 100) {
|
TclDateHour = 0;
|
TclDateHour = 0;
|
TclDateMinutes = TclDatepvt[-0].Number;
|
TclDateMinutes = TclDatepvt[-0].Number;
|
} else {
|
} else {
|
TclDateHour = TclDatepvt[-0].Number / 100;
|
TclDateHour = TclDatepvt[-0].Number / 100;
|
TclDateMinutes = TclDatepvt[-0].Number % 100;
|
TclDateMinutes = TclDatepvt[-0].Number % 100;
|
}
|
}
|
TclDateSeconds = 0;
|
TclDateSeconds = 0;
|
TclDateMeridian = MER24;
|
TclDateMeridian = MER24;
|
}
|
}
|
} break;
|
} break;
|
case 39:{
|
case 39:{
|
TclDateval.Meridian = MER24;
|
TclDateval.Meridian = MER24;
|
} break;
|
} break;
|
case 40:{
|
case 40:{
|
TclDateval.Meridian = TclDatepvt[-0].Meridian;
|
TclDateval.Meridian = TclDatepvt[-0].Meridian;
|
} break;
|
} break;
|
}
|
}
|
goto TclDatestack; /* reset registers in driver code */
|
goto TclDatestack; /* reset registers in driver code */
|
}
|
}
|
|
|
|
|
