shared_source/c_tcl_base_7_5_w_mods/tclwintime.c

/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tcl_base/tclwintime.c,v 1.1.1.1 2001/06/13 04:50:48 dtashley Exp $ */

/* 
 * 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	dashley	25	/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tcl_base/tclwintime.c,v 1.1.1.1 2001/06/13 04:50:48 dtashley Exp $ */
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 */