Python/pytime.c

#include "Python.h"
#ifdef MS_WINDOWS
#include <windows.h>
#endif

#if defined(__APPLE__) && defined(HAVE_GETTIMEOFDAY) && defined(HAVE_FTIME)
  /*
   * _PyTime_gettimeofday falls back to ftime when getttimeofday fails because the latter
   * might fail on some platforms. This fallback is unwanted on MacOSX because
   * that makes it impossible to use a binary build on OSX 10.4 on earlier
   * releases of the OS. Therefore claim we don't support ftime.
   */
# undef HAVE_FTIME
#endif

#if defined(HAVE_FTIME) && !defined(MS_WINDOWS)
#include <sys/timeb.h>
extern int ftime(struct timeb *);
#endif

#define MICROSECONDS    1000000

void
_PyTime_get(_PyTime_t *ts)
{
#ifdef MS_WINDOWS
    FILETIME system_time;
    ULARGE_INTEGER large;
    ULONGLONG value;

    GetSystemTimeAsFileTime(&system_time);
    large.u.LowPart = system_time.dwLowDateTime;
    large.u.HighPart = system_time.dwHighDateTime;
    /* 116,444,736,000,000,000: number of 100 ns between
       the 1st january 1601 and the 1st january 1970 (369 years + 89 leap
       days). */
    value = large.QuadPart - 116444736000000000;
    ts->seconds = 0;
    ts->numerator = value;
    ts->denominator = (_PyTime_fraction_t)10000000;
#else

#ifdef HAVE_GETTIMEOFDAY
    struct timeval tv;
    int err;
#endif
#if defined(HAVE_FTIME)
    struct timeb t;
#endif

    /* There are three ways to get the time:
      (1) gettimeofday() -- resolution in microseconds
      (2) ftime() -- resolution in milliseconds
      (3) time() -- resolution in seconds
      In all cases the return value in a timeval struct.
      Since on some systems (e.g. SCO ODT 3.0) gettimeofday() may
      fail, so we fall back on ftime() or time().
      Note: clock resolution does not imply clock accuracy! */

#ifdef HAVE_GETTIMEOFDAY
#ifdef GETTIMEOFDAY_NO_TZ
    err = gettimeofday(&tv);
#else /* !GETTIMEOFDAY_NO_TZ */
    err = gettimeofday(&tv, (struct timezone *)NULL);
#endif /* !GETTIMEOFDAY_NO_TZ */
    if (err == 0)
    {
        ts->seconds = tv.tv_sec;
        ts->numerator = tv.tv_usec;
        ts->denominator = MICROSECONDS;
        return;
    }
#endif /* !HAVE_GETTIMEOFDAY */

#if defined(HAVE_FTIME)
    ftime(&t);
    ts->seconds = t.time;
    ts->numerator = t.millitm;
    ts->denominator = 1000;
#else /* !HAVE_FTIME */
    ts->seconds = time(NULL);
    ts->numerator = 0;
    ts->denominator = 1;
#endif /* !HAVE_FTIME */

#endif /* MS_WINDOWS */
}

void
_PyTime_gettimeofday(_PyTime_timeval *tv)
{
    _PyTime_t ts;
    _PyTime_fraction_t k;
    time_t sec;

    _PyTime_get(&ts);
    tv->tv_sec = ts.seconds;
    if (ts.numerator) {
        if (ts.numerator > ts.denominator) {
            sec = Py_SAFE_DOWNCAST(ts.numerator / ts.denominator,
                                   _PyTime_fraction_t, time_t);
            /* ignore integer overflow because _PyTime_gettimeofday() has
               no return value */
            tv->tv_sec += sec;
            ts.numerator = ts.numerator % ts.denominator;
        }
        if (MICROSECONDS >= ts.denominator) {
            k = (_PyTime_fraction_t)MICROSECONDS / ts.denominator;
            tv->tv_usec = (long)(ts.numerator * k);
        }
        else {
            k = ts.denominator / (_PyTime_fraction_t)MICROSECONDS;
            tv->tv_usec = (long)(ts.numerator / k);
        }
    }
    else {
        tv->tv_usec = 0;
    }
}

