mosesdecoder/xmlrpc-c-1.51.06/lib/libutil/time.c

#include "xmlrpc_config.h"
#include <assert.h>
#include <time.h>

#if HAVE_GETTIMEOFDAY
#  include <sys/time.h>
#endif

#if MSVCRT
#  define WIN32_LEAN_AND_MEAN
#  include <windows.h>
#endif

#include "xmlrpc-c/string_int.h"
#include "xmlrpc-c/time_int.h"


/* A note about struct timeval and Windows: There is a 'struct
   timeval' type in Windows, but it is just an argument to select(),
   which is just part of the sockets interface.  It's defined
   identically to the POSIX type of the same name, but not meant for
   general timekeeping as the POSIX type is.
*/

#if HAVE_GETTIMEOFDAY
static void
gettimeofdayPosix(xmlrpc_timespec * const todP) {

    struct timeval tv;

    gettimeofday(&tv, NULL);

    todP->tv_sec  = tv.tv_sec;
    todP->tv_nsec = tv.tv_usec * 1000;
}
#endif



#if MSVCRT
static void
gettimeofdayWindows(xmlrpc_timespec * const todP) {

    __int64 const epochOffset = 116444736000000000ll;
        /* Number of 100-nanosecond units between the beginning of the
           Windows epoch (Jan. 1, 1601) and the Unix epoch (Jan. 1, 1970).
        */
    FILETIME        ft;
    LARGE_INTEGER   li;
    __int64         t;

    GetSystemTimeAsFileTime(&ft);
    li.LowPart  = ft.dwLowDateTime;
    li.HighPart = ft.dwHighDateTime;
    t  = (li.QuadPart - epochOffset) * 100;  /* nanoseconds */
    todP->tv_sec  = (long)(t / 1E9);
    todP->tv_nsec = (long)(t - (__int64)todP->tv_sec * 1E9);
}
#endif



void
xmlrpc_gettimeofday(xmlrpc_timespec * const todP) {

    assert(todP);

#if HAVE_GETTIMEOFDAY
    gettimeofdayPosix(todP);
#else
#if MSVCRT
    gettimeofdayWindows(todP);
#else
  #error "We don't know how to get the time of day on this system"
#endif
#endif /* HAVE_GETTIMEOFDAY */
}



static bool
isLeapYear(unsigned int const yearOfAd) {

    return
        (yearOfAd % 4) == 0 &&
        ((yearOfAd % 100) != 0 || (yearOfAd % 400) == 0);
}



void
xmlrpc_timegm(const struct tm  * const tmP,
              time_t *           const timeValueP,
              const char **      const errorP) {
/*----------------------------------------------------------------------------
   This does what GNU libc's timegm() does.
-----------------------------------------------------------------------------*/
    if (tmP->tm_year < 70 ||
        tmP->tm_mon  > 11 ||
        tmP->tm_mon  <  0 ||
        tmP->tm_mday > 31 ||
        tmP->tm_min  > 60 ||
        tmP->tm_sec  > 60 ||
        tmP->tm_hour > 24) {

        xmlrpc_asprintf(errorP, "Invalid time specification; a member "
                        "of struct tm is out of range");
    } else {
        static unsigned int const monthDaysNonLeap[12] = 
            {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

        unsigned int totalDays;
        unsigned int year;
        unsigned int month;

        totalDays = 0;  /* initial value */
    
        for (year = 70; year < (unsigned int)tmP->tm_year; ++year)
            totalDays += isLeapYear(1900 + year) ? 366 : 365;
    
        for (month = 0; month < (unsigned int)tmP->tm_mon; ++month)
            totalDays += monthDaysNonLeap[month];

        if (tmP->tm_mon > 1 && isLeapYear(1900 + tmP->tm_year))
            totalDays += 1;

        totalDays += tmP->tm_mday - 1;

        *errorP = NULL;

        *timeValueP = ((totalDays * 24 +
                        tmP->tm_hour) * 60 +
                        tmP->tm_min) * 60 +
                        tmP->tm_sec;
    }
}



void
xmlrpc_localtime(time_t      const datetime,
                 struct tm * const tmP) {
/*----------------------------------------------------------------------------
   Convert datetime from standard to broken-down format in the local
   time zone.

   For Windows, this is not thread-safe.  If you run a version of Abyss
   with multiple threads, you can get arbitrary results here.
-----------------------------------------------------------------------------*/
#if HAVE_LOCALTIME_R
  localtime_r(&datetime, tmP);
#else
  *tmP = *localtime(&datetime);
#endif
}



void
xmlrpc_gmtime(time_t      const datetime,
              struct tm * const resultP) {
/*----------------------------------------------------------------------------
   Convert datetime from standard to broken-down UTC format.

   For Windows, this is not thread-safe.  If you run a version of Abyss
   with multiple threads, you can get arbitrary results here.
-----------------------------------------------------------------------------*/

#if HAVE_GMTIME_R
    gmtime_r(&datetime, resultP);
#else
    *resultP = *gmtime(&datetime);
#endif
}