[wxWidgets.git] / src / msw / wince / time.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/msw/wince/time.cpp
// Purpose:     Implements missing time functionality for WinCE
// Author:      Marco Cavallini (MCK) - wx@koansoftware.com
// Modified by: Vadim Zeitlin for VC8 support
// Created:     31-08-2003
// RCS-ID:      $Id$
// Copyright:   (c) Marco Cavallini
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ===========================================================================
// declarations
// ===========================================================================

// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/msw/wrapwin.h"
#endif

#include "wx/msw/wince/time.h"

#if defined(__VISUALC__) && (__VISUALC__ >= 1400)

// VC8 does provide the time functions but not the standard ones
#include <altcecrt.h>

time_t __cdecl time(time_t *t)
{
    __time64_t t64;
    if ( !_time64(&t64) )
        return (time_t)-1;

    if ( t )
        *t = (time_t)t64;

    return (time_t)t64;
}

time_t __cdecl mktime(struct tm *t)
{
    return (time_t)_mktime64(t);
}

#else // !VC8

/////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                         //
//                             strftime() - taken from OpenBSD                             //
//                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////

#define IN_NONE	0
#define IN_SOME	1
#define IN_THIS	2
#define IN_ALL	3
#define CHAR_BIT      8

#define TYPE_BIT(type)	(sizeof (type) * CHAR_BIT)
#define TYPE_SIGNED(type) (((type) -1) < 0)

#define INT_STRLEN_MAXIMUM(type) \
    ((TYPE_BIT(type) - TYPE_SIGNED(type)) * 302 / 1000 + 1 + TYPE_SIGNED(type))

#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))

#define MONSPERYEAR	12
#define DAYSPERWEEK	7
#define TM_YEAR_BASE	1900
#define HOURSPERDAY	24
#define DAYSPERNYEAR	365
#define DAYSPERLYEAR	366

static char		wildabbr[] = "WILDABBR";

char *			tzname[2] = {
	wildabbr,
	wildabbr
};


#define Locale	(&C_time_locale)

struct lc_time_T {
	const char *	mon[MONSPERYEAR];
	const char *	month[MONSPERYEAR];
	const char *	wday[DAYSPERWEEK];
	const char *	weekday[DAYSPERWEEK];
	const char *	X_fmt;
	const char *	x_fmt;
	const char *	c_fmt;
	const char *	am;
	const char *	pm;
	const char *	date_fmt;
};

static const struct lc_time_T	C_time_locale = {
	{
		"Jan", "Feb", "Mar", "Apr", "May", "Jun",
		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
	}, {
		"January", "February", "March", "April", "May", "June",
		"July", "August", "September", "October", "November", "December"
	}, {
		"Sun", "Mon", "Tue", "Wed",
		"Thu", "Fri", "Sat"
	}, {
		"Sunday", "Monday", "Tuesday", "Wednesday",
		"Thursday", "Friday", "Saturday"
	},

	/* X_fmt */
	"%H:%M:%S",

	/*
	** x_fmt
	** C99 requires this format.
	** Using just numbers (as here) makes Quakers happier;
	** it's also compatible with SVR4.
	*/
	"%m/%d/%y",

	/*
	** c_fmt
	** C99 requires this format.
	** Previously this code used "%D %X", but we now conform to C99.
	** Note that
	**      "%a %b %d %H:%M:%S %Y"
	** is used by Solaris 2.3.
	*/
	"%a %b %e %T %Y",

	/* am */
	"AM",

	/* pm */
	"PM",

	/* date_fmt */
	"%a %b %e %H:%M:%S %Z %Y"
};


static char *
_add(const char * str, char * pt, const char * const ptlim)
{
	while (pt < ptlim && (*pt = *str++) != '\0')
		++pt;
	return pt;
}


static char *
_conv(const int n, const char * const format, char * const pt, const char * const ptlim)
{
	char	buf[INT_STRLEN_MAXIMUM(int) + 1];

	(void) _snprintf(buf, sizeof buf, format, n);
	return _add(buf, pt, ptlim);
}


