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;
}

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