Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205//// gmtime.cpp//// Copyright (c) Microsoft Corporation. All rights reserved.//// The gmtime() family of functions, which converts a time_t value into a tm// structure in UTC.//#include <corecrt_internal_time.h>
// This is a utility that allows us to compute the year value differently for// 32-bit and 64-bit time_t objects.static int __cdecl compute_year(__time32_t& caltim, bool& is_leap_year) throw(){ // Determine years since 1970. First, identify the four-year interval // since this makes handling leap-years easy (note that 2000 IS a // leap year and 2100 is out-of-range). int tmptim = static_cast<int>(caltim / _FOUR_YEAR_SEC); caltim -= static_cast<__time32_t>(tmptim) * _FOUR_YEAR_SEC;
// Determine which year of the interval tmptim = (tmptim * 4) + 70; // 1970, 1974, 1978,...,etc.
if (caltim >= _YEAR_SEC) { tmptim++; // 1971, 1975, 1979,...,etc. caltim -= _YEAR_SEC;
if (caltim >= _YEAR_SEC) { tmptim++; // 1972, 1976, 1980,...,etc. caltim -= _YEAR_SEC;
// Note, it takes 366 days-worth of seconds to get past a leap // year. if (caltim >= (_YEAR_SEC + _DAY_SEC)) { tmptim++; // 1973, 1977, 1981,...,etc. caltim -= (_YEAR_SEC + _DAY_SEC); } else { // In a leap year after all, set the flag. is_leap_year = true; } } }
return tmptim;}
static int __cdecl compute_year(__time64_t& caltim, bool& is_leap_year) throw(){ // Determine the years since 1900. Start by ignoring leap years: int tmptim = static_cast<int>(caltim / _YEAR_SEC) + 70; caltim -= static_cast<__time64_t>(tmptim - 70) * _YEAR_SEC;
// Correct for elapsed leap years: caltim -= static_cast<__time64_t>(__crt_time_elapsed_leap_years(tmptim)) * _DAY_SEC;
// If we have underflowed the __time64_t range (i.e., if caltim < 0), // back up one year, adjusting the correction if necessary. if (caltim < 0) { caltim += static_cast<__time64_t>(_YEAR_SEC); tmptim--; if (__crt_time_is_leap_year(tmptim)) { caltim += _DAY_SEC; is_leap_year = true; } } else if (__crt_time_is_leap_year(tmptim)) { is_leap_year = true; }
return tmptim;}
// Converts a time_t value into a tm structure in UTC. Stores the tm structure// into the '*ptm' buffer. Returns zero on success; returns an error code on// failuretemplate <typename TimeType>static errno_t __cdecl common_gmtime_s(tm* const ptm, TimeType const* const timp) throw(){ typedef __crt_time_time_t_traits<__time64_t> time_traits;
_VALIDATE_RETURN_ERRCODE(ptm != nullptr, EINVAL) memset(ptm, 0xff, sizeof(tm));
_VALIDATE_RETURN_ERRCODE(timp != nullptr, EINVAL); TimeType caltim = *timp;
_VALIDATE_RETURN_ERRCODE_NOEXC(caltim >= _MIN_LOCAL_TIME, EINVAL)
// Upper bound check only necessary for _gmtime64_s (it's > LONG_MAX). // For _gmtime32_s, any positive number is within range (<= LONG_MAX). _VALIDATE_RETURN_ERRCODE_NOEXC(caltim <= time_traits::max_time_t + _MAX_LOCAL_TIME, EINVAL)
// tmptim now holds the value for tm_year. caltim now holds the // number of elapsed seconds since the beginning of that year. bool is_leap_year = false; ptm->tm_year = compute_year(caltim, is_leap_year);
// Determine days since January 1 (0 - 365). This is the tm_yday value. // Leave caltim with number of elapsed seconds in that day. ptm->tm_yday = static_cast<int>(caltim / _DAY_SEC); caltim -= static_cast<TimeType>(ptm->tm_yday) * _DAY_SEC;
// Determine months since January (0 - 11) and day of month (1 - 31): int const* const mdays = is_leap_year ? _lpdays : _days;
int tmptim = 0; for (tmptim = 1 ; mdays[tmptim] < ptm->tm_yday ; tmptim++) { }
ptm->tm_mon = --tmptim;
ptm->tm_mday = ptm->tm_yday - mdays[tmptim];
// Determine days since Sunday (0 - 6) ptm->tm_wday = (static_cast<int>(*timp / _DAY_SEC) + _BASE_DOW) % 7;
// Determine hours since midnight (0 - 23), minutes after the hour // (0 - 59), and seconds after the minute (0 - 59). ptm->tm_hour = static_cast<int>(caltim / 3600); caltim -= static_cast<TimeType>(ptm->tm_hour) * 3600L;
ptm->tm_min = static_cast<int>(caltim / 60); ptm->tm_sec = static_cast<int>(caltim - (ptm->tm_min) * 60);
ptm->tm_isdst = 0; return 0;}
extern "C" errno_t __cdecl _gmtime32_s(tm* const result, __time32_t const* const time_value){ return common_gmtime_s(result, time_value);}
extern "C" errno_t __cdecl _gmtime64_s(tm* const result, __time64_t const* const time_value){ return common_gmtime_s(result, time_value);}
// Gets the thread-local buffer to be used by gmtime. Returns a pointer to the// buffer on success; returns null and sets errno on failure.extern "C" tm* __cdecl __getgmtimebuf(){ __acrt_ptd* const ptd = __acrt_getptd_noexit(); if (ptd == nullptr) { errno = ENOMEM; return nullptr; }
if (ptd->_gmtime_buffer != nullptr) { return ptd->_gmtime_buffer; }
ptd->_gmtime_buffer = _malloc_crt_t(tm, 1).detach(); if (ptd->_gmtime_buffer == nullptr) { errno = ENOMEM; return nullptr; }
return ptd->_gmtime_buffer;}
// Converts a time_t value into a tm structure in UTC. Returns a pointer to a// thread-local buffer containing the tm structure on success; returns null on// failure.template <typename TimeType>_Success_(return != 0)static tm* __cdecl common_gmtime(TimeType const* const time_value) throw(){ tm* const ptm = __getgmtimebuf(); if (ptm == nullptr) return nullptr;
if (common_gmtime_s(ptm, time_value) != 0) return nullptr;
return ptm;}
extern "C" tm* __cdecl _gmtime32(__time32_t const* const time_value){ return common_gmtime(time_value);}
extern "C" tm* __cdecl _gmtime64(__time64_t const* const time_value){ return common_gmtime(time_value);}