static char *
_fmt(const char * format, const struct tm * const t, char * pt, const char * const ptlim, int * warnp)
{
	for ( ; *format; ++format) {
		if (*format == '%') {
label:
			switch (*++format) {
			case '\0':
				--format;
				break;
			case 'A':
				pt = _add((t->tm_wday < 0 ||
					t->tm_wday >= DAYSPERWEEK) ?
					"?" : Locale->weekday[t->tm_wday],
					pt, ptlim);
				continue;
			case 'a':
				pt = _add((t->tm_wday < 0 ||
					t->tm_wday >= DAYSPERWEEK) ?
					"?" : Locale->wday[t->tm_wday],
					pt, ptlim);
				continue;
			case 'B':
				pt = _add((t->tm_mon < 0 ||
					t->tm_mon >= MONSPERYEAR) ?
					"?" : Locale->month[t->tm_mon],
					pt, ptlim);
				continue;
			case 'b':
			case 'h':
				pt = _add((t->tm_mon < 0 ||
					t->tm_mon >= MONSPERYEAR) ?
					"?" : Locale->mon[t->tm_mon],
					pt, ptlim);
				continue;
			case 'C':
				/*
				** %C used to do a...
				**	_fmt("%a %b %e %X %Y", t);
				** ...whereas now POSIX 1003.2 calls for
				** something completely different.
				** (ado, 1993-05-24)
				*/
				pt = _conv((t->tm_year + TM_YEAR_BASE) / 100,
					"%02d", pt, ptlim);
				continue;
			case 'c':
				{
				int warn2 = IN_SOME;

				pt = _fmt(Locale->c_fmt, t, pt, ptlim, warnp);
				if (warn2 == IN_ALL)
					warn2 = IN_THIS;
				if (warn2 > *warnp)
					*warnp = warn2;
				}
				continue;
			case 'D':
				pt = _fmt("%m/%d/%y", t, pt, ptlim, warnp);
				continue;
			case 'd':
				pt = _conv(t->tm_mday, "%02d", pt, ptlim);
				continue;
			case 'E':
			case 'O':
				/*
				** C99 locale modifiers.
				** The sequences
				**	%Ec %EC %Ex %EX %Ey %EY
				**	%Od %oe %OH %OI %Om %OM
				**	%OS %Ou %OU %OV %Ow %OW %Oy
				** are supposed to provide alternate
				** representations.
				*/
				goto label;
			case 'e':
				pt = _conv(t->tm_mday, "%2d", pt, ptlim);
				continue;
			case 'F':
				pt = _fmt("%Y-%m-%d", t, pt, ptlim, warnp);
				continue;
			case 'H':
				pt = _conv(t->tm_hour, "%02d", pt, ptlim);
				continue;
			case 'I':
				pt = _conv((t->tm_hour % 12) ?
					(t->tm_hour % 12) : 12,
					"%02d", pt, ptlim);
				continue;
			case 'j':
				pt = _conv(t->tm_yday + 1, "%03d", pt, ptlim);
				continue;
			case 'k':
				/*
				** This used to be...
				**	_conv(t->tm_hour % 12 ?
				**		t->tm_hour % 12 : 12, 2, ' ');
				** ...and has been changed to the below to
				** match SunOS 4.1.1 and Arnold Robbins'
				** strftime version 3.0.  That is, "%k" and
				** "%l" have been swapped.
				** (ado, 1993-05-24)
				*/
				pt = _conv(t->tm_hour, "%2d", pt, ptlim);
				continue;
#ifdef KITCHEN_SINK
			case 'K':
				/*
				** After all this time, still unclaimed!
				*/
				pt = _add("kitchen sink", pt, ptlim);
				continue;
#endif /* defined KITCHEN_SINK */
			case 'l':
				/*
				** This used to be...
				**	_conv(t->tm_hour, 2, ' ');
				** ...and has been changed to the below to
				** match SunOS 4.1.1 and Arnold Robbin's
				** strftime version 3.0.  That is, "%k" and
				** "%l" have been swapped.
				** (ado, 1993-05-24)
				*/
				pt = _conv((t->tm_hour % 12) ?
					(t->tm_hour % 12) : 12,
					"%2d", pt, ptlim);
				continue;
			case 'M':
				pt = _conv(t->tm_min, "%02d", pt, ptlim);
				continue;
			case 'm':
				pt = _conv(t->tm_mon + 1, "%02d", pt, ptlim);
				continue;
			case 'n':
				pt = _add("\n", pt, ptlim);
				continue;
			case 'p':
				pt = _add((t->tm_hour >= (HOURSPERDAY / 2)) ?
					Locale->pm :
					Locale->am,
					pt, ptlim);
				continue;
			case 'R':
				pt = _fmt("%H:%M", t, pt, ptlim, warnp);
				continue;
			case 'r':
				pt = _fmt("%I:%M:%S %p", t, pt, ptlim, warnp);
				continue;
			case 'S':
				pt = _conv(t->tm_sec, "%02d", pt, ptlim);
				continue;
			case 's':
				{
					struct tm	tm;
					char		buf[INT_STRLEN_MAXIMUM(
								time_t) + 1];
					time_t		mkt;

					tm = *t;
					mkt = mktime(&tm);
					if (TYPE_SIGNED(time_t))
						(void) _snprintf(buf, sizeof buf,
						    "%ld", (long) mkt);
					else	(void) _snprintf(buf, sizeof buf,
						    "%lu", (unsigned long) mkt);
					pt = _add(buf, pt, ptlim);
				}
				continue;
			case 'T':
				pt = _fmt("%H:%M:%S", t, pt, ptlim, warnp);
				continue;
			case 't':
				pt = _add("\t", pt, ptlim);
				continue;
			case 'U':
				pt = _conv((t->tm_yday + DAYSPERWEEK -
					t->tm_wday) / DAYSPERWEEK,
					"%02d", pt, ptlim);
				continue;
			case 'u':
				/*
				** From Arnold Robbins' strftime version 3.0:
				** "ISO 8601: Weekday as a decimal number
				** [1 (Monday) - 7]"
				** (ado, 1993-05-24)
				*/
				pt = _conv((t->tm_wday == 0) ?
					DAYSPERWEEK : t->tm_wday,
					"%d", pt, ptlim);
				continue;
			case 'V':	/* ISO 8601 week number */
			case 'G':	/* ISO 8601 year (four digits) */
			case 'g':	/* ISO 8601 year (two digits) */
				{
					int	year;
					int	yday;
					int	wday;
					int	w;

					year = t->tm_year + TM_YEAR_BASE;
					yday = t->tm_yday;
					wday = t->tm_wday;
					for ( ; ; ) {
						int	len;
						int	bot;
						int	top;

						len = isleap(year) ?
							DAYSPERLYEAR :
							DAYSPERNYEAR;
						/*
						** What yday (-3 ... 3) does
						** the ISO year begin on?
						*/
						bot = ((yday + 11 - wday) %
							DAYSPERWEEK) - 3;
						/*
						** What yday does the NEXT
						** ISO year begin on?
						*/
						top = bot -
							(len % DAYSPERWEEK);
						if (top < -3)
							top += DAYSPERWEEK;
						top += len;
						if (yday >= top) {
							++year;
							w = 1;
							break;
						}
						if (yday >= bot) {
							w = 1 + ((yday - bot) /
								DAYSPERWEEK);
							break;
						}
						--year;
						yday += isleap(year) ?
							DAYSPERLYEAR :
							DAYSPERNYEAR;
					}
					if (*format == 'V')
						pt = _conv(w, "%02d",
							pt, ptlim);
					else if (*format == 'g') {
						*warnp = IN_ALL;
						pt = _conv(year % 100, "%02d",
							pt, ptlim);
					} else	pt = _conv(year, "%04d",
							pt, ptlim);
				}
				continue;
			case 'v':
				pt = _fmt("%e-%b-%Y", t, pt, ptlim, warnp);
				continue;
			case 'W':
				pt = _conv((t->tm_yday + DAYSPERWEEK -
					(t->tm_wday ?
					(t->tm_wday - 1) :
					(DAYSPERWEEK - 1))) / DAYSPERWEEK,
					"%02d", pt, ptlim);
				continue;
			case 'w':
				pt = _conv(t->tm_wday, "%d", pt, ptlim);
				continue;
			case 'X':
				pt = _fmt(Locale->X_fmt, t, pt, ptlim, warnp);
				continue;
			case 'x':
				{
				int	warn2 = IN_SOME;

				pt = _fmt(Locale->x_fmt, t, pt, ptlim, &warn2);
				if (warn2 == IN_ALL)
					warn2 = IN_THIS;
				if (warn2 > *warnp)
					*warnp = warn2;
				}
				continue;
			case 'y':
				*warnp = IN_ALL;
				pt = _conv((t->tm_year + TM_YEAR_BASE) % 100,
					"%02d", pt, ptlim);
				continue;
			case 'Y':
				pt = _conv(t->tm_year + TM_YEAR_BASE, "%04d",
					pt, ptlim);
				continue;
			case 'Z':
				if (t->tm_isdst >= 0)
					pt = _add(tzname[t->tm_isdst != 0],
						pt, ptlim);
				/*
				** C99 says that %Z must be replaced by the
				** empty string if the time zone is not
				** determinable.
				*/
				continue;
			case 'z':
				{
				int		diff = -timezone;
				char const *	sign;

				if (diff < 0) {
					sign = "-";
					diff = -diff;
				} else	sign = "+";
				pt = _add(sign, pt, ptlim);
				diff /= 60;
				pt = _conv((diff/60)*100 + diff%60,
					"%04d", pt, ptlim);
				}
				continue;
			case '+':
				pt = _fmt(Locale->date_fmt, t, pt, ptlim,
					warnp);
				continue;
			case '%':
			default:
				break;
			}
		}
		if (pt == ptlim)
			break;
		*pt++ = *format;
	}
	return pt;
}

