/* 

  * tclMacTime.c --

  *

  *	Contains Macintosh specific versions of Tcl functions that

  *	obtain time values from the operating system.

  *

  * Copyright (c) 1995-1997 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: tclMacTime.c,v 1.7 2002/01/04 11:21:05 das Exp $

  */

 #include "tclInt.h"

 #include "tclPort.h"

 #include "tclMacInt.h"

 #include <OSUtils.h>

 #include <Timer.h>

 #include <time.h>

 /*

  * Static variables used by the Tcl_GetTime function.

  */

 static int initalized = false;

 static unsigned long baseSeconds;

 static UnsignedWide microOffset;

 static int gmt_initialized = false;

 static long gmt_offset;

 static int gmt_isdst;

 TCL_DECLARE_MUTEX(gmtMutex)

 static int gmt_lastGetDateUseGMT = 0;

 typedef struct _TABLE {

     char        *name;

     int         type;

     time_t      value;

 } TABLE;

 #define HOUR(x)         ((time_t) (3600 * x))

 #define tZONE 0

 #define tDAYZONE 1

 /*

  * inverse timezone table, adapted from tclDate.c by removing duplicates and

  * adding some made up names for unusual daylight savings

  */

 static TABLE    invTimezoneTable[] = {

     { "Z",    -1,     HOUR( 36) },      /* Unknown */

     { "GMT",    tZONE,     HOUR( 0) },      /* Greenwich Mean */

     { "BST",    tDAYZONE,  HOUR( 0) },      /* British Summer */

     { "WAT",    tZONE,     HOUR( 1) },      /* West Africa */

     { "WADST",  tDAYZONE,  HOUR( 1) },      /* West Africa Daylight*/

     { "AT",     tZONE,     HOUR( 2) },      /* Azores Daylight*/

     { "ADST",   tDAYZONE,  HOUR( 2) },      /* Azores */

     { "NFT",    tZONE,     HOUR( 7/2) },    /* Newfoundland */

     { "NDT",    tDAYZONE,  HOUR( 7/2) },    /* Newfoundland Daylight */

     { "AST",    tZONE,     HOUR( 4) },      /* Atlantic Standard */

     { "ADT",    tDAYZONE,  HOUR( 4) },      /* Atlantic Daylight */

     { "EST",    tZONE,     HOUR( 5) },      /* Eastern Standard */

     { "EDT",    tDAYZONE,  HOUR( 5) },      /* Eastern Daylight */

     { "CST",    tZONE,     HOUR( 6) },      /* Central Standard */

     { "CDT",    tDAYZONE,  HOUR( 6) },      /* Central Daylight */

     { "MST",    tZONE,     HOUR( 7) },      /* Mountain Standard */

     { "MDT",    tDAYZONE,  HOUR( 7) },      /* Mountain Daylight */

     { "PST",    tZONE,     HOUR( 8) },      /* Pacific Standard */

     { "PDT",    tDAYZONE,  HOUR( 8) },      /* Pacific Daylight */

     { "YST",    tZONE,     HOUR( 9) },      /* Yukon Standard */

     { "YDT",    tDAYZONE,  HOUR( 9) },      /* Yukon Daylight */

     { "HST",    tZONE,     HOUR(10) },      /* Hawaii Standard */

     { "HDT",    tDAYZONE,  HOUR(10) },      /* Hawaii Daylight */

     { "NT",     tZONE,     HOUR(11) },      /* Nome */

     { "NST",    tDAYZONE,  HOUR(11) },      /* Nome Daylight*/

     { "IDLW",   tZONE,     HOUR(12) },      /* International Date Line West */

     { "CET",    tZONE,    -HOUR( 1) },      /* Central European */

     { "CEST",   tDAYZONE, -HOUR( 1) },      /* Central European Summer */

     { "EET",    tZONE,    -HOUR( 2) },      /* Eastern Europe, USSR Zone 1 */

     { "EEST",   tDAYZONE, -HOUR( 2) },      /* Eastern Europe, USSR Zone 1 Daylight*/

     { "BT",     tZONE,    -HOUR( 3) },      /* Baghdad, USSR Zone 2 */

     { "BDST",   tDAYZONE, -HOUR( 3) },      /* Baghdad, USSR Zone 2 Daylight*/

     { "IT",     tZONE,    -HOUR( 7/2) },    /* Iran */

     { "IDST",   tDAYZONE, -HOUR( 7/2) },    /* Iran Daylight*/

     { "ZP4",    tZONE,    -HOUR( 4) },      /* USSR Zone 3 */

     { "ZP4S",   tDAYZONE, -HOUR( 4) },      /* USSR Zone 3 */

     { "ZP5",    tZONE,    -HOUR( 5) },      /* USSR Zone 4 */

     { "ZP5S",   tDAYZONE, -HOUR( 5) },      /* USSR Zone 4 */

     { "IST",    tZONE,    -HOUR(11/2) },    /* Indian Standard */

     { "ISDST",  tDAYZONE, -HOUR(11/2) },    /* Indian Standard */

     { "ZP6",    tZONE,    -HOUR( 6) },      /* USSR Zone 5 */

     { "ZP6S",   tDAYZONE, -HOUR( 6) },      /* USSR Zone 5 */

     { "WAST",   tZONE,    -HOUR( 7) },      /* West Australian Standard */

     { "WADT",   tDAYZONE, -HOUR( 7) },      /* West Australian Daylight */

     { "JT",     tZONE,    -HOUR(15/2) },    /* Java (3pm in Cronusland!) */

     { "JDST",   tDAYZONE, -HOUR(15/2) },    /* Java (3pm in Cronusland!) */

     { "CCT",    tZONE,    -HOUR( 8) },      /* China Coast, USSR Zone 7 */

     { "CCST",   tDAYZONE, -HOUR( 8) },      /* China Coast, USSR Zone 7 */

     { "JST",    tZONE,    -HOUR( 9) },      /* Japan Standard, USSR Zone 8 */

     { "JSDST",  tDAYZONE, -HOUR( 9) },      /* Japan Standard, USSR Zone 8 */

     { "CAST",   tZONE,    -HOUR(19/2) },    /* Central Australian Standard */

     { "CADT",   tDAYZONE, -HOUR(19/2) },    /* Central Australian Daylight */

     { "EAST",   tZONE,    -HOUR(10) },      /* Eastern Australian Standard */

     { "EADT",   tDAYZONE, -HOUR(10) },      /* Eastern Australian Daylight */

     { "NZT",    tZONE,    -HOUR(12) },      /* New Zealand */

     { "NZDT",   tDAYZONE, -HOUR(12) },      /* New Zealand Daylight */

     {  NULL  }

 };

 /*

  * Prototypes for procedures that are private to this file:

  */

 static void SubtractUnsignedWide _ANSI_ARGS_((UnsignedWide *x,

 	UnsignedWide *y, UnsignedWide *result));

 /*

  *-----------------------------------------------------------------------------

  *

  * TclpGetGMTOffset --

  *

  *	This procedure gets the offset seconds that needs to be _added_ to tcl time

  *  in seconds (i.e. GMT time) to get local time needed as input to various

  *  Mac OS APIs, to convert Mac OS API output to tcl time, _subtract_ this value.

  *

  * Results:

  *	Number of seconds separating GMT time and mac.

  *

  * Side effects:

  *	None.

  *

  *-----------------------------------------------------------------------------

  */

 long

 TclpGetGMTOffset()

 {

     if (gmt_initialized == false) {

 	MachineLocation loc;

     Tcl_MutexLock(&gmtMutex);

 	ReadLocation(&loc);

 	gmt_offset = loc.u.gmtDelta & 0x00ffffff;

 	if (gmt_offset & 0x00800000) {

 	    gmt_offset = gmt_offset | 0xff000000;

 	}

 	gmt_isdst=(loc.u.dlsDelta < 0);

 	gmt_initialized = true;

     Tcl_MutexUnlock(&gmtMutex);

     }

 	return (gmt_offset);

 }

 /*

  *-----------------------------------------------------------------------------

  *

  * TclpGetSeconds --

  *

  *	This procedure returns the number of seconds from the epoch.  On

  *	the Macintosh the epoch is Midnight Jan 1, 1904.  Unfortunatly,

  *	the Macintosh doesn't tie the epoch to a particular time zone.  For

  *	Tcl we tie the epoch to GMT.  This makes the time zone date parsing

  *	code work.  The epoch for Mac-Tcl is: Midnight Jan 1, 1904 GMT.

  *

  * Results:

  *	Number of seconds from the epoch in GMT.

  *

  * Side effects:

  *	None.

  *

  *-----------------------------------------------------------------------------

  */

 unsigned long

 TclpGetSeconds()

 {

     unsigned long seconds;

     GetDateTime(&seconds);

 	return (seconds - TclpGetGMTOffset() + tcl_mac_epoch_offset);

 }

 /*

  *-----------------------------------------------------------------------------

  *

  * TclpGetClicks --

  *

  *	This procedure returns a value that represents the highest resolution

  *	clock available on the system.  There are no garantees 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()

 {

     UnsignedWide micros;

     Microseconds(&micros);

     return micros.lo;

 }

 /*

  *----------------------------------------------------------------------

  *

  * TclpGetTimeZone --

  *

  *	Get the current time zone.

  *

  * Results:

  *	The return value is the local time zone, measured in

  *	minutes away from GMT (-ve for east, +ve for west).

  *

  * Side effects:

  *	None.

  *

  *----------------------------------------------------------------------

  */

 int

 TclpGetTimeZone (

     unsigned long  currentTime)		/* Ignored on Mac. */

 {

     long offset;

     /*

      * Convert the Mac offset from seconds to minutes and

      * add an hour if we have daylight savings time.

      */

     offset = -TclpGetGMTOffset();

     offset /= 60;

     if (gmt_isdst) {

 	offset += 60;

     }

     return offset;

 }

 /*

  *----------------------------------------------------------------------

  *

  * Tcl_GetTime --

  *

  *	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 the local timezone) in timePtr.

  *

  * Side effects:

  *	None.

  *

  *----------------------------------------------------------------------

  */

 void

 Tcl_GetTime(

     Tcl_Time *timePtr)		/* Location to store time information. */

 {

     UnsignedWide micro;

 #ifndef NO_LONG_LONG

     long long *microPtr;

 #endif

     if (initalized == false) {

 	GetDateTime(&baseSeconds);

 	/*

 	 * Remove the local offset that ReadDateTime() adds.

 	 */

 	baseSeconds -= TclpGetGMTOffset() - tcl_mac_epoch_offset;

 	Microseconds(&microOffset);

 	initalized = true;

     }

     Microseconds(&micro);

 #ifndef NO_LONG_LONG

     microPtr = (long long *) µ

     *microPtr -= *((long long *) &microOffset);

     timePtr->sec = baseSeconds + (*microPtr / 1000000);

     timePtr->usec = *microPtr % 1000000;

 #else

     SubtractUnsignedWide(&micro, &microOffset, &micro);

     /*

      * This lovely computation is equal to: base + (micro / 1000000)

      * For the .hi part the ratio of 0x100000000 / 1000000 has been

      * reduced to avoid overflow.  This computation certainly has 

      * problems as the .hi part gets large.  However, your application

      * would have to run for a long time to make that happen.

      */

     timePtr->sec = baseSeconds + (micro.lo / 1000000) + 

     	(long) (micro.hi * ((double) 33554432.0 / 15625.0));

     timePtr->usec = micro.lo % 1000000;

 #endif

 }

 /*

  *----------------------------------------------------------------------

  *

  * TclpGetDate --

  *

  *	Converts raw seconds to a struct tm data structure.  The

  *	returned time will be for Greenwich Mean Time if the useGMT flag 

  *	is set.  Otherwise, the returned time will be for the local

  *	time zone.  This function is meant to be used as a replacement

  *	for localtime and gmtime which is broken on most ANSI libs

  *	on the Macintosh.

  *

  * Results:

  *	None.

  *

  * Side effects:

  *  	The passed in struct tm data structure is modified.

  *

  *----------------------------------------------------------------------

  */

 struct tm *

 TclpGetDate(

     TclpTime_t time,	/* Time struct to fill. */

     int useGMT)		/* True if date should reflect GNT time. */

 {

     const time_t *tp = (const time_t *)time;

     DateTimeRec dtr;

     unsigned long offset=0L;

     static struct tm statictime;

     static const short monthday[12] =

         {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};

 	if(useGMT)

 		SecondsToDate(*tp - tcl_mac_epoch_offset, &dtr);

 	else

 		SecondsToDate(*tp + TclpGetGMTOffset() - tcl_mac_epoch_offset, &dtr);

     statictime.tm_sec = dtr.second;

     statictime.tm_min = dtr.minute;

     statictime.tm_hour = dtr.hour;

     statictime.tm_mday = dtr.day;

     statictime.tm_mon = dtr.month - 1;

     statictime.tm_year = dtr.year - 1900;

     statictime.tm_wday = dtr.dayOfWeek - 1;

     statictime.tm_yday = monthday[statictime.tm_mon]

 	+ statictime.tm_mday - 1;

     if (1 < statictime.tm_mon && !(statictime.tm_year & 3)) {

 	++statictime.tm_yday;

     }

     if(useGMT)

     	statictime.tm_isdst = 0;

     else

     	statictime.tm_isdst = gmt_isdst;

     gmt_lastGetDateUseGMT=useGMT; /* hack to make TclpGetTZName below work */

     return(&statictime);

 }

 /*

  *----------------------------------------------------------------------

  *

  * 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)

 {

     register TABLE *tp;

 	long zonevalue=-TclpGetGMTOffset();

     if (gmt_isdst)

         zonevalue += HOUR(1);

 	if(gmt_lastGetDateUseGMT) /* hack: if last TclpGetDate was called */

 		zonevalue=0;          /* with useGMT==1 then we're using GMT  */

     for (tp = invTimezoneTable; tp->name; tp++) {

         if ((tp->value == zonevalue) && (tp->type == dst)) break;

     }

 	if(!tp->name)

 		tp = invTimezoneTable; /* default to unknown */

     return tp->name;

 }

 #ifdef NO_LONG_LONG

 /*

  *----------------------------------------------------------------------

  *

  * SubtractUnsignedWide --

  *

  *	Subtracts one UnsignedWide value from another.

  *

  * Results:

  *  	The subtracted value.

  *

  * Side effects:

  *	None.

  *

  *----------------------------------------------------------------------

  */

 static void

 SubtractUnsignedWide(

     UnsignedWide *x,		/* Ptr to wide int. */

     UnsignedWide *y,		/* Ptr to wide int. */

     UnsignedWide *result)	/* Ptr to result. */

 {

     result->hi = x->hi - y->hi;

     if (x->lo < y->lo) {

 	result->hi--;

     }

     result->lo = x->lo - y->lo;

 }

 #endif