shared_source/c_tcl_base_7_5_w_mods/tclwintime.c

/* $Header$ */

/* 
 * tclWinTime.c --
 *
 *      Contains Windows specific versions of Tcl functions that
 *      obtain time values from the operating system.
 *
 * Copyright 1995-1998 by Sun Microsystems, Inc.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: tclwintime.c,v 1.1.1.1 2001/06/13 04:50:48 dtashley Exp $
 */

#include "tclWinInt.h"

#define SECSPERDAY (60L * 60L * 24L)
#define SECSPERYEAR (SECSPERDAY * 365L)
#define SECSPER4YEAR (SECSPERYEAR * 4L + SECSPERDAY)

/*
 * The following arrays contain the day of year for the last day of
 * each month, where index 1 is January.
 */

static int normalDays[] = {
    -1, 30, 58, 89, 119, 150, 180, 211, 242, 272, 303, 333, 364
};

static int leapDays[] = {
    -1, 30, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
};

typedef struct ThreadSpecificData {
    char tzName[64];            /* Time zone name */
    struct tm tm;               /* time information */
} ThreadSpecificData;
static Tcl_ThreadDataKey dataKey;

/*
 * Declarations for functions defined later in this file.
 */

static struct tm *      ComputeGMT _ANSI_ARGS_((const time_t *tp));