size_t
strftime(char * const s, const size_t maxsize, const char *format, const struct tm * const t)
{
	char *	p;
	int	warn;

	//tzset();

	warn = IN_NONE;
	p = _fmt(((format == NULL) ? "%c" : format), t, s, s + maxsize, &warn);

	if (p == s + maxsize) {
		if (maxsize > 0)
			s[maxsize - 1] = '\0';
		return 0;
	}
	*p = '\0';
	return p - s;
}

extern "C"
{

/* Not needed in VS Studio 2005 */

size_t wcsftime(wchar_t *s,
                const size_t maxsize,
                const wchar_t *format,
                const struct tm *t)
{
    wxCharBuffer sBuf(maxsize/sizeof(wchar_t));

    wxString formatStr(format);
    wxCharBuffer bufFormatStr(formatStr.mb_str());

    size_t sz = strftime(sBuf.data(), maxsize/sizeof(wchar_t), bufFormatStr, t);

    wxMB2WC(s, sBuf, maxsize);

    return sz;
}

} /* extern "C" */

#define is_leap(y)   (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0))
#define SECONDS_IN_ONE_MINUTE      60
#define DAYS_IN_ONE_YEAR          365
#define SECONDS_IN_ONE_MIN         60
#define SECONDS_IN_ONE_HOUR      3600
#define SECONDS_IN_ONE_DAY      86400
#define DEFAULT_TIMEZONE        28800
#define DO_GMTIME                   0
#define DO_LOCALTIME                1


long timezone ; // global variable


////////////////////////////////////////////////////////////////////////
// Common code for localtime and gmtime (static)
////////////////////////////////////////////////////////////////////////

