Context Navigation

tclGetDate.y @ 42

Last change on this file since 42 was 25, checked in by landauf, 18 years ago
added tcl to libs
File size: 25.1 KB

Rev	Line
[25]	1	/*
	2	* tclGetDate.y --
	3	*
	4	* Contains yacc grammar for parsing date and time strings. The output of
	5	* this file should be the file tclDate.c which is used directly in the
	6	* Tcl sources. Note that this file is largely obsolete in Tcl 8.5; it is
	7	* only used when doing free-form date parsing, an ill-defined process
	8	* anyway.
	9	*
	10	* Copyright (c) 1992-1995 Karl Lehenbauer and Mark Diekhans.
	11	* Copyright (c) 1995-1997 Sun Microsystems, Inc.
	12	*
	13	* See the file "license.terms" for information on usage and redistribution of
	14	* this file, and for a DISCLAIMER OF ALL WARRANTIES.
	15	*
	16	* RCS: @(#) $Id: tclGetDate.y,v 1.38 2007/12/13 15:23:17 dgp Exp $
	17	*/
	18
	19	%{
	20	/*
	21	* tclDate.c --
	22	*
	23	* This file is generated from a yacc grammar defined in the file
	24	* tclGetDate.y. It should not be edited directly.
	25	*
	26	* Copyright (c) 1992-1995 Karl Lehenbauer and Mark Diekhans.
	27	* Copyright (c) 1995-1997 Sun Microsystems, Inc.
	28	*
	29	* See the file "license.terms" for information on usage and redistribution of
	30	* this file, and for a DISCLAIMER OF ALL WARRANTIES.
	31	*
	32	*/
	33
	34	#include "tclInt.h"
	35
	36	/*
	37	* Bison generates several labels that happen to be unused. MS Visual C++
	38	* doesn't like that, and complains. Tell it to shut up.
	39	*/
	40
	41	#ifdef _MSC_VER
	42	#pragma warning( disable : 4102 )
	43	#endif /* _MSC_VER */
	44
	45	/*
	46	* yyparse will accept a 'struct DateInfo' as its parameter; that's where the
	47	* parsed fields will be returned.
	48	*/
	49
	50	typedef struct DateInfo {
	51	time_t dateYear;
	52	time_t dateMonth;
	53	time_t dateDay;
	54	int dateHaveDate;
	55
	56	time_t dateHour;
	57	time_t dateMinutes;
	58	time_t dateSeconds;
	59	int dateMeridian;
	60	int dateHaveTime;
	61
	62	time_t dateTimezone;
	63	int dateDSTmode;
	64	int dateHaveZone;
	65
	66	time_t dateRelMonth;
	67	time_t dateRelDay;
	68	time_t dateRelSeconds;
	69	int dateHaveRel;
	70
	71	time_t dateMonthOrdinal;
	72	int dateHaveOrdinalMonth;
	73
	74	time_t dateDayOrdinal;
	75	time_t dateDayNumber;
	76	int dateHaveDay;
	77
	78	char *dateInput;
	79	time_t *dateRelPointer;
	80
	81	int dateDigitCount;
	82	} DateInfo;
	83
	84	#define YYPARSE_PARAM info
	85	#define YYLEX_PARAM info
	86
	87	#define YYMALLOC ckalloc
	88	#define YYFREE(x) (ckfree((void*) (x)))
	89
	90	#define yyDSTmode (((DateInfo *) info)->dateDSTmode)
	91	#define yyDayOrdinal (((DateInfo *) info)->dateDayOrdinal)
	92	#define yyDayNumber (((DateInfo *) info)->dateDayNumber)
	93	#define yyMonthOrdinal (((DateInfo *) info)->dateMonthOrdinal)
	94	#define yyHaveDate (((DateInfo *) info)->dateHaveDate)
	95	#define yyHaveDay (((DateInfo *) info)->dateHaveDay)
	96	#define yyHaveOrdinalMonth (((DateInfo *) info)->dateHaveOrdinalMonth)
	97	#define yyHaveRel (((DateInfo *) info)->dateHaveRel)
	98	#define yyHaveTime (((DateInfo *) info)->dateHaveTime)
	99	#define yyHaveZone (((DateInfo *) info)->dateHaveZone)
	100	#define yyTimezone (((DateInfo *) info)->dateTimezone)
	101	#define yyDay (((DateInfo *) info)->dateDay)
	102	#define yyMonth (((DateInfo *) info)->dateMonth)
	103	#define yyYear (((DateInfo *) info)->dateYear)
	104	#define yyHour (((DateInfo *) info)->dateHour)
	105	#define yyMinutes (((DateInfo *) info)->dateMinutes)
	106	#define yySeconds (((DateInfo *) info)->dateSeconds)
	107	#define yyMeridian (((DateInfo *) info)->dateMeridian)
	108	#define yyRelMonth (((DateInfo *) info)->dateRelMonth)
	109	#define yyRelDay (((DateInfo *) info)->dateRelDay)
	110	#define yyRelSeconds (((DateInfo *) info)->dateRelSeconds)
	111	#define yyRelPointer (((DateInfo *) info)->dateRelPointer)
	112	#define yyInput (((DateInfo *) info)->dateInput)
	113	#define yyDigitCount (((DateInfo *) info)->dateDigitCount)
	114
	115	#define EPOCH 1970
	116	#define START_OF_TIME 1902
	117	#define END_OF_TIME 2037
	118
	119	/*
	120	* The offset of tm_year of struct tm returned by localtime, gmtime, etc.
	121	* Posix requires 1900.
	122	*/
	123
	124	#define TM_YEAR_BASE 1900
	125
	126	#define HOUR(x) ((int) (60 * x))
	127	#define SECSPERDAY (24L * 60L * 60L)
	128	#define IsLeapYear(x) ((x % 4 == 0) && (x % 100 != 0 \|\| x % 400 == 0))
	129
	130	/*
	131	* An entry in the lexical lookup table.
	132	*/
	133
	134	typedef struct _TABLE {
	135	char *name;
	136	int type;
	137	time_t value;
	138	} TABLE;
	139
	140	/*
	141	* Daylight-savings mode: on, off, or not yet known.
	142	*/
	143
	144	typedef enum _DSTMODE {
	145	DSTon, DSToff, DSTmaybe
	146	} DSTMODE;
	147
	148	/*
	149	* Meridian: am, pm, or 24-hour style.
	150	*/
	151
	152	typedef enum _MERIDIAN {
	153	MERam, MERpm, MER24
	154	} MERIDIAN;
	155
	156	/*
	157	* Prototypes of internal functions.
	158	*/
	159
	160	static int LookupWord(char *buff);
	161	static void TclDateerror(char *s);
	162	static int TclDatelex(void *info);
	163	static time_t ToSeconds(time_t Hours, time_t Minutes,
	164	time_t Seconds, MERIDIAN Meridian);
	165	MODULE_SCOPE int yyparse(void *);
	166
	167	%}
	168
	169	%union {
	170	time_t Number;
	171	enum _MERIDIAN Meridian;
	172	}
	173
	174	%token tAGO tDAY tDAYZONE tID tMERIDIAN tMINUTE_UNIT tMONTH tMONTH_UNIT
	175	%token tSTARDATE tSEC_UNIT tSNUMBER tUNUMBER tZONE tEPOCH tDST tISOBASE
	176	%token tDAY_UNIT tNEXT
	177
	178	%type <Number> tDAY tDAYZONE tMINUTE_UNIT tMONTH tMONTH_UNIT tDST
	179	%type <Number> tSEC_UNIT tSNUMBER tUNUMBER tZONE tISOBASE tDAY_UNIT
	180	%type <Number> unit sign tNEXT tSTARDATE
	181	%type <Meridian> tMERIDIAN o_merid
	182
	183	%%
	184
	185	spec : /* NULL */
	186	\| spec item
	187	;
	188
	189	item : time {
	190	yyHaveTime++;
	191	}
	192	\| zone {
	193	yyHaveZone++;
	194	}
	195	\| date {
	196	yyHaveDate++;
	197	}
	198	\| ordMonth {
	199	yyHaveOrdinalMonth++;
	200	}
	201	\| day {
	202	yyHaveDay++;
	203	}
	204	\| relspec {
	205	yyHaveRel++;
	206	}
	207	\| iso {
	208	yyHaveTime++;
	209	yyHaveDate++;
	210	}
	211	\| trek {
	212	yyHaveTime++;
	213	yyHaveDate++;
	214	yyHaveRel++;
	215	}
	216	\| number
	217	;
	218
	219	time : tUNUMBER tMERIDIAN {
	220	yyHour = $1;
	221	yyMinutes = 0;
	222	yySeconds = 0;
	223	yyMeridian = $2;
	224	}
	225	\| tUNUMBER ':' tUNUMBER o_merid {
	226	yyHour = $1;
	227	yyMinutes = $3;
	228	yySeconds = 0;
	229	yyMeridian = $4;
	230	}
	231	\| tUNUMBER ':' tUNUMBER '-' tUNUMBER {
	232	yyHour = $1;
	233	yyMinutes = $3;
	234	yyMeridian = MER24;
	235	yyDSTmode = DSToff;
	236	yyTimezone = ($5 % 100 + ($5 / 100) * 60);
	237	++yyHaveZone;
	238	}
	239	\| tUNUMBER ':' tUNUMBER ':' tUNUMBER o_merid {
	240	yyHour = $1;
	241	yyMinutes = $3;
	242	yySeconds = $5;
	243	yyMeridian = $6;
	244	}
	245	\| tUNUMBER ':' tUNUMBER ':' tUNUMBER '-' tUNUMBER {
	246	yyHour = $1;
	247	yyMinutes = $3;
	248	yySeconds = $5;
	249	yyMeridian = MER24;
	250	yyDSTmode = DSToff;
	251	yyTimezone = ($7 % 100 + ($7 / 100) * 60);
	252	++yyHaveZone;
	253	}
	254	;
	255
	256	zone : tZONE tDST {
	257	yyTimezone = $1;
	258	yyDSTmode = DSTon;
	259	}
	260	\| tZONE {
	261	yyTimezone = $1;
	262	yyDSTmode = DSToff;
	263	}
	264	\| tDAYZONE {
	265	yyTimezone = $1;
	266	yyDSTmode = DSTon;
	267	}
	268	;
	269
	270	day : tDAY {
	271	yyDayOrdinal = 1;
	272	yyDayNumber = $1;
	273	}
	274	\| tDAY ',' {
	275	yyDayOrdinal = 1;
	276	yyDayNumber = $1;
	277	}
	278	\| tUNUMBER tDAY {
	279	yyDayOrdinal = $1;
	280	yyDayNumber = $2;
	281	}
	282	\| sign tUNUMBER tDAY {
	283	yyDayOrdinal = $1 * $2;
	284	yyDayNumber = $3;
	285	}
	286	\| tNEXT tDAY {
	287	yyDayOrdinal = 2;
	288	yyDayNumber = $2;
	289	}
	290	;
	291
	292	date : tUNUMBER '/' tUNUMBER {
	293	yyMonth = $1;
	294	yyDay = $3;
	295	}
	296	\| tUNUMBER '/' tUNUMBER '/' tUNUMBER {
	297	yyMonth = $1;
	298	yyDay = $3;
	299	yyYear = $5;
	300	}
	301	\| tISOBASE {
	302	yyYear = $1 / 10000;
	303	yyMonth = ($1 % 10000)/100;
	304	yyDay = $1 % 100;
	305	}
	306	\| tUNUMBER '-' tMONTH '-' tUNUMBER {
	307	yyDay = $1;
	308	yyMonth = $3;
	309	yyYear = $5;
	310	}
	311	\| tUNUMBER '-' tUNUMBER '-' tUNUMBER {
	312	yyMonth = $3;
	313	yyDay = $5;
	314	yyYear = $1;
	315	}
	316	\| tMONTH tUNUMBER {
	317	yyMonth = $1;
	318	yyDay = $2;
	319	}
	320	\| tMONTH tUNUMBER ',' tUNUMBER {
	321	yyMonth = $1;
	322	yyDay = $2;
	323	yyYear = $4;
	324	}
	325	\| tUNUMBER tMONTH {
	326	yyMonth = $2;
	327	yyDay = $1;
	328	}
	329	\| tEPOCH {
	330	yyMonth = 1;
	331	yyDay = 1;
	332	yyYear = EPOCH;
	333	}
	334	\| tUNUMBER tMONTH tUNUMBER {
	335	yyMonth = $2;
	336	yyDay = $1;
	337	yyYear = $3;
	338	}
	339	;
	340
	341	ordMonth: tNEXT tMONTH {
	342	yyMonthOrdinal = 1;
	343	yyMonth = $2;
	344	}
	345	\| tNEXT tUNUMBER tMONTH {
	346	yyMonthOrdinal = $2;
	347	yyMonth = $3;
	348	}
	349	;
	350
	351	iso : tISOBASE tZONE tISOBASE {
	352	if ($2 != HOUR( 7)) YYABORT;
	353	yyYear = $1 / 10000;
	354	yyMonth = ($1 % 10000)/100;
	355	yyDay = $1 % 100;
	356	yyHour = $3 / 10000;
	357	yyMinutes = ($3 % 10000)/100;
	358	yySeconds = $3 % 100;
	359	}
	360	\| tISOBASE tZONE tUNUMBER ':' tUNUMBER ':' tUNUMBER {
	361	if ($2 != HOUR( 7)) YYABORT;
	362	yyYear = $1 / 10000;
	363	yyMonth = ($1 % 10000)/100;
	364	yyDay = $1 % 100;
	365	yyHour = $3;
	366	yyMinutes = $5;
	367	yySeconds = $7;
	368	}
	369	\| tISOBASE tISOBASE {
	370	yyYear = $1 / 10000;
	371	yyMonth = ($1 % 10000)/100;
	372	yyDay = $1 % 100;
	373	yyHour = $2 / 10000;
	374	yyMinutes = ($2 % 10000)/100;
	375	yySeconds = $2 % 100;
	376	}
	377	;
	378
	379	trek : tSTARDATE tUNUMBER '.' tUNUMBER {
	380	/*
	381	* Offset computed year by -377 so that the returned years will be
	382	* in a range accessible with a 32 bit clock seconds value.
	383	*/
	384
	385	yyYear = $2/1000 + 2323 - 377;
	386	yyDay = 1;
	387	yyMonth = 1;
	388	yyRelDay += (($2%1000)*(365 + IsLeapYear(yyYear)))/1000;
	389	yyRelSeconds += $4 * 144 * 60;
	390	}
	391	;
	392
	393	relspec : relunits tAGO {
	394	yyRelSeconds *= -1;
	395	yyRelMonth *= -1;
	396	yyRelDay *= -1;
	397	}
	398	\| relunits
	399	;
	400
	401	relunits : sign tUNUMBER unit {
	402	yyRelPointer += $1 $2 * $3;
	403	}
	404	\| tUNUMBER unit {
	405	yyRelPointer += $1 $2;
	406	}
	407	\| tNEXT unit {
	408	*yyRelPointer += $2;
	409	}
	410	\| tNEXT tUNUMBER unit {
	411	yyRelPointer += $2 $3;
	412	}
	413	\| unit {
	414	*yyRelPointer += $1;
	415	}
	416	;
	417
	418	sign : '-' {
	419	$$ = -1;
	420	}
	421	\| '+' {
	422	$$ = 1;
	423	}
	424	;
	425
	426	unit : tSEC_UNIT {
	427	$$ = $1;
	428	yyRelPointer = &yyRelSeconds;
	429	}
	430	\| tDAY_UNIT {
	431	$$ = $1;
	432	yyRelPointer = &yyRelDay;
	433	}
	434	\| tMONTH_UNIT {
	435	$$ = $1;
	436	yyRelPointer = &yyRelMonth;
	437	}
	438	;
	439
	440	number : tUNUMBER {
	441	if (yyHaveTime && yyHaveDate && !yyHaveRel) {
	442	yyYear = $1;
	443	} else {
	444	yyHaveTime++;
	445	if (yyDigitCount <= 2) {
	446	yyHour = $1;
	447	yyMinutes = 0;
	448	} else {
	449	yyHour = $1 / 100;
	450	yyMinutes = $1 % 100;
	451	}
	452	yySeconds = 0;
	453	yyMeridian = MER24;
	454	}
	455	}
	456	;
	457
	458	o_merid : /* NULL */ {
	459	$$ = MER24;
	460	}
	461	\| tMERIDIAN {
	462	$$ = $1;
	463	}
	464	;
	465
	466	%%
	467	MODULE_SCOPE int yychar;
	468	MODULE_SCOPE YYSTYPE yylval;
	469	MODULE_SCOPE int yynerrs;
	470
	471	/*
	472	* Month and day table.
	473	*/
	474
	475	static TABLE MonthDayTable[] = {
	476	{ "january", tMONTH, 1 },
	477	{ "february", tMONTH, 2 },
	478	{ "march", tMONTH, 3 },
	479	{ "april", tMONTH, 4 },
	480	{ "may", tMONTH, 5 },
	481	{ "june", tMONTH, 6 },
	482	{ "july", tMONTH, 7 },
	483	{ "august", tMONTH, 8 },
	484	{ "september", tMONTH, 9 },
	485	{ "sept", tMONTH, 9 },
	486	{ "october", tMONTH, 10 },
	487	{ "november", tMONTH, 11 },
	488	{ "december", tMONTH, 12 },
	489	{ "sunday", tDAY, 0 },
	490	{ "monday", tDAY, 1 },
	491	{ "tuesday", tDAY, 2 },
	492	{ "tues", tDAY, 2 },
	493	{ "wednesday", tDAY, 3 },
	494	{ "wednes", tDAY, 3 },
	495	{ "thursday", tDAY, 4 },
	496	{ "thur", tDAY, 4 },
	497	{ "thurs", tDAY, 4 },
	498	{ "friday", tDAY, 5 },
	499	{ "saturday", tDAY, 6 },
	500	{ NULL }
	501	};
	502
	503	/*
	504	* Time units table.
	505	*/
	506
	507	static TABLE UnitsTable[] = {
	508	{ "year", tMONTH_UNIT, 12 },
	509	{ "month", tMONTH_UNIT, 1 },
	510	{ "fortnight", tDAY_UNIT, 14 },
	511	{ "week", tDAY_UNIT, 7 },
	512	{ "day", tDAY_UNIT, 1 },
	513	{ "hour", tSEC_UNIT, 60 * 60 },
	514	{ "minute", tSEC_UNIT, 60 },
	515	{ "min", tSEC_UNIT, 60 },
	516	{ "second", tSEC_UNIT, 1 },
	517	{ "sec", tSEC_UNIT, 1 },
	518	{ NULL }
	519	};
	520
	521	/*
	522	* Assorted relative-time words.
	523	*/
	524
	525	static TABLE OtherTable[] = {
	526	{ "tomorrow", tDAY_UNIT, 1 },
	527	{ "yesterday", tDAY_UNIT, -1 },
	528	{ "today", tDAY_UNIT, 0 },
	529	{ "now", tSEC_UNIT, 0 },
	530	{ "last", tUNUMBER, -1 },
	531	{ "this", tSEC_UNIT, 0 },
	532	{ "next", tNEXT, 1 },
	533	#if 0
	534	{ "first", tUNUMBER, 1 },
	535	{ "second", tUNUMBER, 2 },
	536	{ "third", tUNUMBER, 3 },
	537	{ "fourth", tUNUMBER, 4 },
	538	{ "fifth", tUNUMBER, 5 },
	539	{ "sixth", tUNUMBER, 6 },
	540	{ "seventh", tUNUMBER, 7 },
	541	{ "eighth", tUNUMBER, 8 },
	542	{ "ninth", tUNUMBER, 9 },
	543	{ "tenth", tUNUMBER, 10 },
	544	{ "eleventh", tUNUMBER, 11 },
	545	{ "twelfth", tUNUMBER, 12 },
	546	#endif
	547	{ "ago", tAGO, 1 },
	548	{ "epoch", tEPOCH, 0 },
	549	{ "stardate", tSTARDATE, 0 },
	550	{ NULL }
	551	};
	552
	553	/*
	554	* The timezone table. (Note: This table was modified to not use any floating
	555	* point constants to work around an SGI compiler bug).
	556	*/
	557
	558	static TABLE TimezoneTable[] = {
	559	{ "gmt", tZONE, HOUR( 0) }, /* Greenwich Mean */
	560	{ "ut", tZONE, HOUR( 0) }, /* Universal (Coordinated) */
	561	{ "utc", tZONE, HOUR( 0) },
	562	{ "uct", tZONE, HOUR( 0) }, /* Universal Coordinated Time */
	563	{ "wet", tZONE, HOUR( 0) }, /* Western European */
	564	{ "bst", tDAYZONE, HOUR( 0) }, /* British Summer */
	565	{ "wat", tZONE, HOUR( 1) }, /* West Africa */
	566	{ "at", tZONE, HOUR( 2) }, /* Azores */
	567	#if 0
	568	/* For completeness. BST is also British Summer, and GST is
	569	* also Guam Standard. */
	570	{ "bst", tZONE, HOUR( 3) }, /* Brazil Standard */
	571	{ "gst", tZONE, HOUR( 3) }, /* Greenland Standard */
	572	#endif
	573	{ "nft", tZONE, HOUR( 7/2) }, /* Newfoundland */
	574	{ "nst", tZONE, HOUR( 7/2) }, /* Newfoundland Standard */
	575	{ "ndt", tDAYZONE, HOUR( 7/2) }, /* Newfoundland Daylight */
	576	{ "ast", tZONE, HOUR( 4) }, /* Atlantic Standard */
	577	{ "adt", tDAYZONE, HOUR( 4) }, /* Atlantic Daylight */
	578	{ "est", tZONE, HOUR( 5) }, /* Eastern Standard */
	579	{ "edt", tDAYZONE, HOUR( 5) }, /* Eastern Daylight */
	580	{ "cst", tZONE, HOUR( 6) }, /* Central Standard */
	581	{ "cdt", tDAYZONE, HOUR( 6) }, /* Central Daylight */
	582	{ "mst", tZONE, HOUR( 7) }, /* Mountain Standard */
	583	{ "mdt", tDAYZONE, HOUR( 7) }, /* Mountain Daylight */
	584	{ "pst", tZONE, HOUR( 8) }, /* Pacific Standard */
	585	{ "pdt", tDAYZONE, HOUR( 8) }, /* Pacific Daylight */
	586	{ "yst", tZONE, HOUR( 9) }, /* Yukon Standard */
	587	{ "ydt", tDAYZONE, HOUR( 9) }, /* Yukon Daylight */
	588	{ "hst", tZONE, HOUR(10) }, /* Hawaii Standard */
	589	{ "hdt", tDAYZONE, HOUR(10) }, /* Hawaii Daylight */
	590	{ "cat", tZONE, HOUR(10) }, /* Central Alaska */
	591	{ "ahst", tZONE, HOUR(10) }, /* Alaska-Hawaii Standard */
	592	{ "nt", tZONE, HOUR(11) }, /* Nome */
	593	{ "idlw", tZONE, HOUR(12) }, /* International Date Line West */
	594	{ "cet", tZONE, -HOUR( 1) }, /* Central European */
	595	{ "cest", tDAYZONE, -HOUR( 1) }, /* Central European Summer */
	596	{ "met", tZONE, -HOUR( 1) }, /* Middle European */
	597	{ "mewt", tZONE, -HOUR( 1) }, /* Middle European Winter */
	598	{ "mest", tDAYZONE, -HOUR( 1) }, /* Middle European Summer */
	599	{ "swt", tZONE, -HOUR( 1) }, /* Swedish Winter */
	600	{ "sst", tDAYZONE, -HOUR( 1) }, /* Swedish Summer */
	601	{ "fwt", tZONE, -HOUR( 1) }, /* French Winter */
	602	{ "fst", tDAYZONE, -HOUR( 1) }, /* French Summer */
	603	{ "eet", tZONE, -HOUR( 2) }, /* Eastern Europe, USSR Zone 1 */
	604	{ "bt", tZONE, -HOUR( 3) }, /* Baghdad, USSR Zone 2 */
	605	{ "it", tZONE, -HOUR( 7/2) }, /* Iran */
	606	{ "zp4", tZONE, -HOUR( 4) }, /* USSR Zone 3 */
	607	{ "zp5", tZONE, -HOUR( 5) }, /* USSR Zone 4 */
	608	{ "ist", tZONE, -HOUR(11/2) }, /* Indian Standard */
	609	{ "zp6", tZONE, -HOUR( 6) }, /* USSR Zone 5 */
	610	#if 0
	611	/* For completeness. NST is also Newfoundland Stanard, nad SST is
	612	* also Swedish Summer. */
	613	{ "nst", tZONE, -HOUR(13/2) }, /* North Sumatra */
	614	{ "sst", tZONE, -HOUR( 7) }, /* South Sumatra, USSR Zone 6 */
	615	#endif /* 0 */
	616	{ "wast", tZONE, -HOUR( 7) }, /* West Australian Standard */
	617	{ "wadt", tDAYZONE, -HOUR( 7) }, /* West Australian Daylight */
	618	{ "jt", tZONE, -HOUR(15/2) }, /* Java (3pm in Cronusland!) */
	619	{ "cct", tZONE, -HOUR( 8) }, /* China Coast, USSR Zone 7 */
	620	{ "jst", tZONE, -HOUR( 9) }, /* Japan Standard, USSR Zone 8 */
	621	{ "jdt", tDAYZONE, -HOUR( 9) }, /* Japan Daylight */
	622	{ "kst", tZONE, -HOUR( 9) }, /* Korea Standard */
	623	{ "kdt", tDAYZONE, -HOUR( 9) }, /* Korea Daylight */
	624	{ "cast", tZONE, -HOUR(19/2) }, /* Central Australian Standard */
	625	{ "cadt", tDAYZONE, -HOUR(19/2) }, /* Central Australian Daylight */
	626	{ "east", tZONE, -HOUR(10) }, /* Eastern Australian Standard */
	627	{ "eadt", tDAYZONE, -HOUR(10) }, /* Eastern Australian Daylight */
	628	{ "gst", tZONE, -HOUR(10) }, /* Guam Standard, USSR Zone 9 */
	629	{ "nzt", tZONE, -HOUR(12) }, /* New Zealand */
	630	{ "nzst", tZONE, -HOUR(12) }, /* New Zealand Standard */
	631	{ "nzdt", tDAYZONE, -HOUR(12) }, /* New Zealand Daylight */
	632	{ "idle", tZONE, -HOUR(12) }, /* International Date Line East */
	633	/* ADDED BY Marco Nijdam */
	634	{ "dst", tDST, HOUR( 0) }, /* DST on (hour is ignored) */
	635	/* End ADDED */
	636	{ NULL }
	637	};
	638
	639	/*
	640	* Military timezone table.
	641	*/
	642
	643	static TABLE MilitaryTable[] = {
	644	{ "a", tZONE, -HOUR( 1) },
	645	{ "b", tZONE, -HOUR( 2) },
	646	{ "c", tZONE, -HOUR( 3) },
	647	{ "d", tZONE, -HOUR( 4) },
	648	{ "e", tZONE, -HOUR( 5) },
	649	{ "f", tZONE, -HOUR( 6) },
	650	{ "g", tZONE, -HOUR( 7) },
	651	{ "h", tZONE, -HOUR( 8) },
	652	{ "i", tZONE, -HOUR( 9) },
	653	{ "k", tZONE, -HOUR(10) },
	654	{ "l", tZONE, -HOUR(11) },
	655	{ "m", tZONE, -HOUR(12) },
	656	{ "n", tZONE, HOUR( 1) },
	657	{ "o", tZONE, HOUR( 2) },
	658	{ "p", tZONE, HOUR( 3) },
	659	{ "q", tZONE, HOUR( 4) },
	660	{ "r", tZONE, HOUR( 5) },
	661	{ "s", tZONE, HOUR( 6) },
	662	{ "t", tZONE, HOUR( 7) },
	663	{ "u", tZONE, HOUR( 8) },
	664	{ "v", tZONE, HOUR( 9) },
	665	{ "w", tZONE, HOUR( 10) },
	666	{ "x", tZONE, HOUR( 11) },
	667	{ "y", tZONE, HOUR( 12) },
	668	{ "z", tZONE, HOUR( 0) },
	669	{ NULL }
	670	};
	671
	672	/*
	673	* Dump error messages in the bit bucket.
	674	*/
	675
	676	static void
	677	TclDateerror(
	678	char *s)
	679	{
	680	}
	681
	682	static time_t
	683	ToSeconds(
	684	time_t Hours,
	685	time_t Minutes,
	686	time_t Seconds,
	687	MERIDIAN Meridian)
	688	{
	689	if (Minutes < 0 \|\| Minutes > 59 \|\| Seconds < 0 \|\| Seconds > 59) {
	690	return -1;
	691	}
	692	switch (Meridian) {
	693	case MER24:
	694	if (Hours < 0 \|\| Hours > 23) {
	695	return -1;
	696	}
	697	return (Hours * 60L + Minutes) * 60L + Seconds;
	698	case MERam:
	699	if (Hours < 1 \|\| Hours > 12) {
	700	return -1;
	701	}
	702	return ((Hours % 12) * 60L + Minutes) * 60L + Seconds;
	703	case MERpm:
	704	if (Hours < 1 \|\| Hours > 12) {
	705	return -1;
	706	}
	707	return (((Hours % 12) + 12) * 60L + Minutes) * 60L + Seconds;
	708	}
	709	return -1; /* Should never be reached */
	710	}
	711
	712	static int
	713	LookupWord(
	714	char *buff)
	715	{
	716	register char *p;
	717	register char *q;
	718	register TABLE *tp;
	719	int i, abbrev;
	720
	721	/*
	722	* Make it lowercase.
	723	*/
	724
	725	Tcl_UtfToLower(buff);
	726
	727	if (strcmp(buff, "am") == 0 \|\| strcmp(buff, "a.m.") == 0) {
	728	yylval.Meridian = MERam;
	729	return tMERIDIAN;
	730	}
	731	if (strcmp(buff, "pm") == 0 \|\| strcmp(buff, "p.m.") == 0) {
	732	yylval.Meridian = MERpm;
	733	return tMERIDIAN;
	734	}
	735
	736	/*
	737	* See if we have an abbreviation for a month.
	738	*/
	739
	740	if (strlen(buff) == 3) {
	741	abbrev = 1;
	742	} else if (strlen(buff) == 4 && buff[3] == '.') {
	743	abbrev = 1;
	744	buff[3] = '\0';
	745	} else {
	746	abbrev = 0;
	747	}
	748
	749	for (tp = MonthDayTable; tp->name; tp++) {
	750	if (abbrev) {
	751	if (strncmp(buff, tp->name, 3) == 0) {
	752	yylval.Number = tp->value;
	753	return tp->type;
	754	}
	755	} else if (strcmp(buff, tp->name) == 0) {
	756	yylval.Number = tp->value;
	757	return tp->type;
	758	}
	759	}
	760
	761	for (tp = TimezoneTable; tp->name; tp++) {
	762	if (strcmp(buff, tp->name) == 0) {
	763	yylval.Number = tp->value;
	764	return tp->type;
	765	}
	766	}
	767
	768	for (tp = UnitsTable; tp->name; tp++) {
	769	if (strcmp(buff, tp->name) == 0) {
	770	yylval.Number = tp->value;
	771	return tp->type;
	772	}
	773	}
	774
	775	/*
	776	* Strip off any plural and try the units table again.
	777	*/
	778
	779	i = strlen(buff) - 1;
	780	if (i > 0 && buff[i] == 's') {
	781	buff[i] = '\0';
	782	for (tp = UnitsTable; tp->name; tp++) {
	783	if (strcmp(buff, tp->name) == 0) {
	784	yylval.Number = tp->value;
	785	return tp->type;
	786	}
	787	}
	788	}
	789
	790	for (tp = OtherTable; tp->name; tp++) {
	791	if (strcmp(buff, tp->name) == 0) {
	792	yylval.Number = tp->value;
	793	return tp->type;
	794	}
	795	}
	796
	797	/*
	798	* Military timezones.
	799	*/
	800
	801	if (buff[1] == '\0' && !(*buff & 0x80)
	802	&& isalpha(UCHAR(buff))) { / INTL: ISO only */
	803	for (tp = MilitaryTable; tp->name; tp++) {
	804	if (strcmp(buff, tp->name) == 0) {
	805	yylval.Number = tp->value;
	806	return tp->type;
	807	}
	808	}
	809	}
	810
	811	/*
	812	* Drop out any periods and try the timezone table again.
	813	*/
	814
	815	for (i = 0, p = q = buff; *q; q++) {
	816	if (*q != '.') {
	817	p++ = q;
	818	} else {
	819	i++;
	820	}
	821	}
	822	*p = '\0';
	823	if (i) {
	824	for (tp = TimezoneTable; tp->name; tp++) {
	825	if (strcmp(buff, tp->name) == 0) {
	826	yylval.Number = tp->value;
	827	return tp->type;
	828	}
	829	}
	830	}
	831
	832	return tID;
	833	}
	834
	835	static int
	836	TclDatelex(
	837	void *info)
	838	{
	839	register char c;
	840	register char *p;
	841	char buff[20];
	842	int Count;
	843
	844	for ( ; ; ) {
	845	while (isspace(UCHAR(*yyInput))) {
	846	yyInput++;
	847	}
	848
	849	if (isdigit(UCHAR(c = yyInput))) { / INTL: digit */
	850	/*
	851	* Convert the string into a number; count the number of digits.
	852	*/
	853
	854	Count = 0;
	855	for (yylval.Number = 0;
	856	isdigit(UCHAR(c = yyInput++)); ) { / INTL: digit */
	857	yylval.Number = 10 * yylval.Number + c - '0';
	858	Count++;
	859	}
	860	yyInput--;
	861	yyDigitCount = Count;
	862
	863	/*
	864	* A number with 6 or more digits is considered an ISO 8601 base.
	865	*/
	866
	867	if (Count >= 6) {
	868	return tISOBASE;
	869	} else {
	870	return tUNUMBER;
	871	}
	872	}
	873	if (!(c & 0x80) && isalpha(UCHAR(c))) { /* INTL: ISO only. */
	874	for (p = buff; isalpha(UCHAR(c = yyInput++)) / INTL: ISO only. */
	875	\|\| c == '.'; ) {
	876	if (p < &buff[sizeof buff - 1]) {
	877	*p++ = c;
	878	}
	879	}
	880	*p = '\0';
	881	yyInput--;
	882	return LookupWord(buff);
	883	}
	884	if (c != '(') {
	885	return *yyInput++;
	886	}
	887	Count = 0;
	888	do {
	889	c = *yyInput++;
	890	if (c == '\0') {
	891	return c;
	892	} else if (c == '(') {
	893	Count++;
	894	} else if (c == ')') {
	895	Count--;
	896	}
	897	} while (Count > 0);
	898	}
	899	}
	900
	901	int
	902	TclClockOldscanObjCmd(
	903	ClientData clientData, /* Unused */
	904	Tcl_Interp interp, / Tcl interpreter */
	905	int objc, /* Count of paraneters */
	906	Tcl_Obj CONST objv) /* Parameters */
	907	{
	908	Tcl_Obj result, resultElement;
	909	int yr, mo, da;
	910	DateInfo dateInfo;
	911	void info = (void ) &dateInfo;
	912
	913	if (objc != 5) {
	914	Tcl_WrongNumArgs(interp, 1, objv,
	915	"stringToParse baseYear baseMonth baseDay" );
	916	return TCL_ERROR;
	917	}
	918
	919	yyInput = Tcl_GetString( objv[1] );
	920
	921	yyHaveDate = 0;
	922	if (Tcl_GetIntFromObj(interp, objv[2], &yr) != TCL_OK
	923	\|\| Tcl_GetIntFromObj(interp, objv[3], &mo) != TCL_OK
	924	\|\| Tcl_GetIntFromObj(interp, objv[4], &da) != TCL_OK) {
	925	return TCL_ERROR;
	926	}
	927	yyYear = yr; yyMonth = mo; yyDay = da;
	928
	929	yyHaveTime = 0;
	930	yyHour = 0; yyMinutes = 0; yySeconds = 0; yyMeridian = MER24;
	931
	932	yyHaveZone = 0;
	933	yyTimezone = 0; yyDSTmode = DSTmaybe;
	934
	935	yyHaveOrdinalMonth = 0;
	936	yyMonthOrdinal = 0;
	937
	938	yyHaveDay = 0;
	939	yyDayOrdinal = 0; yyDayNumber = 0;
	940
	941	yyHaveRel = 0;
	942	yyRelMonth = 0; yyRelDay = 0; yyRelSeconds = 0; yyRelPointer = NULL;
	943
	944	if (yyparse(info)) {
	945	Tcl_SetObjResult(interp, Tcl_NewStringObj("syntax error", -1));
	946	return TCL_ERROR;
	947	}
	948
	949	if (yyHaveDate > 1) {
	950	Tcl_SetObjResult(interp,
	951	Tcl_NewStringObj("more than one date in string", -1));
	952	return TCL_ERROR;
	953	}
	954	if (yyHaveTime > 1) {
	955	Tcl_SetObjResult(interp,
	956	Tcl_NewStringObj("more than one time of day in string", -1));
	957	return TCL_ERROR;
	958	}
	959	if (yyHaveZone > 1) {
	960	Tcl_SetObjResult(interp,
	961	Tcl_NewStringObj("more than one time zone in string", -1));
	962	return TCL_ERROR;
	963	}
	964	if (yyHaveDay > 1) {
	965	Tcl_SetObjResult(interp,
	966	Tcl_NewStringObj("more than one weekday in string", -1));
	967	return TCL_ERROR;
	968	}
	969	if (yyHaveOrdinalMonth > 1) {
	970	Tcl_SetObjResult(interp,
	971	Tcl_NewStringObj("more than one ordinal month in string", -1));
	972	return TCL_ERROR;
	973	}
	974
	975	result = Tcl_NewObj();
	976	resultElement = Tcl_NewObj();
	977	if (yyHaveDate) {
	978	Tcl_ListObjAppendElement(interp, resultElement,
	979	Tcl_NewIntObj((int) yyYear));
	980	Tcl_ListObjAppendElement(interp, resultElement,
	981	Tcl_NewIntObj((int) yyMonth));
	982	Tcl_ListObjAppendElement(interp, resultElement,
	983	Tcl_NewIntObj((int) yyDay));
	984	}
	985	Tcl_ListObjAppendElement(interp, result, resultElement);
	986
	987	if (yyHaveTime) {
	988	Tcl_ListObjAppendElement(interp, result, Tcl_NewIntObj((int)
	989	ToSeconds(yyHour, yyMinutes, yySeconds, yyMeridian)));
	990	} else {
	991	Tcl_ListObjAppendElement(interp, result, Tcl_NewObj());
	992	}
	993
	994	resultElement = Tcl_NewObj();
	995	if (yyHaveZone) {
	996	Tcl_ListObjAppendElement(interp, resultElement,
	997	Tcl_NewIntObj((int) -yyTimezone));
	998	Tcl_ListObjAppendElement(interp, resultElement,
	999	Tcl_NewIntObj(1 - yyDSTmode));
	1000	}
	1001	Tcl_ListObjAppendElement(interp, result, resultElement);
	1002
	1003	resultElement = Tcl_NewObj();
	1004	if (yyHaveRel) {
	1005	Tcl_ListObjAppendElement(interp, resultElement,
	1006	Tcl_NewIntObj((int) yyRelMonth));
	1007	Tcl_ListObjAppendElement(interp, resultElement,
	1008	Tcl_NewIntObj((int) yyRelDay));
	1009	Tcl_ListObjAppendElement(interp, resultElement,
	1010	Tcl_NewIntObj((int) yyRelSeconds));
	1011	}
	1012	Tcl_ListObjAppendElement(interp, result, resultElement);
	1013
	1014	resultElement = Tcl_NewObj();
	1015	if (yyHaveDay && !yyHaveDate) {
	1016	Tcl_ListObjAppendElement(interp, resultElement,
	1017	Tcl_NewIntObj((int) yyDayOrdinal));
	1018	Tcl_ListObjAppendElement(interp, resultElement,
	1019	Tcl_NewIntObj((int) yyDayNumber));
	1020	}
	1021	Tcl_ListObjAppendElement(interp, result, resultElement);
	1022
	1023	resultElement = Tcl_NewObj();
	1024	if (yyHaveOrdinalMonth) {
	1025	Tcl_ListObjAppendElement(interp, resultElement,
	1026	Tcl_NewIntObj((int) yyMonthOrdinal));
	1027	Tcl_ListObjAppendElement(interp, resultElement,
	1028	Tcl_NewIntObj((int) yyMonth));
	1029	}
	1030	Tcl_ListObjAppendElement(interp, result, resultElement);
	1031
	1032	Tcl_SetObjResult(interp, result);
	1033	return TCL_OK;
	1034	}
	1035
	1036	/*
	1037	* Local Variables:
	1038	* mode: c
	1039	* c-basic-offset: 4
	1040	* fill-column: 78
	1041	* End:
	1042	*/

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format