path: root/gcsdk/steamextra/rtime.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Encapsulates real world (wall clock) time
//
//=============================================================================

#include "stdafx.h"
#ifdef POSIX
#include <sys/time.h>
#else
#include "winlite.h"
#endif
#include "rtime.h"
#include <time.h>

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

#if defined( WIN32 ) || defined( _PS3 )
// This strptime implementation is taken from the Goolge Site Map Generator project:

// Copyright 2009 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Implement strptime under windows
static const char* kWeekFull[] = {
	"Sunday", "Monday", "Tuesday", "Wednesday",
	"Thursday", "Friday", "Saturday"
};

static const char* kWeekAbbr[] = {
	"Sun", "Mon", "Tue", "Wed",
	"Thu", "Fri", "Sat"
};

static const char* kMonthFull[] = {
	"January", "February", "March", "April", "May", "June",
	"July", "August", "September", "October", "November", "December"
};

static const char* kMonthAbbr[] = {
	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};

static const char* _parse_num(const char* s, int low, int high, int* value) {
	const char* p = s;
	for (*value = 0; *p != NULL && V_isdigit(*p); ++p) {
		*value = (*value) * 10 + static_cast<int>(*p) - static_cast<int>('0');
	}

	if (p == s || *value < low || *value > high) return NULL;
	return p;
}

static char* _strptime(const char *s, const char *format, struct tm *tm) {
	while (*format != NULL && *s != NULL) {
		if (*format != '%') {
			if (*s != *format) return NULL;

			++format;
			++s;
			continue;
		}

		++format;
		int len = 0;
		switch (*format) {
			// weekday name.
	  case 'a':
	  case 'A':
		  tm->tm_wday = -1;
		  for (int i = 0; i < 7; ++i) {
			  len = static_cast<int>(strlen(kWeekAbbr[i]));
			  if (V_strnicmp(kWeekAbbr[i], s, len) == 0) {
				  tm->tm_wday = i;
				  break;
			  }

			  len = static_cast<int>(strlen(kWeekFull[i]));
			  if ( V_strnicmp(kWeekFull[i], s, len) == 0) {
				  tm->tm_wday = i;
				  break;
			  }
		  }
		  if (tm->tm_wday == -1) return NULL;
		  s += len;
		  break;

		  // month name.
	  case 'b':
	  case 'B':
	  case 'h':
		  tm->tm_mon = -1;
		  for (int i = 0; i < 12; ++i) {
			  len = static_cast<int>(strlen(kMonthAbbr[i]));
			  if ( V_strnicmp(kMonthAbbr[i], s, len) == 0) {
				  tm->tm_mon = i;
				  break;
			  }

			  len = static_cast<int>(strlen(kMonthFull[i]));
			  if ( V_strnicmp(kMonthFull[i], s, len) == 0) {
				  tm->tm_mon = i;
				  break;
			  }
		  }
		  if (tm->tm_mon == -1) return NULL;
		  s += len;
		  break;

		  // month [1, 12].
	  case 'm':
		  s = _parse_num(s, 1, 12, &tm->tm_mon);
		  if (s == NULL) return NULL;
		  --tm->tm_mon;
		  break;

		  // day [1, 31].
	  case 'd':
	  case 'e':
		  s = _parse_num(s, 1, 31, &tm->tm_mday);
		  if (s == NULL) return NULL;
		  break;

		  // hour [0, 23].
	  case 'H':
		  s = _parse_num(s, 0, 23, &tm->tm_hour);
		  if (s == NULL) return NULL;
		  break;

		  // minute [0, 59]
	  case 'M':
		  s = _parse_num(s, 0, 59, &tm->tm_min);
		  if (s == NULL) return NULL;
		  break;

		  // seconds [0, 60]. 60 is for leap year.
	  case 'S':
		  s = _parse_num(s, 0, 60, &tm->tm_sec);
		  if (s == NULL) return NULL;
		  break;

		  // year [1900, 9999].
	  case 'Y':
		  s = _parse_num(s, 1900, 9999, &tm->tm_year);
		  if (s == NULL) return NULL;
		  tm->tm_year -= 1900;
		  break;

		  // year [0, 99].
	  case 'y':
		  s = _parse_num(s, 0, 99, &tm->tm_year);
		  if (s == NULL) return NULL;
		  if (tm->tm_year <= 68) {
			  tm->tm_year += 100;
		  }
		  break;
		  // arbitray whitespace.
	  case 't':
	  case 'n':
		  while (V_isspace(*s)) ++s;
		  break;

		  // '%'.
	  case '%':
		  if (*s != '%') return NULL;
		  ++s;
		  break;

		  // All the other format are not supported.
	  default:
		  AssertMsg( false, "Invalid format string to strptime!" );
		  return NULL;
		}
		++format;
	}

	if (*format != NULL) {
		return NULL;
	} else {
		return const_cast<char*>(s);
	}
}

char* strptime(const char *buf, const char *fmt, struct tm *tm) {
	return _strptime(buf, fmt, tm);
}
#endif  // WIN32