static PyObject*
_PyLong_FromTime_t(time_t value)
{
#if SIZEOF_TIME_T <= SIZEOF_LONG
    return PyLong_FromLong(value);
#else
    assert(sizeof(time_t) <= sizeof(PY_LONG_LONG));
    return PyLong_FromLongLong(value);
#endif
}

#if defined(HAVE_LONG_LONG)
#  define _PyLong_FromTimeFraction_t PyLong_FromLongLong
#else
#  define _PyLong_FromTimeFraction_t PyLong_FromSize_t
#endif

/* Convert a timestamp to a PyFloat object */
static PyObject*
_PyTime_AsFloat(_PyTime_t *ts)
{
    double d;
    d = (double)ts->seconds;
    d += (double)ts->numerator / (double)ts->denominator;
    return PyFloat_FromDouble(d);
}

/* Convert a timestamp to a PyLong object */
static PyObject*
_PyTime_AsLong(_PyTime_t *ts)
{
    PyObject *a, *b, *c;

    a = _PyLong_FromTime_t(ts->seconds);
    if (a == NULL)
        return NULL;
    b = _PyLong_FromTimeFraction_t(ts->numerator / ts->denominator);
    if (b == NULL)
    {
        Py_DECREF(a);
        return NULL;
    }
    c = PyNumber_Add(a, b);
    Py_DECREF(a);
    Py_DECREF(b);
    return c;
}