/*
 *----------------------------------------------------------------------
 *
 * TclpGetSeconds --
 *
 *      This procedure returns the number of seconds from the epoch.
 *      On most Unix systems the epoch is Midnight Jan 1, 1970 GMT.
 *
 * Results:
 *      Number of seconds from the epoch.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

unsigned long
TclpGetSeconds()
{
    return (unsigned long) time((time_t *) NULL);
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGetClicks --
 *
 *      This procedure returns a value that represents the highest
 *      resolution clock available on the system.  There are no
 *      guarantees on what the resolution will be.  In Tcl we will
 *      call this value a "click".  The start time is also system
 *      dependant.
 *
 * Results:
 *      Number of clicks from some start time.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

unsigned long
TclpGetClicks()
{
    return GetTickCount();
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGetTimeZone --
 *
 *      Determines the current timezone.  The method varies wildly
 *      between different Platform implementations, so its hidden in
 *      this function.
 *
 * Results:
 *      Minutes west of GMT.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
TclpGetTimeZone (currentTime)
    unsigned long  currentTime;
{
    int timeZone;

    tzset();
    timeZone = _timezone / 60;

    return timeZone;
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGetTime --
 *
 *      Gets the current system time in seconds and microseconds
 *      since the beginning of the epoch: 00:00 UCT, January 1, 1970.
 *
 * Results:
 *      Returns the current time in timePtr.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

void
TclpGetTime(timePtr)
    Tcl_Time *timePtr;          /* Location to store time information. */
{
    struct timeb t;

    ftime(&t);
    timePtr->sec = t.time;
    timePtr->usec = t.millitm * 1000;
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGetTZName --
 *
 *      Gets the current timezone string.
 *
 * Results:
 *      Returns a pointer to a static string, or NULL on failure.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

char *
TclpGetTZName(int dst)
{
    int len;
    char *zone, *p;
    TIME_ZONE_INFORMATION tz;
    Tcl_Encoding encoding;
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
    char *name = tsdPtr->tzName;

    /*
     * tzset() under Borland doesn't seem to set up tzname[] at all.
     * tzset() under MSVC has the following weird observed behavior:
     *   First time we call "clock format [clock seconds] -format %Z -gmt 1"
     *   we get "GMT", but on all subsequent calls we get the current time 
     *   zone string, even though env(TZ) is GMT and the variable _timezone 
     *   is 0.
     */

    name[0] = '\0';

    zone = getenv("TZ");
    if (zone != NULL) {
        /*
         * TZ is of form "NST-4:30NDT", where "NST" would be the
         * name of the standard time zone for this area, "-4:30" is
         * the offset from GMT in hours, and "NDT is the name of 
         * the daylight savings time zone in this area.  The offset 
         * and DST strings are optional.
         */

        len = strlen(zone);
        if (len > 3) {
            len = 3;
        }
        if (dst != 0) {
            /*
             * Skip the offset string and get the DST string.
             */

            p = zone + len;
            p += strspn(p, "+-:0123456789");
            if (*p != '\0') {
                zone = p;
                len = strlen(zone);
                if (len > 3) {
                    len = 3;
                }
            }
        }
        Tcl_ExternalToUtf(NULL, NULL, zone, len, 0, NULL, name,
                sizeof(tsdPtr->tzName), NULL, NULL, NULL);
    }
    if (name[0] == '\0') {
        if (GetTimeZoneInformation(&tz) == TIME_ZONE_ID_UNKNOWN) {
            /*
             * MSDN: On NT this is returned if DST is not used in
             * the current TZ
             */
            dst = 0;
        }
        encoding = Tcl_GetEncoding(NULL, "unicode");
        Tcl_ExternalToUtf(NULL, encoding, 
                (char *) ((dst) ? tz.DaylightName : tz.StandardName), -1, 
                0, NULL, name, sizeof(tsdPtr->tzName), NULL, NULL, NULL);
        Tcl_FreeEncoding(encoding);
    } 
    return name;
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGetDate --
 *
 *      This function converts between seconds and struct tm.  If
 *      useGMT is true, then the returned date will be in Greenwich
 *      Mean Time (GMT).  Otherwise, it will be in the local time zone.
 *
 * Results:
 *      Returns a static tm structure.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

struct tm *
TclpGetDate(t, useGMT)
    TclpTime_t t;
    int useGMT;
{
    const time_t *tp = (const time_t *) t;
    struct tm *tmPtr;
    long time;

    if (!useGMT) {
        tzset();

        /*
         * If we are in the valid range, let the C run-time library
         * handle it.  Otherwise we need to fake it.  Note that this
         * algorithm ignores daylight savings time before the epoch.
         */

        if (*tp >= 0) {
            return localtime(tp);
        }

        time = *tp - _timezone;
        
        /*
         * If we aren't near to overflowing the long, just add the bias and
         * use the normal calculation.  Otherwise we will need to adjust
         * the result at the end.
         */

        if (*tp < (LONG_MAX - 2 * SECSPERDAY)
                && *tp > (LONG_MIN + 2 * SECSPERDAY)) {
            tmPtr = ComputeGMT(&time);
        } else {
            tmPtr = ComputeGMT(tp);

            tzset();

            /*
             * Add the bias directly to the tm structure to avoid overflow.
             * Propagate seconds overflow into minutes, hours and days.
             */

            time = tmPtr->tm_sec - _timezone;
            tmPtr->tm_sec = (int)(time % 60);
            if (tmPtr->tm_sec < 0) {
                tmPtr->tm_sec += 60;
                time -= 60;
            }
    
            time = tmPtr->tm_min + time/60;
            tmPtr->tm_min = (int)(time % 60);
            if (tmPtr->tm_min < 0) {
                tmPtr->tm_min += 60;
                time -= 60;
            }

            time = tmPtr->tm_hour + time/60;
            tmPtr->tm_hour = (int)(time % 24);
            if (tmPtr->tm_hour < 0) {
                tmPtr->tm_hour += 24;
                time -= 24;
            }

            time /= 24;
            tmPtr->tm_mday += time;
            tmPtr->tm_yday += time;
            tmPtr->tm_wday = (tmPtr->tm_wday + time) % 7;
        }
    } else {
        tmPtr = ComputeGMT(tp);
    }
    return tmPtr;
}

/*
 *----------------------------------------------------------------------
 *
 * ComputeGMT --
 *
 *      This function computes GMT given the number of seconds since
 *      the epoch (midnight Jan 1 1970).
 *
 * Results:
 *      Returns a (per thread) statically allocated struct tm.
 *
 * Side effects:
 *      Updates the values of the static struct tm.
 *
 *----------------------------------------------------------------------
 */

static struct tm *
ComputeGMT(tp)
    const time_t *tp;
{
    struct tm *tmPtr;
    long tmp, rem;
    int isLeap;
    int *days;
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

    tmPtr = &tsdPtr->tm;

    /*
     * Compute the 4 year span containing the specified time.
     */

    tmp = *tp / SECSPER4YEAR;
    rem = *tp % SECSPER4YEAR;

    /*
     * Correct for weird mod semantics so the remainder is always positive.
     */

    if (rem < 0) {
        tmp--;
        rem += SECSPER4YEAR;
    }

    /*
     * Compute the year after 1900 by taking the 4 year span and adjusting
     * for the remainder.  This works because 2000 is a leap year, and
     * 1900/2100 are out of the range.
     */

    tmp = (tmp * 4) + 70;
    isLeap = 0;
    if (rem >= SECSPERYEAR) {                     /* 1971, etc. */
        tmp++;
        rem -= SECSPERYEAR;
        if (rem >= SECSPERYEAR) {                 /* 1972, etc. */
            tmp++;
            rem -= SECSPERYEAR;
            if (rem >= SECSPERYEAR + SECSPERDAY) { /* 1973, etc. */
                tmp++;
                rem -= SECSPERYEAR + SECSPERDAY;
            } else {
                isLeap = 1;
            }
        }
    }
    tmPtr->tm_year = tmp;

    /*
     * Compute the day of year and leave the seconds in the current day in
     * the remainder.
     */

    tmPtr->tm_yday = rem / SECSPERDAY;
    rem %= SECSPERDAY;
    
    /*
     * Compute the time of day.
     */

    tmPtr->tm_hour = rem / 3600;
    rem %= 3600;
    tmPtr->tm_min = rem / 60;
    tmPtr->tm_sec = rem % 60;

    /*
     * Compute the month and day of month.
     */

    days = (isLeap) ? leapDays : normalDays;
    for (tmp = 1; days[tmp] < tmPtr->tm_yday; tmp++) {
    }
    tmPtr->tm_mon = --tmp;
    tmPtr->tm_mday = tmPtr->tm_yday - days[tmp];

    /*
     * Compute day of week.  Epoch started on a Thursday.
     */

    tmPtr->tm_wday = (*tp / SECSPERDAY) + 4;
    if ((*tp % SECSPERDAY) < 0) {
        tmPtr->tm_wday--;
    }
    tmPtr->tm_wday %= 7;
    if (tmPtr->tm_wday < 0) {
        tmPtr->tm_wday += 7;
    }

    return tmPtr;
}


/* $History: tclwintime.c $
 * 
 * *****************  Version 1  *****************
 * User: Dtashley     Date: 1/02/01    Time: 12:20a
 * Created in $/IjuScripter, IjuConsole/Source/Tcl Base
 * Initial check-in.
 */ 

/* End of TCLWINTIME.C */
1	/* $Header$ */
2
3	/*
4	* tclWinTime.c --
5	*
6	* Contains Windows specific versions of Tcl functions that
7	* obtain time values from the operating system.
8	*
9	* Copyright 1995-1998 by Sun Microsystems, Inc.
10	*
11	* See the file "license.terms" for information on usage and redistribution
12	* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
13	*
14	* RCS: @(#) $Id: tclwintime.c,v 1.1.1.1 2001/06/13 04:50:48 dtashley Exp $
15	*/
16
17	#include "tclWinInt.h"
18
19	#define SECSPERDAY (60L * 60L * 24L)
20	#define SECSPERYEAR (SECSPERDAY * 365L)
21	#define SECSPER4YEAR (SECSPERYEAR * 4L + SECSPERDAY)
22
23	/*
24	* The following arrays contain the day of year for the last day of
25	* each month, where index 1 is January.
26	*/
27
28	static int normalDays[] = {
29	-1, 30, 58, 89, 119, 150, 180, 211, 242, 272, 303, 333, 364
30	};
31
32	static int leapDays[] = {
33	-1, 30, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
34	};
35
36	typedef struct ThreadSpecificData {
37	char tzName[64]; /* Time zone name */
38	struct tm tm; /* time information */
39	} ThreadSpecificData;
40	static Tcl_ThreadDataKey dataKey;
41
42	/*
43	* Declarations for functions defined later in this file.
44	*/
45
46	static struct tm * ComputeGMT _ANSI_ARGS_((const time_t *tp));
47
48	/*
49	*----------------------------------------------------------------------
50	*
51	* TclpGetSeconds --
52	*
53	* This procedure returns the number of seconds from the epoch.
54	* On most Unix systems the epoch is Midnight Jan 1, 1970 GMT.
55	*
56	* Results:
57	* Number of seconds from the epoch.
58	*
59	* Side effects:
60	* None.
61	*
62	*----------------------------------------------------------------------
63	*/
64
65	unsigned long
66	TclpGetSeconds()
67	{
68	return (unsigned long) time((time_t *) NULL);
69	}
70
71	/*
72	*----------------------------------------------------------------------
73	*
74	* TclpGetClicks --
75	*
76	* This procedure returns a value that represents the highest
77	* resolution clock available on the system. There are no
78	* guarantees on what the resolution will be. In Tcl we will
79	* call this value a "click". The start time is also system
80	* dependant.
81	*
82	* Results:
83	* Number of clicks from some start time.
84	*
85	* Side effects:
86	* None.
87	*
88	*----------------------------------------------------------------------
89	*/
90
91	unsigned long
92	TclpGetClicks()
93	{
94	return GetTickCount();
95	}
96
97	/*
98	*----------------------------------------------------------------------
99	*
100	* TclpGetTimeZone --
101	*
102	* Determines the current timezone. The method varies wildly
103	* between different Platform implementations, so its hidden in
104	* this function.
105	*
106	* Results:
107	* Minutes west of GMT.
108	*
109	* Side effects:
110	* None.
111	*
112	*----------------------------------------------------------------------
113	*/
114
115	int
116	TclpGetTimeZone (currentTime)
117	unsigned long currentTime;
118	{
119	int timeZone;
120
121	tzset();
122	timeZone = _timezone / 60;
123
124	return timeZone;
125	}
126
127	/*
128	*----------------------------------------------------------------------
129	*
130	* TclpGetTime --
131	*
132	* Gets the current system time in seconds and microseconds
133	* since the beginning of the epoch: 00:00 UCT, January 1, 1970.
134	*
135	* Results:
136	* Returns the current time in timePtr.
137	*
138	* Side effects:
139	* None.
140	*
141	*----------------------------------------------------------------------
142	*/
143
144	void
145	TclpGetTime(timePtr)
146	Tcl_Time timePtr; / Location to store time information. */
147	{
148	struct timeb t;
149
150	ftime(&t);
151	timePtr->sec = t.time;
152	timePtr->usec = t.millitm * 1000;
153	}
154
155	/*
156	*----------------------------------------------------------------------
157	*
158	* TclpGetTZName --
159	*
160	* Gets the current timezone string.
161	*
162	* Results:
163	* Returns a pointer to a static string, or NULL on failure.
164	*
165	* Side effects:
166	* None.
167	*
168	*----------------------------------------------------------------------
169	*/
170
171	char *
172	TclpGetTZName(int dst)
173	{
174	int len;
175	char zone, p;
176	TIME_ZONE_INFORMATION tz;
177	Tcl_Encoding encoding;
178	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
179	char *name = tsdPtr->tzName;
180
181	/*
182	* tzset() under Borland doesn't seem to set up tzname[] at all.
183	* tzset() under MSVC has the following weird observed behavior:
184	* First time we call "clock format [clock seconds] -format %Z -gmt 1"
185	* we get "GMT", but on all subsequent calls we get the current time
186	* zone string, even though env(TZ) is GMT and the variable _timezone
187	* is 0.
188	*/
189
190	name[0] = '\0';
191
192	zone = getenv("TZ");
193	if (zone != NULL) {
194	/*
195	* TZ is of form "NST-4:30NDT", where "NST" would be the
196	* name of the standard time zone for this area, "-4:30" is
197	* the offset from GMT in hours, and "NDT is the name of
198	* the daylight savings time zone in this area. The offset
199	* and DST strings are optional.
200	*/
201
202	len = strlen(zone);
203	if (len > 3) {
204	len = 3;
205	}
206	if (dst != 0) {
207	/*
208	* Skip the offset string and get the DST string.
209	*/
210
211	p = zone + len;
212	p += strspn(p, "+-:0123456789");
213	if (*p != '\0') {
214	zone = p;
215	len = strlen(zone);
216	if (len > 3) {
217	len = 3;
218	}
219	}
220	}
221	Tcl_ExternalToUtf(NULL, NULL, zone, len, 0, NULL, name,
222	sizeof(tsdPtr->tzName), NULL, NULL, NULL);
223	}
224	if (name[0] == '\0') {
225	if (GetTimeZoneInformation(&tz) == TIME_ZONE_ID_UNKNOWN) {
226	/*
227	* MSDN: On NT this is returned if DST is not used in
228	* the current TZ
229	*/
230	dst = 0;
231	}
232	encoding = Tcl_GetEncoding(NULL, "unicode");
233	Tcl_ExternalToUtf(NULL, encoding,
234	(char *) ((dst) ? tz.DaylightName : tz.StandardName), -1,
235	0, NULL, name, sizeof(tsdPtr->tzName), NULL, NULL, NULL);
236	Tcl_FreeEncoding(encoding);
237	}
238	return name;
239	}
240
241	/*
242	*----------------------------------------------------------------------
243	*
244	* TclpGetDate --
245	*
246	* This function converts between seconds and struct tm. If
247	* useGMT is true, then the returned date will be in Greenwich
248	* Mean Time (GMT). Otherwise, it will be in the local time zone.
249	*
250	* Results:
251	* Returns a static tm structure.
252	*
253	* Side effects:
254	* None.
255	*
256	*----------------------------------------------------------------------
257	*/
258
259	struct tm *
260	TclpGetDate(t, useGMT)
261	TclpTime_t t;
262	int useGMT;
263	{
264	const time_t tp = (const time_t ) t;
265	struct tm *tmPtr;
266	long time;
267
268	if (!useGMT) {
269	tzset();
270
271	/*
272	* If we are in the valid range, let the C run-time library
273	* handle it. Otherwise we need to fake it. Note that this
274	* algorithm ignores daylight savings time before the epoch.
275	*/
276
277	if (*tp >= 0) {
278	return localtime(tp);
279	}
280
281	time = *tp - _timezone;
282
283	/*
284	* If we aren't near to overflowing the long, just add the bias and
285	* use the normal calculation. Otherwise we will need to adjust
286	* the result at the end.
287	*/
288
289	if (tp < (LONG_MAX - 2 SECSPERDAY)
290	&& tp > (LONG_MIN + 2 SECSPERDAY)) {
291	tmPtr = ComputeGMT(&time);
292	} else {
293	tmPtr = ComputeGMT(tp);
294
295	tzset();
296
297	/*
298	* Add the bias directly to the tm structure to avoid overflow.
299	* Propagate seconds overflow into minutes, hours and days.
300	*/
301
302	time = tmPtr->tm_sec - _timezone;
303	tmPtr->tm_sec = (int)(time % 60);
304	if (tmPtr->tm_sec < 0) {
305	tmPtr->tm_sec += 60;
306	time -= 60;
307	}
308
309	time = tmPtr->tm_min + time/60;
310	tmPtr->tm_min = (int)(time % 60);
311	if (tmPtr->tm_min < 0) {
312	tmPtr->tm_min += 60;
313	time -= 60;
314	}
315
316	time = tmPtr->tm_hour + time/60;
317	tmPtr->tm_hour = (int)(time % 24);
318	if (tmPtr->tm_hour < 0) {
319	tmPtr->tm_hour += 24;
320	time -= 24;
321	}
322
323	time /= 24;
324	tmPtr->tm_mday += time;
325	tmPtr->tm_yday += time;
326	tmPtr->tm_wday = (tmPtr->tm_wday + time) % 7;
327	}
328	} else {
329	tmPtr = ComputeGMT(tp);
330	}
331	return tmPtr;
332	}
333
334	/*
335	*----------------------------------------------------------------------
336	*
337	* ComputeGMT --
338	*
339	* This function computes GMT given the number of seconds since
340	* the epoch (midnight Jan 1 1970).
341	*
342	* Results:
343	* Returns a (per thread) statically allocated struct tm.
344	*
345	* Side effects:
346	* Updates the values of the static struct tm.
347	*
348	*----------------------------------------------------------------------
349	*/
350
351	static struct tm *
352	ComputeGMT(tp)
353	const time_t *tp;
354	{
355	struct tm *tmPtr;
356	long tmp, rem;
357	int isLeap;
358	int *days;
359	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
360
361	tmPtr = &tsdPtr->tm;
362
363	/*
364	* Compute the 4 year span containing the specified time.
365	*/
366
367	tmp = *tp / SECSPER4YEAR;
368	rem = *tp % SECSPER4YEAR;
369
370	/*
371	* Correct for weird mod semantics so the remainder is always positive.
372	*/
373
374	if (rem < 0) {
375	tmp--;
376	rem += SECSPER4YEAR;
377	}
378
379	/*
380	* Compute the year after 1900 by taking the 4 year span and adjusting
381	* for the remainder. This works because 2000 is a leap year, and
382	* 1900/2100 are out of the range.
383	*/
384
385	tmp = (tmp * 4) + 70;
386	isLeap = 0;
387	if (rem >= SECSPERYEAR) { /* 1971, etc. */
388	tmp++;
389	rem -= SECSPERYEAR;
390	if (rem >= SECSPERYEAR) { /* 1972, etc. */
391	tmp++;
392	rem -= SECSPERYEAR;
393	if (rem >= SECSPERYEAR + SECSPERDAY) { /* 1973, etc. */
394	tmp++;
395	rem -= SECSPERYEAR + SECSPERDAY;
396	} else {
397	isLeap = 1;
398	}
399	}
400	}
401	tmPtr->tm_year = tmp;
402
403	/*
404	* Compute the day of year and leave the seconds in the current day in
405	* the remainder.
406	*/
407
408	tmPtr->tm_yday = rem / SECSPERDAY;
409	rem %= SECSPERDAY;
410
411	/*
412	* Compute the time of day.
413	*/
414
415	tmPtr->tm_hour = rem / 3600;
416	rem %= 3600;
417	tmPtr->tm_min = rem / 60;
418	tmPtr->tm_sec = rem % 60;
419
420	/*
421	* Compute the month and day of month.
422	*/
423
424	days = (isLeap) ? leapDays : normalDays;
425	for (tmp = 1; days[tmp] < tmPtr->tm_yday; tmp++) {
426	}
427	tmPtr->tm_mon = --tmp;
428	tmPtr->tm_mday = tmPtr->tm_yday - days[tmp];
429
430	/*
431	* Compute day of week. Epoch started on a Thursday.
432	*/
433
434	tmPtr->tm_wday = (*tp / SECSPERDAY) + 4;
435	if ((*tp % SECSPERDAY) < 0) {
436	tmPtr->tm_wday--;
437	}
438	tmPtr->tm_wday %= 7;
439	if (tmPtr->tm_wday < 0) {
440	tmPtr->tm_wday += 7;
441	}
442
443	return tmPtr;
444	}
445
446
447	/* $History: tclwintime.c $
448	*
449	* *************** Version 1 ***************
450	* User: Dtashley Date: 1/02/01 Time: 12:20a
451	* Created in $/IjuScripter, IjuConsole/Source/Tcl Base
452	* Initial check-in.
453	*/
454
455	/* End of TCLWINTIME.C */