qb64/internal/c/time64.c

/* Copyright (c) Robert Walker, support@tunesmithy.co.uk
 * Free source. Do what you wish with it - treat it as you would
 * example code in a book on c programming.
 */ 
#include "time64.h"
#undef time
#undef localtime
#undef mktime
#undef difftime
#undef gmtime
#undef time_t

#include <time.h>
#include <windows.h>
#include <assert.h>

#define SECS_TO_FT_MULT 10000000
#ifdef _DEBUG
#define DEBUG_TIME_T
#endif

/* From MSVC help:
 * The gmtime, mktime, and localtime functions use the same single, 
 * statically allocated structure to hold their results. Each call to 
 * one of these functions destroys the result of any previous call. 
 * If timer represents a date before midnight, January 1, 1970, 
 * gmtime returns NULL. There is no error return.
 *
 * So here is the struct to use for our 64 bit implementation
 *
 * However, it may be useful to be able to make this thread safe
 */

#ifdef USE_THREAD_LOCAL_VARIABLES
#define  TIME64_THREAD_LOCAL _declspec(thread)
#else
#define TIME64_THREAD_LOCAL
#endif

TIME64_THREAD_LOCAL static struct tm today_ret;

static void T64ToFileTime(t64 *pt,FILETIME *pft)
{
 LARGE_INTEGER li; 
 li.QuadPart=*pt*SECS_TO_FT_MULT;
 pft->dwLowDateTime=li.LowPart;
 pft->dwHighDateTime=li.HighPart;
}

static void FileTimeToT64(FILETIME *pft,t64 *pt)
{
 LARGE_INTEGER li;    
 li.LowPart = pft->dwLowDateTime;
 li.HighPart = pft->dwHighDateTime;
 *pt=li.QuadPart;
 *pt/=SECS_TO_FT_MULT;
}

//#define  FindTimeTBase() ((t64) 11644473600)
#define  FindTimeTBase() (((__int64)11644)*1000000+473600)

 // calculated using
/**
static t64 FindTimeTBase(void)
{
 // Find 1st Jan 1970 as a FILETIME 
 SYSTEMTIME st;
 FILETIME ft;
 memset(&st,0,sizeof(st));
 st.wYear=1970;
 st.wMonth=1;
 st.wDay=1;
 SystemTimeToFileTime(&st, &ft);
 FileTimeToT64(&ft,&tbase);
 return tbase;
}
**/

static void SystemTimeToT64(SYSTEMTIME *pst,t64 *pt)
{
 FILETIME ft;
 SystemTimeToFileTime(pst, &ft);
 FileTimeToT64(&ft,pt);
 *pt-=FindTimeTBase();
}


static void T64ToSystemTime(t64 *pt,SYSTEMTIME *pst)
{
 FILETIME ft;
 t64 t=*pt;
 t+=FindTimeTBase();
 T64ToFileTime(&t,&ft);
 FileTimeToSystemTime(&ft,pst);
}


t64 time_64(t64 *pt)
{
 t64 t;
 SYSTEMTIME st;
 GetSystemTime(&st);
 SystemTimeToT64(&st,&t);
#ifdef DEBUG_TIME_T
 {
  time_t t2=time(NULL);
  if(t2>=0)

//2005 assert(abs(t2-(int)t)<=1);
 assert(abs((long)(t2-(int)t))<=1);

   // the <=1 here is in case the seconds get incremented
   // betweeen the GetSystemTime(..) call and the time(..) call
 }
#endif
 if(pt)
  *pt=t;
 return t;
}

double difftime_64(t64 time1, t64 time0)
{
 return (double)(time1-time0);
}

t64 mktime64( struct tm *today )
{
 t64 t;
 SYSTEMTIME st;
 st.wDay=(WORD)today->tm_mday;
 st.wDayOfWeek=(WORD)today->tm_wday;
 st.wHour=(WORD)today->tm_hour;
 st.wMinute=(WORD)today->tm_min;
 st.wMonth=(WORD)(today->tm_mon+1);
 st.wSecond=(WORD)today->tm_sec;
 st.wYear=(WORD)(today->tm_year+1900);
 st.wMilliseconds=0;
 SystemTimeToT64(&st,&t);
 return t;
}

#define DAY_IN_SECS (60*60*24)
struct tm *gmtime_64(t64 t)
{
 SYSTEMTIME st;
 T64ToSystemTime(&t,&st);
 today_ret.tm_wday=st.wDayOfWeek;
 today_ret.tm_min=st.wMinute;
 today_ret.tm_sec=st.wSecond;
 today_ret.tm_mon=st.wMonth-1;
 today_ret.tm_mday=st.wDay;
 today_ret.tm_hour=st.wHour;
 today_ret.tm_year=st.wYear-1900;
 {
  SYSTEMTIME styear;
  t64 t64Year;
  memset(&styear,0,sizeof(styear));
  styear.wYear=st.wYear;
  styear.wMonth=1;
  styear.wDay=1;
  SystemTimeToT64(&styear,&t64Year);
  today_ret.tm_yday=(int)((t-t64Year)/DAY_IN_SECS);
 }
 today_ret.tm_isdst=0;
#ifdef DEBUG_TIME_T
 {
  struct tm today2;
  long t32=(int)t;
  if(t32>=0)
  {
//2005   today2=*gmtime(&t32);
   today2=*gmtime((time_t*)&t32);

   assert(today_ret.tm_yday==today2.tm_yday);
   assert(today_ret.tm_wday==today2.tm_wday);
   assert(today_ret.tm_min==today2.tm_min);
   assert(today_ret.tm_sec==today2.tm_sec);
   assert(today_ret.tm_mon==today2.tm_mon);
   assert(today_ret.tm_mday==today2.tm_mday);
   assert(today_ret.tm_hour==today2.tm_hour);
   assert(today_ret.tm_year==today2.tm_year);
  }
 }
 {
  t64 t2=mktime64(&today_ret);
  assert(t2==t);
 }
#endif
 return &today_ret;
}

struct tm *localtime_64(t64 *pt)
{
 t64 t=*pt;
 FILETIME ft,ftlocal;
 T64ToFileTime(&t,&ft);
 FileTimeToLocalFileTime(&ft,&ftlocal);
 FileTimeToT64(&ftlocal,&t);
 today_ret=*gmtime_64(t);
 {
  TIME_ZONE_INFORMATION TimeZoneInformation;
  switch(GetTimeZoneInformation(&TimeZoneInformation))
  {
  case TIME_ZONE_ID_DAYLIGHT:today_ret.tm_isdst=1;break;
  case TIME_ZONE_ID_STANDARD:today_ret.tm_isdst=0;break;
  case TIME_ZONE_ID_UNKNOWN:today_ret.tm_isdst=-1;break;
  }
 }
 return &today_ret;
}