/* Convert a timestamp to a decimal.Decimal object */
static PyObject*
_PyTime_AsDecimal(_PyTime_t *ts)
{
    static PyObject* module = NULL;
    static PyObject* decimal = NULL;
    static PyObject* exponent_context = NULL;
    static PyObject* context = NULL;
    /* exponent cache, dictionary of:
       int (denominator) => Decimal (1/denominator) */
    static PyObject* exponent_cache = NULL;
    PyObject *t = NULL;
    PyObject *key, *exponent, *quantized;
    _Py_IDENTIFIER(quantize);
    _Py_IDENTIFIER(__truediv__);

    if (!module) {
        module = PyImport_ImportModuleNoBlock("decimal");
        if (module == NULL)
            return NULL;
    }

    if (!decimal) {
        decimal = PyObject_GetAttrString(module, "Decimal");
        if (decimal == NULL)
            return NULL;
    }

    if (context == NULL)
    {
        /* Use 12 decimal digits to store 10,000 years in seconds + 9
           decimal digits for the floating part in nanoseconds + 1 decimal
           digit to round correctly.

           context = decimal.Context(22, rounding=decimal.ROUND_HALF_EVEN)
           exponent_context = decimal.Context(1, rounding=decimal.ROUND_HALF_EVEN)
        */
        PyObject *context_class, *rounding;
        context_class = PyObject_GetAttrString(module, "Context");
        if (context_class == NULL)
            return NULL;
        rounding = PyObject_GetAttrString(module, "ROUND_HALF_EVEN");
        if (rounding == NULL)
        {
            Py_DECREF(context_class);
            return NULL;
        }
        context = PyObject_CallFunction(context_class, "iO", 22, rounding);
        if (context == NULL)
        {
            Py_DECREF(context_class);
            Py_DECREF(rounding);
            return NULL;
        }

        exponent_context = PyObject_CallFunction(context_class, "iO", 1, rounding);
        Py_DECREF(context_class);
        Py_DECREF(rounding);
        if (exponent_context == NULL)
        {
            Py_CLEAR(context);
            return NULL;
        }
    }

    /* t = decimal.Decimal(value) */
    if (ts->seconds) {
        PyObject *f = _PyLong_FromTime_t(ts->seconds);
        t = PyObject_CallFunction(decimal, "O", f);
        Py_CLEAR(f);
    }
    else {
        t = PyObject_CallFunction(decimal, "iO", 0, context);
    }
    if (t == NULL)
        return NULL;

    if (ts->numerator)
    {
        /* t += decimal.Decimal(numerator, ctx) / decimal.Decimal(denominator, ctx) */
        PyObject *a, *b, *c, *d, *x;

        x = _PyLong_FromTimeFraction_t(ts->numerator);
        if (x == NULL)
            goto error;
        a = PyObject_CallFunction(decimal, "OO", x, context);
        Py_CLEAR(x);
        if (a == NULL)
            goto error;

        x = _PyLong_FromTimeFraction_t(ts->denominator);
        if (x == NULL)
        {
            Py_DECREF(a);
            goto error;
        }
        b = PyObject_CallFunction(decimal, "OO", x, context);
        Py_CLEAR(x);
        if (b == NULL)
        {
            Py_DECREF(a);
            goto error;
        }

        c = _PyObject_CallMethodId(a, &PyId___truediv__, "OO",
                                   b, context);
        Py_DECREF(a);
        Py_DECREF(b);
        if (c == NULL)
            goto error;

        d = PyNumber_Add(t, c);
        Py_DECREF(c);
        if (d == NULL)
            goto error;
        Py_DECREF(t);
        t = d;
    }

    if (exponent_cache == NULL) {
        exponent_cache = PyDict_New();
        if (exponent_cache == NULL)
            goto error;
    }

    key = _PyLong_FromTimeFraction_t(ts->denominator);
    if (key == NULL)
        goto error;
    exponent = PyDict_GetItem(exponent_cache, key);
    if (exponent == NULL) {
        /* exponent = decimal.Decimal(1) / decimal.Decimal(resolution) */
        PyObject *one, *denominator;

        one = PyObject_CallFunction(decimal, "i", 1);
        if (one == NULL) {
            Py_DECREF(key);
            goto error;
        }

        denominator = PyObject_CallFunction(decimal, "O", key);
        if (denominator == NULL) {
            Py_DECREF(key);
            Py_DECREF(one);
            goto error;
        }

        exponent = _PyObject_CallMethodId(one, &PyId___truediv__, "OO",
                                          denominator, exponent_context);
        Py_DECREF(one);
        Py_DECREF(denominator);
        if (exponent == NULL) {
            Py_DECREF(key);
            goto error;
        }

        if (PyDict_SetItem(exponent_cache, key, exponent) < 0) {
            Py_DECREF(key);
            Py_DECREF(exponent);
            goto error;
        }
        Py_DECREF(key);
    }

    /* t = t.quantize(exponent, None, context) */
    quantized = _PyObject_CallMethodId(t, &PyId_quantize, "OOO",
                                       exponent, Py_None, context);
    if (quantized == NULL)
        goto error;
    Py_DECREF(t);
    t = quantized;

    return t;

error:
    Py_XDECREF(t);
    return NULL;
}

PyObject*
_PyTime_Convert(_PyTime_t *ts, PyObject *format)
{
    assert(ts->denominator != 0);

    if (format == NULL || (PyTypeObject *)format == &PyFloat_Type)
        return _PyTime_AsFloat(ts);
    if ((PyTypeObject *)format == &PyLong_Type)
        return _PyTime_AsLong(ts);

    if (PyType_Check(format))
    {
        PyObject *module, *name;
        _Py_IDENTIFIER(__name__);
        _Py_IDENTIFIER(__module__);

        module = _PyObject_GetAttrId(format, &PyId___module__);
        name = _PyObject_GetAttrId(format, &PyId___name__);
        if (module != NULL && PyUnicode_Check(module)
            && name != NULL && PyUnicode_Check(name))
        {
            if (PyUnicode_CompareWithASCIIString(module, "decimal") == 0
                && PyUnicode_CompareWithASCIIString(name, "Decimal") == 0)
                return _PyTime_AsDecimal(ts);
        }
        else
            PyErr_Clear();
    }

    PyErr_Format(PyExc_ValueError, "Unknown timestamp format: %R", format);
    return NULL;
}

void
_PyTime_Init()
{
    /* Do nothing.  Needed to force linking. */
}