// Our cached copy of the current time
RTime32  CRTime::sm_nTimeLastSystemTimeUpdate = 0;	// initialize to large negative value to trigger immediate FileTimeCur update
char CRTime::sm_rgchLocalTimeCur[16]="";
char CRTime::sm_rgchLocalDateCur[16]="";
RTime32 CRTime::sm_nTimeCur = 0;




//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CRTime::CRTime()
{
	if ( sm_nTimeCur == 0 )
	{
		sm_nTimeCur = time(NULL);
	}

	m_nStartTime = sm_nTimeCur;
	m_bGMT = false;
}


//-----------------------------------------------------------------------------
// Purpose: Returns the amount of time that's passed between our time and the
//			current time.
// Output:	Time that's passed between our time and the current time
//-----------------------------------------------------------------------------
int CRTime::CSecsPassed() const
{
	return( sm_nTimeCur - m_nStartTime );
}


//-----------------------------------------------------------------------------
// Purpose: Updates our current time value.  We only
//			update the time once per frame-- the rest of the time, we just
//			access a cached copy of the time.  
//			NOTE: This should only be called once per frame.
//-----------------------------------------------------------------------------
void CRTime::UpdateRealTime()
{
	// BUGBUG Alfred: update this less often than once per frame?
	RTime32 nTimePrev = sm_nTimeCur;
	sm_nTimeCur = time(NULL);

	if ( sm_nTimeCur < nTimePrev )
	{
		// time can go backwards sometimes if clock sync adjusts system time; warn when this happens
		EmitInfo( SPEW_SYSTEM_MISC, SPEW_ALWAYS, LOG_ALWAYS, "Warning: system time went backward by %d seconds\n", ( nTimePrev - sm_nTimeCur ) );
	}

	// update our time from file time once per second
	if ( sm_nTimeCur - sm_nTimeLastSystemTimeUpdate >= 1 )
	{
#ifdef _WIN32
		// get the local time, generate time & date strings and cache the strings, as we will need these
		// frequently for logs.
		SYSTEMTIME systemTimeLocal;
		GetLocalTime( &systemTimeLocal );
		GetTimeFormat( LOCALE_USER_DEFAULT, 0, &systemTimeLocal, "HH:mm:ss", sm_rgchLocalTimeCur, Q_ARRAYSIZE( sm_rgchLocalTimeCur ) );
		GetDateFormat( LOCALE_USER_DEFAULT, 0, &systemTimeLocal, "MM/dd/yy", sm_rgchLocalDateCur, Q_ARRAYSIZE( sm_rgchLocalDateCur ) );
#elif defined(POSIX)
		time_t now; 
		time( &now );
		struct tm tmStruct;
		struct tm *localTime = Plat_gmtime( &now, &tmStruct );
		strftime( sm_rgchLocalTimeCur, Q_ARRAYSIZE( sm_rgchLocalTimeCur ), "%H:%M:%S", localTime );
		strftime( sm_rgchLocalDateCur, Q_ARRAYSIZE( sm_rgchLocalDateCur ), "%m/%d/%y", localTime );
#else
#error "Implement me"
#endif
		sm_nTimeLastSystemTimeUpdate = sm_nTimeCur;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sets the system clock on this box to specified world time
// Input:	rTime32Current - world time to set
//-----------------------------------------------------------------------------
void CRTime::SetSystemClock( RTime32 rTime32Current )
{
#ifdef _WIN32
	FILETIME fileTime;
	SYSTEMTIME systemTime = {0};
	// convert from seconds since 1/1/1970 to filetime (100 nanoseconds since 1/1/1601) with this magic formula courtesy of MSDN
    uint64 ulTmp = ( ( (uint64) rTime32Current ) * 10 * k_nMillion ) + 116444736000000000;
	fileTime.dwLowDateTime = (DWORD) ulTmp;
    fileTime.dwHighDateTime = ulTmp >> 32;

	// convert from filetime to system time (note this also does time zone conversion to UTC)
	BOOL bRet = FileTimeToSystemTime( &fileTime, &systemTime );
	Assert( bRet ); // should never fail
	if ( !bRet )	// but if it does, don't set system clock to garbage
		return;

	// set system time in UTC
	bRet = SetSystemTime( &systemTime );
	Assert( bRet );

	// update our cached time
	sm_nTimeCur = rTime32Current;
#else
	Assert( !"Not implemented" );
#endif // _WIN32
}


//-----------------------------------------------------------------------------
// Purpose: Renders the time
// Output :	ptr to time string
//-----------------------------------------------------------------------------
const char* CRTime::Render( char (&buf)[k_RTimeRenderBufferSize] ) const
{
	return Render( m_nStartTime, buf );
}

//-----------------------------------------------------------------------------
// Purpose: Renders the time - static function
// Input  : rTime32 - time to render
// Output :	ptr to time string
//-----------------------------------------------------------------------------
const char* CRTime::Render( const RTime32 rTime32, char (&buf)[k_RTimeRenderBufferSize] )
{
	if ( !buf )
	{
		Assert( buf );
		return nullptr;
	}

	// The return value string contains exactly 26 characters and has the form:	Wed Jan 02 02:03:55 1980\n\0
	time_t tTime = rTime32;
	char pchTime[32];
	if ( !Plat_ctime( &tTime, pchTime, Q_ARRAYSIZE( pchTime ) ) )
		return 0;

	// Remove '\n'
	Assert( Q_strlen( pchTime ) == 25 );
	pchTime[ 24 ] = '\0';

	if ( rTime32 == k_RTime32Infinite )
		Q_strncpy( buf, "Infinite time value", k_RTimeRenderBufferSize );
	else if ( rTime32 == k_RTime32Nil )
		Q_strncpy( buf, "Nil time value", k_RTimeRenderBufferSize );
	else if ( rTime32 < k_RTime32MinValid )
		Q_strncpy( buf, "Invalid time value", k_RTimeRenderBufferSize );
	else
		Q_strncpy( buf, pchTime, k_RTimeRenderBufferSize );

	return buf;
}

//-----------------------------------------------------------------------------
// Purpose: Get the calendar year (absolute) for the current time
//-----------------------------------------------------------------------------
int CRTime::GetYear() const
{
	time_t timeCur = m_nStartTime;
	struct tm tmStruct;
	struct tm *ptmCur = m_bGMT ? Plat_gmtime( &timeCur, &tmStruct ) : Plat_localtime( &timeCur, &tmStruct );
	return ptmCur->tm_year + 1900;
}


//-----------------------------------------------------------------------------
// Purpose: Get the calendar month (0-11) for the current time
//-----------------------------------------------------------------------------
int CRTime::GetMonth() const
{
	time_t timeCur = m_nStartTime;
	struct tm tmStruct;
	struct tm *ptmCur = m_bGMT ? Plat_gmtime( &timeCur, &tmStruct ) : Plat_localtime( &timeCur, &tmStruct );
	return ptmCur->tm_mon;
}


//-----------------------------------------------------------------------------
// Purpose: Get the day of the calendar year (0-365) for the current time
//-----------------------------------------------------------------------------
int CRTime::GetDayOfYear() const
{
	time_t timeCur = m_nStartTime;
	struct tm tmStruct;
	struct tm *ptmCur = m_bGMT ? Plat_gmtime( &timeCur, &tmStruct ) : Plat_localtime( &timeCur, &tmStruct );
	return ptmCur->tm_yday;
}


//-----------------------------------------------------------------------------
// Purpose: Get the day of the month (1-31) for the current time
//-----------------------------------------------------------------------------
int CRTime::GetDayOfMonth() const
{
	time_t timeCur = m_nStartTime;
	struct tm tmStruct;
	struct tm *ptmCur = m_bGMT ? Plat_gmtime( &timeCur, &tmStruct ) : Plat_localtime( &timeCur, &tmStruct );
	return ptmCur->tm_mday;
}


//-----------------------------------------------------------------------------
// Purpose: Get the day of the week (0-6, 0=Sunday) for the current time
//-----------------------------------------------------------------------------
int CRTime::GetDayOfWeek() const
{
	time_t timeCur = m_nStartTime;
	struct tm tmStruct;
	struct tm *ptmCur = m_bGMT ? Plat_gmtime( &timeCur, &tmStruct ) : Plat_localtime( &timeCur, &tmStruct );
	return ptmCur->tm_wday;
}


//-----------------------------------------------------------------------------
// Purpose: Get the current hour (0-23)
//-----------------------------------------------------------------------------
int CRTime::GetHour( ) const
{
	time_t timeCur = m_nStartTime;
	struct tm tmStruct;
	struct tm *ptmCur = m_bGMT ? Plat_gmtime( &timeCur, &tmStruct ) : Plat_localtime( &timeCur, &tmStruct );
	return ptmCur->tm_hour;
}


//-----------------------------------------------------------------------------
// Purpose: Get the current minute value (0-59)
//-----------------------------------------------------------------------------
int CRTime::GetMinute( ) const
{
	time_t timeCur = m_nStartTime;
	struct tm tmStruct;
	struct tm *ptmCur = m_bGMT ? Plat_gmtime( &timeCur, &tmStruct ) : Plat_localtime( &timeCur, &tmStruct );
	return ptmCur->tm_min;
}


//-----------------------------------------------------------------------------
// Purpose: Get the current second value (0-59)
//-----------------------------------------------------------------------------
int CRTime::GetSecond() const
{
	time_t timeCur = m_nStartTime;
	struct tm tmStruct;
	struct tm *ptmCur = m_bGMT ? Plat_gmtime( &timeCur, &tmStruct ) : Plat_localtime( &timeCur, &tmStruct );
	return ptmCur->tm_sec;
}


//-----------------------------------------------------------------------------
// Purpose: Get the ISO week number
//-----------------------------------------------------------------------------
int CRTime::GetISOWeekOfYear() const
{
	int nDay = GetDayOfYear() - ( 1 + GetDayOfWeek() );
	int nISOWeek = nDay / 7;
	return nISOWeek;
}


//-----------------------------------------------------------------------------
// Purpose: let me know if this is a leap year or not
//-----------------------------------------------------------------------------
/* static */ bool CRTime::BIsLeapYear( int nYear )
{
	// every for years, unless it is a century; or if it is every 4th century
	if ( ( nYear % 4 == 0 && nYear % 100 != 0) || nYear % 400 == 0)
		return true; /* leap */
	else
		return false; /* no leap */
}


//-----------------------------------------------------------------------------
// Purpose: Calculate and return a time value corresponding to given sting
//			Using a format string to convert
// Input:	pchFmt -	Format string that describes how to parse the value
//						YY or YYYY is year, MM month, DD day of the month,
//						hh mm ss is hour minute second.
//						Z0000 is a time-zone offset, eg -0700.
//						Everything except YY is optional (will be considered 0 if not given)
//			pchValue -	String containing the value to covert
// Output:	RTime32
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32FromFmtString( const char *pchFmt, const char* pchValue )
{
	struct tm tm;

	char rgchNum[8];
	char rgchValue[64];

	Q_memset( &tm, 0x0, sizeof( tm ) );
	Q_strncpy( rgchValue, pchValue, sizeof( rgchValue) );

	int cchFmt = Q_strlen( pchFmt );		
	int cchValue = Q_strlen( rgchValue );
	if ( cchFmt != cchValue || cchFmt < 4 )
	{
		Assert( false );
		return k_RTime32Nil;
	}

	const char *pchYYYY = Q_strstr( pchFmt, "YYYY" );
	const char *pchYY = Q_strstr( pchFmt, "YY" );
	const char *pchMM = Q_strstr( pchFmt, "MM" );
	const char *pchMnt = Q_strstr( pchFmt, "Mnt" );
	const char *pchDD = Q_strstr( pchFmt, "DD" );
	const char *pchThh = Q_strstr( pchFmt, "hh" );
	const char *pchTmm = Q_strstr( pchFmt, "mm" );
	const char *pchTss = Q_strstr( pchFmt, "ss" );
	const char *pchTzone = Q_strstr( pchFmt, "Z0000" );

	if ( pchYYYY )
	{
		pchYYYY = rgchValue + ( pchYYYY - pchFmt );
		Q_strncpy( rgchNum, pchYYYY, 5 );
		tm.tm_year = strtol( rgchNum, 0, 10 ) - 1900;
	}
	else if ( pchYY )
	{
		pchYY = rgchValue + ( pchYY - pchFmt );
		Q_strncpy( rgchNum, pchYY, 3 );
		tm.tm_year = strtol( rgchNum, 0, 10 ) + 100;
	}
	else
		return k_RTime32Nil;	// must have a year

	if ( pchMM )
	{
		pchMM = rgchValue + ( pchMM - pchFmt );
		Q_strncpy( rgchNum, pchMM, 3 );
		tm.tm_mon = strtol( rgchNum, 0, 10 ) - 1;
	}
	if ( pchMnt )
	{
		static const char *rgszMonthNames[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
		pchMnt = rgchValue + ( pchMnt - pchFmt );
		int i;
		for ( i = 0; i < 12; i++ )
		{
			if ( !V_strnicmp( rgszMonthNames[i], pchMnt, 3 ) )
				break;
		}
		if ( i < 12 )
			tm.tm_mon = i;
	}
	if ( pchDD )
	{
		pchDD = rgchValue + (pchDD - pchFmt );
		Q_strncpy( rgchNum, pchDD, 3 );
		tm.tm_mday = strtol( rgchNum, 0, 10 );
	}
	if ( pchThh )
	{
		pchThh = rgchValue + ( pchThh - pchFmt );
		Q_strncpy( rgchNum, pchThh, 3 );
		tm.tm_hour = strtol( rgchNum, 0, 10 );
	}
	if ( pchTmm )
	{
		pchTmm = rgchValue + ( pchTmm - pchFmt );
		Q_strncpy( rgchNum, pchTmm, 3 );
		tm.tm_min = strtol( rgchNum, 0, 10 );
	}
	if ( pchTss )
	{
		pchTss = rgchValue + (pchTss - pchFmt );
		Q_strncpy( rgchNum, pchTss, 3 );
		tm.tm_sec = strtol( rgchNum, 0, 10 );
	}
	if ( pchTzone )
	{
		long nOffset = 0;
		pchTzone = rgchValue + (pchTzone - pchFmt);
		Q_strncpy( rgchNum, pchTzone, 6 );
		nOffset = strtol( rgchNum, 0, 10 );
		tm.tm_hour -= nOffset / 100; // to go from -0700 to UTC, need to ADD seven

		// is this a sub-hour timezone? eg +0545 Kathmandu
		int nMinutesOffset = nOffset % 100;
		if ( nMinutesOffset )
			tm.tm_min -= nMinutesOffset;

		// OK, so this is somewhat lame: mktime assumes our tm units are in LOCAL time.
		// However, we have just created a UTC time by using the supplied timezone offset.
		// The rational thing to do here would be to call mkgmtime() instead of mktime(),
		// but that function isn't available in unix-land.
		// SO, instead we will MANUALLY convert this tm back to local time

#if ( defined( _MSC_VER ) && _MSC_VER >= 1900 )
		#define timezone _timezone
		#define daylight _daylight
#endif

		// subtract timezone, which is in SECONDS. timezone is (UTC - local), so local = UTC - timezone
		tm.tm_sec -= timezone;
		// timezone does NOT account for DST, so if we are in DST, we need to ADD an hour. 
		// This is because the value of timezone we subtracted was one hour TOO LARGE
		tm.tm_hour += daylight ? 1 : 0;

	}

	// We don't know if DST is in effect, let the CRT 
	// figure it out
	tm.tm_isdst = -1;

	return mktime( &tm );
}


//-----------------------------------------------------------------------------
// Purpose: Calculate and return a time value corresponding to given sting which is
// expected to be in one of the common HTTP date formats.
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32FromHTTPDateString( const char* pchValue )
{
	// First format here is RFC 822/1123 format
	struct tm tm;
	if ( strptime( pchValue, "%a, %e %b %Y %H:%M:%S", &tm ) )
	{
		return Plat_timegm( &tm );
	}

	// If that failed, try RFC 850/1036 format
	if ( strptime( pchValue, "%a, %e-%b-%y %H:%M:%S", &tm ) )
	{
		return Plat_timegm( &tm );
	}

	// If that also failed, give up
	return k_RTime32Nil;
}


//-----------------------------------------------------------------------------
// Purpose: Parse time from string RFC3339 format (assumes UTC)
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32FromRFC3339UTCString( const char* pchValue )
{

	// UTC only from RFC 3339. Should be 2005-05-15T17:11:51Z
	struct tm tm;
	if ( strptime( pchValue, "%Y-%m-%dT%H:%M:%SZ", &tm ) )
	{
		return Plat_timegm( &tm );
	}	

	// If that also failed, give up
	return k_RTime32Nil;

}


//-----------------------------------------------------------------------------
// Purpose: Output time in RFC3339 format (assumes UTC)
//-----------------------------------------------------------------------------
// STATIC
const char* CRTime::RTime32ToRFC3339UTCString( const RTime32 rTime32, char (&buf)[k_RTimeRenderBufferSize] )
{
	if ( !buf )
	{
		Assert( buf );
		return nullptr;
	}

	// Store the result in a temporary buffer, so that you can use several in a single printf.
	time_t tTime = rTime32; 
	struct tm tmStruct;
	struct tm *ptm = Plat_gmtime( &tTime, &tmStruct );

	if ( rTime32 == k_RTime32Nil || !ptm )
		return "NIL";

	if ( rTime32 == k_RTime32Infinite )
		return "Infinite time value";

	if ( rTime32 < k_RTime32MinValid || !ptm )
		return "Invalid time value";

	Q_snprintf( buf, k_RTimeRenderBufferSize, "%04u-%02u-%02uT%02u:%02u:%02uZ", ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec );	
	return buf;
}


//-----------------------------------------------------------------------------
// Purpose: Calculate and return a time value corresponding to given sting
// "YYYY-MM-DD hh:mm:ss" (copied from sqlhelpers.cpp)
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32FromString( const char* pszValue )
{
	struct tm tm;
	
	char num[5];
	char szValue[64];

	Q_memset( &tm, 0x0, sizeof( tm ) );
	Q_strncpy( szValue, pszValue, sizeof( szValue) );
		
	const char *str= szValue;

	num[0] =*str++; num[1] =*str++; num[2] =*str++; num[3] =*str++; num[4] = 0;
	tm.tm_year = strtol( num, 0, 10 ) - 1900;
	if (*str == '-') str++;
	num[0] = *str++; num[1] = *str++; num[2] = 0;
	tm.tm_mon = strtol( num, 0, 10 ) - 1;
	if (*str == '-') str++;
	num[0] = *str++; num[1] = *str++; num[2] = 0;
	tm.tm_mday = strtol( num, 0, 10 );

	if ( *str != 0 )
	{
		// skip an optional space or T between date and time
		if ( *str == ' ' || *str == 'T' )
			str++;

		// time is given too
		num[0] = *str++; num[1] = *str++; num[2] = 0;
		tm.tm_hour = strtol( num, 0, 10 );
		if (*str == ':') str++;
		num[0] = *str++; num[1] = *str++; num[2] = 0;
		tm.tm_min = strtol( num, 0, 10 );
		if (*str == ':') str++;
		num[0] = *str++; num[1] = *str++; num[2] = 0;
		tm.tm_sec = strtol( num, 0, 10 );
	}
	tm.tm_isdst = -1;

	return mktime( &tm );
}


//-----------------------------------------------------------------------------
// Purpose: Returns a static string "YYYY-MM-DD hh:mm:ss" for given RTime32
// Input:	rTime32 -
//			bNoPunct -	No dashes, colons or spaces will be in the output string
//			bOnlyDate -	Only output the date
// Output:	const char * -- only usable till the next yield
//-----------------------------------------------------------------------------
// STATIC
const char* CRTime::RTime32ToString( const RTime32 rTime32, char (&buf)[k_RTimeRenderBufferSize], bool bNoPunct /*=false*/, bool bOnlyDate /*= false*/ )
{
	if ( !buf )
	{
		return nullptr;
	}

	// Store the result in a temporary buffer, so that you can use several in a single printf.
	time_t tTime = rTime32; 
	struct tm tmStruct;
	struct tm *ptm = Plat_localtime( &tTime, &tmStruct );

	const char *pchOnlyDateFmt = bNoPunct ? "%04u%02u%02u" : "%04u-%02u-%02u";
	const char *pchDateTimeFmt = bNoPunct ? "%04u%02u%02u%02u%02u%02u" : "%04u-%02u-%02u %02u:%02u:%02u";
	if ( rTime32 == k_RTime32Nil || !ptm )
		return "NIL";

	if ( rTime32 == k_RTime32Infinite )
		return "Infinite time value";

	if ( rTime32 < k_RTime32MinValid || !ptm )
		return "Invalid time value";

	if ( bOnlyDate )
	{
		Q_snprintf( buf, k_RTimeRenderBufferSize, pchOnlyDateFmt, 
			ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday );
	}
	else
	{
		Q_snprintf( buf, k_RTimeRenderBufferSize, pchDateTimeFmt, 
			ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday,
			ptm->tm_hour, ptm->tm_min, ptm->tm_sec );
	}

	return buf;
}


//-----------------------------------------------------------------------------
// Purpose: Returns a static string like "Aug 21" for given RTime32
// Input:	rTime32 -
//		
// Output:	const char * -- only usable till the next yield
//-----------------------------------------------------------------------------
// STATIC
const char* CRTime::RTime32ToDayString( const RTime32 rTime32, char (&buf)[k_RTimeRenderBufferSize], bool bGMT )
{
	if ( !buf )
	{
		return nullptr;
	}

	// Store the result in a temporary buffer, so that you can use several in a single printf.
	time_t tTime = rTime32; 
	struct tm tmStruct;
	struct tm *ptm = bGMT ? Plat_gmtime( &tTime, &tmStruct ) : Plat_localtime( &tTime, &tmStruct );

	DbgVerify( strftime( buf, k_RTimeRenderBufferSize, "%b %d", ptm ) );
	return buf;
}



//-----------------------------------------------------------------------------
// Purpose: Calculate and return a time value corresponding to the beginning of
//			the day represented by rtime32
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32BeginningOfDay( const RTime32 rtime32 )
{
	time_t timeCur = rtime32;
	struct tm tmStruct;
	struct tm *ptmCur = Plat_localtime( &timeCur, &tmStruct );
	if ( !ptmCur )
		return k_RTime32Nil;

	// midnight
	ptmCur->tm_hour = 0;
	ptmCur->tm_min = 0;
	ptmCur->tm_sec = 0;

	// Let it compute DST
	ptmCur->tm_isdst = -1;

	return mktime( ptmCur );
}


//-----------------------------------------------------------------------------
// Purpose: Calculate and return a time value corresponding to the beginning of 
//			the next day after rtime32
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32BeginningOfNextDay( const RTime32 rtime32 )
{
	time_t timeCur = rtime32;
	struct tm tmStruct;
	struct tm *ptmCur = Plat_localtime( &timeCur, &tmStruct );
	if ( !ptmCur )
		return k_RTime32Nil;

	// It will move to the next month etc if need be
	ptmCur->tm_mday++;

	// midnight
	ptmCur->tm_hour = 0;
	ptmCur->tm_min = 0;
	ptmCur->tm_sec = 0;

	// Let it compute DST
	ptmCur->tm_isdst = -1;

	return mktime( ptmCur );
}


//-----------------------------------------------------------------------------
// Purpose: Calculate and return a time value corresponding to the first day of
//			the month indicated by rtime32
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32FirstDayOfMonth( const RTime32 rtime32 )
{
	time_t timeCur = rtime32;
	struct tm tmStruct;
	struct tm *ptmCur = Plat_localtime( &timeCur, &tmStruct );
	if ( !ptmCur )
		return k_RTime32Nil;

	// first day of month
	ptmCur->tm_mday = 1;

	// midnight
	ptmCur->tm_hour = 0;
	ptmCur->tm_min = 0;
	ptmCur->tm_sec = 0;

	// Let it compute DST
	ptmCur->tm_isdst = -1;

	return mktime( ptmCur );
}


//-----------------------------------------------------------------------------
// Purpose: Calculate and return a time value corresponding to the last day of
//			the month indicated by rtime32
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32LastDayOfMonth( const RTime32 rtime32 )
{
	time_t timeCur = rtime32;
	struct tm tmStruct;
	struct tm *ptmCur = Plat_localtime( &timeCur, &tmStruct );
	if ( !ptmCur )
		return k_RTime32Nil;

	// Zeroth day of month N becomes last day of month (N-1)
	ptmCur->tm_mon++;
	ptmCur->tm_mday = 0;

	// midnight
	ptmCur->tm_hour = 0;
	ptmCur->tm_min = 0;
	ptmCur->tm_sec = 0;

	// Let it compute DST
	ptmCur->tm_isdst = -1;

	return mktime( ptmCur );
}


//-----------------------------------------------------------------------------
// Purpose: Calculate and return a time value corresponding to the first day of
//			the month after the one indicated by rtime32
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32FirstDayOfNextMonth( const RTime32 rtime32 )
{
	time_t timeCur = rtime32;
	struct tm tmStruct;
	struct tm *ptmCur = Plat_localtime( &timeCur, &tmStruct );
	if ( !ptmCur )
		return k_RTime32Nil;

	ptmCur->tm_mon++;
	ptmCur->tm_mday = 1;

	// midnight
	ptmCur->tm_hour = 0;
	ptmCur->tm_min = 0;
	ptmCur->tm_sec = 0;

	// Let it compute DST
	ptmCur->tm_isdst = -1;

	return mktime( ptmCur );
}


//-----------------------------------------------------------------------------
// Purpose: Calculate and return a time value corresponding to the last day of
//			the month after the one indicated by rtime32
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32LastDayOfNextMonth( const RTime32 rtime32 )
{
	time_t timeCur = rtime32;
	struct tm tmStruct;
	struct tm *ptmCur = Plat_localtime( &timeCur, &tmStruct );
	if ( !ptmCur )
		return k_RTime32Nil;

	// use zeroth-day trick - skip 2 months then back a day
	ptmCur->tm_mon += 2;
	ptmCur->tm_mday = 0;

	// midnight
	ptmCur->tm_hour = 0;
	ptmCur->tm_min = 0;
	ptmCur->tm_sec = 0;

	// Let it compute DST
	ptmCur->tm_isdst = -1;

	return mktime( ptmCur );
}


//-----------------------------------------------------------------------------
// Purpose: Calculate and return a time value corresponding to the Nth day of
//			the month. If that month only has K days, K < N, it will return
//			the Kth day. The input should be reasonable (don't ask for the -5th
//			day of the month).
//
// Input:	rtime32 -		Time representing some time in the month interested in
//			nDay -			The day of that month you want the return to be set to
//
// Return:	Time value equal to midnight on that day.
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32NthDayOfMonth( const RTime32 rtime32, int nDay )
{
	Assert( nDay > 0 );
	Assert( nDay < 32 );

	time_t timeCur = rtime32;
	struct tm tmStruct;
	struct tm *ptmCur = Plat_localtime( &timeCur, &tmStruct );
	if ( !ptmCur )
		return k_RTime32Nil;

	int nCurMonth = ptmCur->tm_mon;

	ptmCur->tm_mday = nDay;

	// midnight
	ptmCur->tm_hour = 0;
	ptmCur->tm_min = 0;
	ptmCur->tm_sec = 0;

	// Let it compute DST
	ptmCur->tm_isdst = -1;

	// This call will modify ptmCur in-place
	time_t timeThen = mktime( ptmCur );

	// See if the month changed
	if ( ptmCur->tm_mon != nCurMonth )
	{
		// use zeroth-day trick to just get the last day of this month
		ptmCur->tm_mday = 0;
		// Let it compute DST
		ptmCur->tm_isdst = -1;
		timeThen = mktime( ptmCur );
	}

	return timeThen;
}


//-----------------------------------------------------------------------------
// Purpose: Add X months to the current date, and return the Nth day of that
//			month.
//
// Input:	nNthDayOfMonth -		Day of the target month to return a date for
//			rtime32StartDate -		Time value to add X months to
//			nMonthsToAdd -			X
//
// Return:	Time value equal to midnight on that day.
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32MonthAddChooseDay( int nNthDayOfMonth, RTime32 rtime32StartDate, int nMonthsToAdd )
{
	// Get the first day of start month
	RTime32 rtime32FirstDayOfStartMonth = CRTime( rtime32StartDate ).GetFirstDayOfMonth();

	// Add X months to that - guaranteed to be correct month
	RTime32 rtime32FirstDayOfTargetMonth = CRTime::RTime32DateAdd( rtime32FirstDayOfStartMonth, nMonthsToAdd, k_ETimeUnitMonth );

	// Then get the Nth day of that month
	RTime32 rtime32Target = CRTime::RTime32NthDayOfMonth( rtime32FirstDayOfTargetMonth, nNthDayOfMonth );

	return rtime32Target;
}


//-----------------------------------------------------------------------------
// Purpose: Add or subtract N units of time from the current value.
//			Units may be days, weeks, seconds, etc
// Input:	rtime32 -				Reference time
//			nAmount -				Number of units to add (neg for subtract)
//			eTimeFlagAmountType -	Indicates what units are on nAmount
//
// Return:	The newly calculated offset time (the input is unmodified)
//-----------------------------------------------------------------------------
// STATIC
RTime32 CRTime::RTime32DateAdd(  const RTime32 rtime32, int nAmount, ETimeUnit eTimeAmountType )
{
	time_t timeCur = rtime32;
	struct tm tmStruct;
	struct tm *ptmCur = Plat_localtime( &timeCur, &tmStruct );
	if ( !ptmCur )
		return k_RTime32Nil;

	// mktime() is smart enough to take day-of-month values that are out of range and adjust
	// everything to make sense. So you can go back 3 weeks by just subtracting 21 from tm_mday.
	switch ( eTimeAmountType )
	{
	default:
		AssertMsg( false, "Bad flag in RTime32DateAdd" );
		break;
	case k_ETimeUnitForever:
		return k_RTime32Infinite;
	case k_ETimeUnitYear:
		ptmCur->tm_year += nAmount;
		break;
	case k_ETimeUnitMonth:
		ptmCur->tm_mon += nAmount;
		break;
	case k_ETimeUnitWeek:
		ptmCur->tm_mday += 7 * nAmount;
		break;
	case k_ETimeUnitDay:
		ptmCur->tm_mday += nAmount;
		break;
	case k_ETimeUnitHour:
		ptmCur->tm_hour += nAmount;
		break;
	case k_ETimeUnitMinute:
		ptmCur->tm_min += nAmount;
		break;
	case k_ETimeUnitSecond:
		ptmCur->tm_sec += nAmount;
		break;
	}

	// Let it compute DST
	ptmCur->tm_isdst = -1;

	return mktime( ptmCur );
}

//-----------------------------------------------------------------------------
// Purpose: Compare two times and evaluate what calendar boundaries have
//			been crossed (eg day, month, hour) between the two times.
//
//			Note: in general, the crossing of a large boundary will be accompanied
//			by the crossing of all smaller boundaries. The exception is Week:
//			the Week boundary is from Saturday to Sunday, and it is possible to
//			go over a Month or Year boundary without beginning a new week.
//
//			So, the return value is the largest time boundary that was crossed. 
//			However, the pbWeekChanged value will be set to indicate if the week
//			changed in cases where the return value is Month or Year.
//
// Input:	unTime1 -		First time value
//			unTime2 -		Second time value
//			pbWeekChanged -	Indicates if the Week changed
//
// Return:	Largest time boundary crossed
//-----------------------------------------------------------------------------
// STATIC
ETimeUnit CRTime::FindTimeBoundaryCrossings( RTime32 unTime1, RTime32 unTime2, bool *pbWeekChanged )
{
	time_t time1 = unTime1;
	time_t time2 = unTime2;

	// have to cache the first one locally, because it's a global object
	struct tm tmStruct1;
	struct tm *ptmTime1 = Plat_localtime( &time1, &tmStruct1 );
	if ( !ptmTime1 )
		return k_ETimeUnitForever;
	struct tm _tmTime1 = *ptmTime1;
	ptmTime1 = &_tmTime1;
	struct tm tmStruct2;
	struct tm *ptmTime2 = Plat_localtime( &time2, &tmStruct2 );
	if ( !ptmTime2 )
		return k_ETimeUnitForever;

	// Need a little extra logic to find week boundaries
	// Find this out first, because it may or may not be true even if a 
	// month / year boundary was crossed.
	*pbWeekChanged = false;

	// If the difference is more than 6 days, we crossed a week boundary
	if ( ( ( unTime1 > unTime2 ) && ( ( unTime1 - unTime2 ) > k_cSecondsPerWeek ) )
		 || ( ( unTime2 > unTime1 ) && ( ( unTime2 - unTime1 ) > k_cSecondsPerWeek ) ) )
	{
		*pbWeekChanged = true;
	}
	else if ( ptmTime1->tm_yday != ptmTime2->tm_yday )
	{
		// Otherwise, we have to look at wday - if the later time
		// has a lower or equal wday value, then we crossed a week boundary
		if ( unTime2 > unTime1 )
		{
			if ( ptmTime2->tm_wday <= ptmTime1->tm_wday )
				*pbWeekChanged = true;
		}
		else
		{
			if ( ptmTime1->tm_wday <= ptmTime2->tm_wday )
				*pbWeekChanged = true;
		}
	}

	// Evaluate larger boundaries first. As soon as we detect
	// that we've crossed a boundary, we consider all smaller boundaries
	// crossed too.

	// Year
	if ( ptmTime1->tm_year != ptmTime2->tm_year )
		return k_ETimeUnitYear;

	// Month
	if ( ptmTime1->tm_mon != ptmTime2->tm_mon )
		return k_ETimeUnitMonth;

	// If the week changed, return that now
	if ( *pbWeekChanged )
		return k_ETimeUnitWeek;

	// Day
	if ( ptmTime1->tm_yday != ptmTime2->tm_yday )
		return  k_ETimeUnitDay;

	// Hour
	if ( ptmTime1->tm_hour != ptmTime2->tm_hour )
		return  k_ETimeUnitHour;

	// If DST changed, make sure that we know an hour boundary was crossed
	// (overlap from the "fall back" case may otherwise trick us)
	if ( ptmTime1->tm_isdst != ptmTime2->tm_isdst )
		return  k_ETimeUnitHour;

	// Minute
	if ( ptmTime1->tm_min != ptmTime2->tm_min )
		return  k_ETimeUnitMinute;

	// Second
	if ( ptmTime1->tm_sec != ptmTime2->tm_sec )
		return  k_ETimeUnitSecond;

	return k_ETimeUnitNone;

}