static struct tm * __cdecl common_localtime(const time_t *t, BOOL bLocal)
{
    wxLongLong i64;
    FILETIME   ft;
    wxString str ;
    SYSTEMTIME SystemTime;
    TIME_ZONE_INFORMATION pTz;
    static struct tm st_res ;             // data holder
    static struct tm * res = &st_res ;    // data pointer
    int iLeap;
    const unsigned short int __mon_yday[2][13] =
    {
        // Normal years
        { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
        // Leap years
        { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
    };

    if (!*t)
        ::GetLocalTime(&SystemTime);
    else
    {
        i64 = *t;
        i64 = i64 * 10000000 + 116444736000000000;

        ft.dwLowDateTime  = i64.GetLo();
        ft.dwHighDateTime = i64.GetHi();

        ::FileTimeToSystemTime(&ft, &SystemTime);
    }

    ::GetTimeZoneInformation(&pTz);

    ///////////////////////////////////////////////
    // Set timezone
    timezone = pTz.Bias * SECONDS_IN_ONE_MINUTE ;
    ///////////////////////////////////////////////

    iLeap = is_leap(SystemTime.wYear) ;

    res->tm_hour = SystemTime.wHour;
    res->tm_min  = SystemTime.wMinute;
    res->tm_sec  = SystemTime.wSecond;

    res->tm_mday = SystemTime.wDay;
    res->tm_mon = SystemTime.wMonth - 1; // this the correct month but localtime returns month aligned to zero
    res->tm_year = SystemTime.wYear;     // this the correct year
    res->tm_year = res->tm_year - 1900;  // but localtime returns the value starting at the 1900

    res->tm_wday = SystemTime.wDayOfWeek;
    res->tm_yday = __mon_yday[iLeap][res->tm_mon] + SystemTime.wDay - 1; // localtime returns year-day aligned to zero

    // if localtime behavior and daylight saving
    if (bLocal && pTz.DaylightBias != 0)
        res->tm_isdst = 1;
    else
        res->tm_isdst = 0; // without daylight saving or gmtime

    return res;
}

extern "C"
{

////////////////////////////////////////////////////////////////////////
// Receive the number of seconds elapsed since midnight(00:00:00)
// and convert a time value and corrects for the local time zone
////////////////////////////////////////////////////////////////////////
struct tm * __cdecl localtime(const time_t * t)
{
    return common_localtime(t, DO_LOCALTIME) ;
}

////////////////////////////////////////////////////////////////////////
// Receives the number of seconds elapsed since midnight(00:00:00)
// and converts a time value WITHOUT correcting for the local time zone
////////////////////////////////////////////////////////////////////////
struct tm * __cdecl gmtime(const time_t *t)
{
    return common_localtime(t, DO_GMTIME) ;
}

}

////////////////////////////////////////////////////////////////////////
// Common code for conversion of struct tm into time_t   (static)
////////////////////////////////////////////////////////////////////////
static time_t __cdecl common_tm_to_time(int day, int month, int year, int hour, int minute, int second)
{
#if 1
    // Use mktime since it seems less broken
    tm t;
    t.tm_isdst = -1;
    t.tm_hour = hour;
    t.tm_mday = day;
    t.tm_min = minute;
    t.tm_mon = month-1;
    t.tm_sec = second;
    t.tm_wday = -1;
    t.tm_yday = -1;
    t.tm_year = year - 1900;
    return mktime(& t);
#else
    time_t prog = 0 ;
    static int mdays[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 } ;

    while (--month)
    {
        prog += mdays[month - 1] ;
        if (month == 2 && is_leap(year))
            prog++ ;
    }

    // Calculate seconds in elapsed days
    prog = day - 1 ;        // align first day of the year to zero
    prog += (DAYS_IN_ONE_YEAR * (year - 1970) + (year - 1901) / 4 - 19) ;
    prog *= SECONDS_IN_ONE_DAY ;

    // Add Calculated elapsed seconds in the current day
    prog += (hour * SECONDS_IN_ONE_HOUR + minute *
                               SECONDS_IN_ONE_MIN + second) ;

    return prog ;
#endif
}

extern "C"
{

////////////////////////////////////////////////////////////////////////
// Returns the number of seconds elapsed since
// midnight(00:00:00) of 1 January 1970
////////////////////////////////////////////////////////////////////////
time_t __cdecl time(time_t *t)
{
    time_t prog = 0 ;

    if (t != NULL)
    {
        SYSTEMTIME SystemTime;

        ::GetLocalTime(&SystemTime) ;
        prog = common_tm_to_time(SystemTime.wDay, SystemTime.wMonth, SystemTime.wYear,
                                 SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond) ;
        *t = prog ;
    }

    return prog ;
}

////////////////////////////////////////////////////////////////////////
// Converts the local time provided by struct tm
// into a time_t calendar value
// Implementation from OpenBSD
////////////////////////////////////////////////////////////////////////

#if 1
int month_to_day[12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};

time_t mktime(struct tm *t)
{
        short  month, year;
        time_t result;

        month = t->tm_mon;
        year = t->tm_year + month / 12 + 1900;
        month %= 12;
        if (month < 0)
        {
                year -= 1;
                month += 12;
        }
        result = (year - 1970) * 365 + (year - 1969) / 4 + month_to_day[month];
        result = (year - 1970) * 365 + month_to_day[month];
        if (month <= 1)
                year -= 1;
        result += (year - 1968) / 4;
        result -= (year - 1900) / 100;
        result += (year - 1600) / 400;
        result += t->tm_mday;
        result -= 1;
        result *= 24;
        result += t->tm_hour;
        result *= 60;
        result += t->tm_min;
        result *= 60;
        result += t->tm_sec;
        return(result);
}

#else
time_t __cdecl mktime(struct tm *t)
{
    return (common_tm_to_time(t->tm_mday, t->tm_mon+1, t->tm_year+1900, t->tm_hour, t->tm_min, t->tm_sec)) ;
}
#endif

} // extern "C"

#endif // VC8/!VC8
Commit	Line	Data
1c193821 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/msw/wince/time.cpp
	3	// Purpose: Implements missing time functionality for WinCE
f22cc0b4	4	// Author: Marco Cavallini (MCK) - wx@koansoftware.com
e09080ec	5	// Modified by: Vadim Zeitlin for VC8 support
f22cc0b4	6	// Created: 31-08-2003
11e70ae6	7	// RCS-ID: $Id$
991420e6	8	// Copyright: (c) Marco Cavallini
65571936	9	// Licence: wxWindows licence
1c193821 JS	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ===========================================================================
	13	// declarations
	14	// ===========================================================================
	15
	16	// ---------------------------------------------------------------------------
	17	// headers
	18	// ---------------------------------------------------------------------------
	19
1c193821 JS	20	// For compilers that support precompilation, includes "wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
	27	#ifndef WX_PRECOMP
9ed0d735	28	#include "wx/msw/wrapwin.h"
1c193821 JS	29	#endif
	30
	31	#include "wx/msw/wince/time.h"
553d7089	32
e09080ec VZ	33	#if defined(__VISUALC__) && (__VISUALC__ >= 1400)
	34
	35	// VC8 does provide the time functions but not the standard ones
	36	#include <altcecrt.h>
	37
	38	time_t __cdecl time(time_t *t)
	39	{
	40	__time64_t t64;
	41	if ( !_time64(&t64) )
	42	return (time_t)-1;
	43
	44	if ( t )
	45	*t = (time_t)t64;
	46
	47	return (time_t)t64;
	48	}
	49
	50	time_t __cdecl mktime(struct tm *t)
	51	{
	52	return (time_t)_mktime64(t);
	53	}
	54
	55	#else // !VC8
	56
553d7089 JS	57	/////////////////////////////////////////////////////////////////////////////////////////////
	58	// //
	59	// strftime() - taken from OpenBSD //
	60	// //
	61	/////////////////////////////////////////////////////////////////////////////////////////////
	62
	63	#define IN_NONE 0
	64	#define IN_SOME 1
	65	#define IN_THIS 2
	66	#define IN_ALL 3
	67	#define CHAR_BIT 8
	68
	69	#define TYPE_BIT(type) (sizeof (type) * CHAR_BIT)
	70	#define TYPE_SIGNED(type) (((type) -1) < 0)
	71
	72	#define INT_STRLEN_MAXIMUM(type) \
	73	((TYPE_BIT(type) - TYPE_SIGNED(type)) * 302 / 1000 + 1 + TYPE_SIGNED(type))
	74
	75	#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 \|\| ((y) % 400) == 0))
	76
	77	#define MONSPERYEAR 12
	78	#define DAYSPERWEEK 7
	79	#define TM_YEAR_BASE 1900
	80	#define HOURSPERDAY 24
	81	#define DAYSPERNYEAR 365
	82	#define DAYSPERLYEAR 366
	83
	84	static char wildabbr[] = "WILDABBR";
	85
	86	char * tzname[2] = {
	87	wildabbr,
	88	wildabbr
	89	};
	90
	91
	92	#define Locale (&C_time_locale)
	93
	94	struct lc_time_T {
	95	const char * mon[MONSPERYEAR];
	96	const char * month[MONSPERYEAR];
	97	const char * wday[DAYSPERWEEK];
	98	const char * weekday[DAYSPERWEEK];
	99	const char * X_fmt;
	100	const char * x_fmt;
	101	const char * c_fmt;
	102	const char * am;
	103	const char * pm;
	104	const char * date_fmt;
	105	};
	106
	107	static const struct lc_time_T C_time_locale = {
	108	{
	109	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
	110	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
	111	}, {
	112	"January", "February", "March", "April", "May", "June",
	113	"July", "August", "September", "October", "November", "December"
	114	}, {
	115	"Sun", "Mon", "Tue", "Wed",
	116	"Thu", "Fri", "Sat"
	117	}, {
	118	"Sunday", "Monday", "Tuesday", "Wednesday",
	119	"Thursday", "Friday", "Saturday"
	120	},
121
122	/* X_fmt */
123	"%H:%M:%S",
124
125	/*
126	** x_fmt
127	** C99 requires this format.
128	** Using just numbers (as here) makes Quakers happier;
129	** it's also compatible with SVR4.
130	*/
131	"%m/%d/%y",
132
133	/*
134	** c_fmt
135	** C99 requires this format.
136	** Previously this code used "%D %X", but we now conform to C99.
137	** Note that
138	** "%a %b %d %H:%M:%S %Y"
139	** is used by Solaris 2.3.
140	*/
141	"%a %b %e %T %Y",
142
143	/* am */
144	"AM",
145
146	/* pm */
147	"PM",
148
149	/* date_fmt */
150	"%a %b %e %H:%M:%S %Z %Y"
151	};
152
153
154	static char *
155	_add(const char * str, char * pt, const char * const ptlim)
156	{
157	while (pt < ptlim && (pt = str++) != '\0')
158	++pt;
159	return pt;
160	}
161
162
163	static char *
164	_conv(const int n, const char * const format, char * const pt, const char * const ptlim)
165	{
166	char buf[INT_STRLEN_MAXIMUM(int) + 1];
167
168	(void) _snprintf(buf, sizeof buf, format, n);
169	return _add(buf, pt, ptlim);
170	}
171
172
173	static char *
174	_fmt(const char * format, const struct tm * const t, char * pt, const char * const ptlim, int * warnp)
175	{
176	for ( ; *format; ++format) {
177	if (*format == '%') {
178	label:
179	switch (*++format) {
180	case '\0':
181	--format;
182	break;
183	case 'A':
184	pt = _add((t->tm_wday < 0 \|\|
185	t->tm_wday >= DAYSPERWEEK) ?
186	"?" : Locale->weekday[t->tm_wday],
187	pt, ptlim);
188	continue;
189	case 'a':
190	pt = _add((t->tm_wday < 0 \|\|
191	t->tm_wday >= DAYSPERWEEK) ?
192	"?" : Locale->wday[t->tm_wday],
193	pt, ptlim);
194	continue;
195	case 'B':
196	pt = _add((t->tm_mon < 0 \|\|
197	t->tm_mon >= MONSPERYEAR) ?
198	"?" : Locale->month[t->tm_mon],
199	pt, ptlim);
200	continue;
201	case 'b':
202	case 'h':
203	pt = _add((t->tm_mon < 0 \|\|
204	t->tm_mon >= MONSPERYEAR) ?
205	"?" : Locale->mon[t->tm_mon],
206	pt, ptlim);
207	continue;
208	case 'C':
209	/*
210	** %C used to do a...
211	** _fmt("%a %b %e %X %Y", t);
212	** ...whereas now POSIX 1003.2 calls for
213	** something completely different.
214	** (ado, 1993-05-24)
215	*/
216	pt = _conv((t->tm_year + TM_YEAR_BASE) / 100,
217	"%02d", pt, ptlim);
218	continue;
219	case 'c':
220	{
221	int warn2 = IN_SOME;
222
223	pt = _fmt(Locale->c_fmt, t, pt, ptlim, warnp);
224	if (warn2 == IN_ALL)
225	warn2 = IN_THIS;
226	if (warn2 > *warnp)
227	*warnp = warn2;
228	}
229	continue;
230	case 'D':
231	pt = _fmt("%m/%d/%y", t, pt, ptlim, warnp);
232	continue;
233	case 'd':
234	pt = _conv(t->tm_mday, "%02d", pt, ptlim);
235	continue;
236	case 'E':
237	case 'O':
238	/*
239	** C99 locale modifiers.
240	** The sequences
241	** %Ec %EC %Ex %EX %Ey %EY
242	** %Od %oe %OH %OI %Om %OM
243	** %OS %Ou %OU %OV %Ow %OW %Oy
244	** are supposed to provide alternate
245	** representations.
246	*/
247	goto label;
248	case 'e':
249	pt = _conv(t->tm_mday, "%2d", pt, ptlim);
250	continue;
251	case 'F':
252	pt = _fmt("%Y-%m-%d", t, pt, ptlim, warnp);
253	continue;
254	case 'H':
255	pt = _conv(t->tm_hour, "%02d", pt, ptlim);
256	continue;
257	case 'I':
258	pt = _conv((t->tm_hour % 12) ?
259	(t->tm_hour % 12) : 12,
260	"%02d", pt, ptlim);
261	continue;
262	case 'j':
263	pt = _conv(t->tm_yday + 1, "%03d", pt, ptlim);
264	continue;
265	case 'k':
266	/*
267	** This used to be...
268	** _conv(t->tm_hour % 12 ?
269	** t->tm_hour % 12 : 12, 2, ' ');
270	** ...and has been changed to the below to
271	** match SunOS 4.1.1 and Arnold Robbins'
272	** strftime version 3.0. That is, "%k" and
273	** "%l" have been swapped.
274	** (ado, 1993-05-24)
275	*/
276	pt = _conv(t->tm_hour, "%2d", pt, ptlim);
277	continue;
278	#ifdef KITCHEN_SINK
279	case 'K':
280	/*
281	** After all this time, still unclaimed!
282	*/
283	pt = _add("kitchen sink", pt, ptlim);
284	continue;
285	#endif /* defined KITCHEN_SINK */
286	case 'l':
287	/*
288	** This used to be...
289	** _conv(t->tm_hour, 2, ' ');
290	** ...and has been changed to the below to
291	** match SunOS 4.1.1 and Arnold Robbin's
292	** strftime version 3.0. That is, "%k" and
293	** "%l" have been swapped.
294	** (ado, 1993-05-24)
295	*/
296	pt = _conv((t->tm_hour % 12) ?
297	(t->tm_hour % 12) : 12,
298	"%2d", pt, ptlim);
299	continue;
300	case 'M':
301	pt = _conv(t->tm_min, "%02d", pt, ptlim);
302	continue;
303	case 'm':
304	pt = _conv(t->tm_mon + 1, "%02d", pt, ptlim);
305	continue;
306	case 'n':
307	pt = _add("\n", pt, ptlim);
308	continue;
309	case 'p':
310	pt = _add((t->tm_hour >= (HOURSPERDAY / 2)) ?
311	Locale->pm :
312	Locale->am,
313	pt, ptlim);
314	continue;
315	case 'R':
316	pt = _fmt("%H:%M", t, pt, ptlim, warnp);
317	continue;
318	case 'r':
319	pt = _fmt("%I:%M:%S %p", t, pt, ptlim, warnp);
320	continue;
321	case 'S':
322	pt = _conv(t->tm_sec, "%02d", pt, ptlim);
323	continue;
324	case 's':
325	{
326	struct tm tm;
327	char buf[INT_STRLEN_MAXIMUM(
328	time_t) + 1];
329	time_t mkt;
330
331	tm = *t;
332	mkt = mktime(&tm);
333	if (TYPE_SIGNED(time_t))
334	(void) _snprintf(buf, sizeof buf,
335	"%ld", (long) mkt);
336	else (void) _snprintf(buf, sizeof buf,
337	"%lu", (unsigned long) mkt);
338	pt = _add(buf, pt, ptlim);
339	}
340	continue;
341	case 'T':
342	pt = _fmt("%H:%M:%S", t, pt, ptlim, warnp);
343	continue;
344	case 't':
345	pt = _add("\t", pt, ptlim);
346	continue;
347	case 'U':
348	pt = _conv((t->tm_yday + DAYSPERWEEK -
349	t->tm_wday) / DAYSPERWEEK,
350	"%02d", pt, ptlim);
351	continue;
352	case 'u':
353	/*
354	** From Arnold Robbins' strftime version 3.0:
355	** "ISO 8601: Weekday as a decimal number
356	** [1 (Monday) - 7]"
357	** (ado, 1993-05-24)
358	*/
359	pt = _conv((t->tm_wday == 0) ?
360	DAYSPERWEEK : t->tm_wday,
361	"%d", pt, ptlim);
362	continue;
363	case 'V': /* ISO 8601 week number */
364	case 'G': /* ISO 8601 year (four digits) */
365	case 'g': /* ISO 8601 year (two digits) */
366	{
367	int year;
368	int yday;
369	int wday;
370	int w;
371
372	year = t->tm_year + TM_YEAR_BASE;
373	yday = t->tm_yday;
374	wday = t->tm_wday;
375	for ( ; ; ) {
376	int len;
377	int bot;
378	int top;
379
380	len = isleap(year) ?
381	DAYSPERLYEAR :
382	DAYSPERNYEAR;
383	/*
384	** What yday (-3 ... 3) does
385	** the ISO year begin on?
386	*/
387	bot = ((yday + 11 - wday) %
388	DAYSPERWEEK) - 3;
389	/*
390	** What yday does the NEXT
391	** ISO year begin on?
392	*/
393	top = bot -
394	(len % DAYSPERWEEK);
395	if (top < -3)
396	top += DAYSPERWEEK;
397	top += len;
398	if (yday >= top) {
399	++year;
400	w = 1;
401	break;
402	}
403	if (yday >= bot) {
404	w = 1 + ((yday - bot) /
405	DAYSPERWEEK);
406	break;
407	}
408	--year;
409	yday += isleap(year) ?
410	DAYSPERLYEAR :
411	DAYSPERNYEAR;
412	}
413	if (*format == 'V')
414	pt = _conv(w, "%02d",
415	pt, ptlim);
416	else if (*format == 'g') {
417	*warnp = IN_ALL;
418	pt = _conv(year % 100, "%02d",
419	pt, ptlim);
420	} else pt = _conv(year, "%04d",
421	pt, ptlim);
422	}
423	continue;
424	case 'v':
425	pt = _fmt("%e-%b-%Y", t, pt, ptlim, warnp);
426	continue;
427	case 'W':
428	pt = _conv((t->tm_yday + DAYSPERWEEK -
429	(t->tm_wday ?
430	(t->tm_wday - 1) :
431	(DAYSPERWEEK - 1))) / DAYSPERWEEK,
432	"%02d", pt, ptlim);
433	continue;
434	case 'w':
435	pt = _conv(t->tm_wday, "%d", pt, ptlim);
436	continue;
437	case 'X':
438	pt = _fmt(Locale->X_fmt, t, pt, ptlim, warnp);
439	continue;
440	case 'x':
441	{
442	int warn2 = IN_SOME;
443
444	pt = _fmt(Locale->x_fmt, t, pt, ptlim, &warn2);
445	if (warn2 == IN_ALL)
446	warn2 = IN_THIS;
447	if (warn2 > *warnp)
448	*warnp = warn2;
449	}
450	continue;
451	case 'y':
452	*warnp = IN_ALL;
453	pt = _conv((t->tm_year + TM_YEAR_BASE) % 100,
454	"%02d", pt, ptlim);
455	continue;
456	case 'Y':
457	pt = _conv(t->tm_year + TM_YEAR_BASE, "%04d",
458	pt, ptlim);
459	continue;
460	case 'Z':
461	if (t->tm_isdst >= 0)
462	pt = _add(tzname[t->tm_isdst != 0],
463	pt, ptlim);
464	/*
465	** C99 says that %Z must be replaced by the
466	** empty string if the time zone is not
467	** determinable.
468	*/
469	continue;
470	case 'z':
471	{
d6327899	472	int diff = -timezone;
553d7089 JS	473	char const * sign;
553d7089 JS	474
553d7089 JS	475	if (diff < 0) {
	476	sign = "-";
	477	diff = -diff;
	478	} else sign = "+";
	479	pt = _add(sign, pt, ptlim);
	480	diff /= 60;
	481	pt = _conv((diff/60)*100 + diff%60,
	482	"%04d", pt, ptlim);
	483	}
	484	continue;
	485	case '+':
	486	pt = _fmt(Locale->date_fmt, t, pt, ptlim,
	487	warnp);
	488	continue;
	489	case '%':
	490	default:
	491	break;
	492	}
	493	}
	494	if (pt == ptlim)
	495	break;
	496	pt++ = format;
	497	}
	498	return pt;
	499	}
	500
	501	size_t
	502	strftime(char * const s, const size_t maxsize, const char format, const struct tm const t)
	503	{
	504	char * p;
	505	int warn;
	506
	507	//tzset();
	508
	509	warn = IN_NONE;
	510	p = _fmt(((format == NULL) ? "%c" : format), t, s, s + maxsize, &warn);
	511
	512	if (p == s + maxsize) {
	513	if (maxsize > 0)
	514	s[maxsize - 1] = '\0';
	515	return 0;
	516	}
	517	*p = '\0';
	518	return p - s;
	519	}
	520
	521	extern "C"
	522	{
	523
048128e0	524	/* Not needed in VS Studio 2005 */
79f82e1f	525
595191bb VZ	526	size_t wcsftime(wchar_t *s,
	527	const size_t maxsize,
	528	const wchar_t *format,
	529	const struct tm *t)
553d7089	530	{
595191bb VZ	531	wxCharBuffer sBuf(maxsize/sizeof(wchar_t));
595191bb VZ	532
553d7089 JS	533	wxString formatStr(format);
553d7089 JS	534	wxCharBuffer bufFormatStr(formatStr.mb_str());
595191bb	535
11e70ae6	536	size_t sz = strftime(sBuf.data(), maxsize/sizeof(wchar_t), bufFormatStr, t);
595191bb VZ	537
	538	wxMB2WC(s, sBuf, maxsize);
	539
553d7089 JS	540	return sz;
	541	}
	542
	543	} /* extern "C" */
1c193821	544
f22cc0b4	545	#define is_leap(y) (y % 4 == 0 && (y % 100 != 0 \|\| y % 400 == 0))
991420e6 WS	546	#define SECONDS_IN_ONE_MINUTE 60
	547	#define DAYS_IN_ONE_YEAR 365
	548	#define SECONDS_IN_ONE_MIN 60
	549	#define SECONDS_IN_ONE_HOUR 3600
	550	#define SECONDS_IN_ONE_DAY 86400
	551	#define DEFAULT_TIMEZONE 28800
	552	#define DO_GMTIME 0
	553	#define DO_LOCALTIME 1
1c193821	554
1c193821	555
991420e6	556	long timezone ; // global variable
f22cc0b4 JS	557
	558
	559	////////////////////////////////////////////////////////////////////////
	560	// Common code for localtime and gmtime (static)
	561	////////////////////////////////////////////////////////////////////////
cff614f6 JS	562
cff614f6 JS	563	static struct tm * __cdecl common_localtime(const time_t *t, BOOL bLocal)
1c193821	564	{
cff614f6 JS	565	wxLongLong i64;
cff614f6 JS	566	FILETIME ft;
991420e6 WS	567	wxString str ;
	568	SYSTEMTIME SystemTime;
	569	TIME_ZONE_INFORMATION pTz;
	570	static struct tm st_res ; // data holder
	571	static struct tm * res = &st_res ; // data pointer
	572	int iLeap;
	573	const unsigned short int __mon_yday[2][13] =
	574	{
	575	// Normal years
	576	{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
	577	// Leap years
	578	{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
	579	};
	580
cff614f6 JS	581	if (!*t)
	582	::GetLocalTime(&SystemTime);
	583	else
	584	{
	585	i64 = *t;
	586	i64 = i64 * 10000000 + 116444736000000000;
	587
	588	ft.dwLowDateTime = i64.GetLo();
	589	ft.dwHighDateTime = i64.GetHi();
	590
	591	::FileTimeToSystemTime(&ft, &SystemTime);
	592	}
	593
991420e6 WS	594	::GetTimeZoneInformation(&pTz);
	595
	596	///////////////////////////////////////////////
	597	// Set timezone
	598	timezone = pTz.Bias * SECONDS_IN_ONE_MINUTE ;
	599	///////////////////////////////////////////////
	600
	601	iLeap = is_leap(SystemTime.wYear) ;
	602
	603	res->tm_hour = SystemTime.wHour;
	604	res->tm_min = SystemTime.wMinute;
	605	res->tm_sec = SystemTime.wSecond;
	606
	607	res->tm_mday = SystemTime.wDay;
	608	res->tm_mon = SystemTime.wMonth - 1; // this the correct month but localtime returns month aligned to zero
	609	res->tm_year = SystemTime.wYear; // this the correct year
	610	res->tm_year = res->tm_year - 1900; // but localtime returns the value starting at the 1900
	611
	612	res->tm_wday = SystemTime.wDayOfWeek;
	613	res->tm_yday = __mon_yday[iLeap][res->tm_mon] + SystemTime.wDay - 1; // localtime returns year-day aligned to zero
	614
	615	// if localtime behavior and daylight saving
	616	if (bLocal && pTz.DaylightBias != 0)
	617	res->tm_isdst = 1;
	618	else
	619	res->tm_isdst = 0; // without daylight saving or gmtime
f22cc0b4 JS	620
f22cc0b4 JS	621	return res;
1c193821 JS	622	}
1c193821 JS	623
92bdf9f7 VZ	624	extern "C"
	625	{
	626
f22cc0b4 JS	627	////////////////////////////////////////////////////////////////////////
	628	// Receive the number of seconds elapsed since midnight(00:00:00)
	629	// and convert a time value and corrects for the local time zone
	630	////////////////////////////////////////////////////////////////////////
	631	struct tm * __cdecl localtime(const time_t * t)
1c193821	632	{
991420e6	633	return common_localtime(t, DO_LOCALTIME) ;
1c193821 JS	634	}
1c193821 JS	635
f22cc0b4 JS	636	////////////////////////////////////////////////////////////////////////
	637	// Receives the number of seconds elapsed since midnight(00:00:00)
	638	// and converts a time value WITHOUT correcting for the local time zone
	639	////////////////////////////////////////////////////////////////////////
	640	struct tm * __cdecl gmtime(const time_t *t)
1c193821	641	{
991420e6	642	return common_localtime(t, DO_GMTIME) ;
1c193821 JS	643	}
1c193821 JS	644
92bdf9f7	645	}
f22cc0b4 JS	646
	647	////////////////////////////////////////////////////////////////////////
	648	// Common code for conversion of struct tm into time_t (static)
	649	////////////////////////////////////////////////////////////////////////
	650	static time_t __cdecl common_tm_to_time(int day, int month, int year, int hour, int minute, int second)
1c193821	651	{
553d7089 JS	652	#if 1
	653	// Use mktime since it seems less broken
	654	tm t;
	655	t.tm_isdst = -1;
	656	t.tm_hour = hour;
	657	t.tm_mday = day;
	658	t.tm_min = minute;
	659	t.tm_mon = month-1;
	660	t.tm_sec = second;
	661	t.tm_wday = -1;
	662	t.tm_yday = -1;
	663	t.tm_year = year - 1900;
	664	return mktime(& t);
	665	#else
991420e6 WS	666	time_t prog = 0 ;
	667	static int mdays[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 } ;
	668
	669	while (--month)
	670	{
	671	prog += mdays[month - 1] ;
	672	if (month == 2 && is_leap(year))
	673	prog++ ;
	674	}
	675
	676	// Calculate seconds in elapsed days
	677	prog = day - 1 ; // align first day of the year to zero
	678	prog += (DAYS_IN_ONE_YEAR * (year - 1970) + (year - 1901) / 4 - 19) ;
	679	prog *= SECONDS_IN_ONE_DAY ;
	680
	681	// Add Calculated elapsed seconds in the current day
	682	prog += (hour * SECONDS_IN_ONE_HOUR + minute *
	683	SECONDS_IN_ONE_MIN + second) ;
	684
	685	return prog ;
553d7089	686	#endif
1c193821 JS	687	}
1c193821 JS	688
92bdf9f7 VZ	689	extern "C"
92bdf9f7 VZ	690	{
f22cc0b4 JS	691
	692	////////////////////////////////////////////////////////////////////////
	693	// Returns the number of seconds elapsed since
	694	// midnight(00:00:00) of 1 January 1970
	695	////////////////////////////////////////////////////////////////////////
	696	time_t __cdecl time(time_t *t)
1c193821	697	{
991420e6	698	time_t prog = 0 ;
f22cc0b4	699
991420e6 WS	700	if (t != NULL)
	701	{
	702	SYSTEMTIME SystemTime;
f22cc0b4	703
991420e6 WS	704	::GetLocalTime(&SystemTime) ;
	705	prog = common_tm_to_time(SystemTime.wDay, SystemTime.wMonth, SystemTime.wYear,
	706	SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond) ;
	707	*t = prog ;
	708	}
f22cc0b4	709
991420e6	710	return prog ;
1c193821 JS	711	}
1c193821 JS	712
f22cc0b4 JS	713	////////////////////////////////////////////////////////////////////////
	714	// Converts the local time provided by struct tm
	715	// into a time_t calendar value
553d7089	716	// Implementation from OpenBSD
f22cc0b4	717	////////////////////////////////////////////////////////////////////////
f22cc0b4	718
553d7089 JS	719	#if 1
553d7089 JS	720	int month_to_day[12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
f22cc0b4	721
553d7089	722	time_t mktime(struct tm *t)
f22cc0b4	723	{
553d7089 JS	724	short month, year;
	725	time_t result;
	726
	727	month = t->tm_mon;
	728	year = t->tm_year + month / 12 + 1900;
	729	month %= 12;
	730	if (month < 0)
	731	{
	732	year -= 1;
	733	month += 12;
	734	}
	735	result = (year - 1970) * 365 + (year - 1969) / 4 + month_to_day[month];
	736	result = (year - 1970) * 365 + month_to_day[month];
	737	if (month <= 1)
	738	year -= 1;
	739	result += (year - 1968) / 4;
	740	result -= (year - 1900) / 100;
	741	result += (year - 1600) / 400;
	742	result += t->tm_mday;
	743	result -= 1;
	744	result *= 24;
	745	result += t->tm_hour;
	746	result *= 60;
	747	result += t->tm_min;
	748	result *= 60;
	749	result += t->tm_sec;
	750	return(result);
	751	}
f22cc0b4	752
553d7089 JS	753	#else
	754	time_t __cdecl mktime(struct tm *t)
	755	{
	756	return (common_tm_to_time(t->tm_mday, t->tm_mon+1, t->tm_year+1900, t->tm_hour, t->tm_min, t->tm_sec)) ;
f22cc0b4	757	}
553d7089	758	#endif
92bdf9f7 VZ	759
92bdf9f7 VZ	760	} // extern "C"
553d7089	761
e09080ec	762	#endif // VC8/!VC8