Modules/timemodule.c

   1
   2 /* Time module */
   3
   4 #include "Python.h"
   5 #include "structseq.h"
   6 #include "timefuncs.h"
   7
   8 #ifdef __APPLE__
   9 #if defined(HAVE_GETTIMEOFDAY) && defined(HAVE_FTIME)
  10   /*
  11    * floattime falls back to ftime when getttimeofday fails because the latter
  12    * might fail on some platforms. This fallback is unwanted on MacOSX because
  13    * that makes it impossible to use a binary build on OSX 10.4 on earlier
  14    * releases of the OS. Therefore claim we don't support ftime.
  15    */
  16 # undef HAVE_FTIME
  17 #endif
  18 #endif
  19
  20 #include <ctype.h>
  21
  22 #ifdef HAVE_SYS_TYPES_H
  23 #include <sys/types.h>
  24 #endif /* HAVE_SYS_TYPES_H */
  25
  26 #ifdef QUICKWIN
  27 #include <io.h>
  28 #endif
  29
  30 #ifdef HAVE_FTIME
  31 #include <sys/timeb.h>
  32 #if !defined(MS_WINDOWS) && !defined(PYOS_OS2)
  33 extern int ftime(struct timeb *);
  34 #endif /* MS_WINDOWS */
  35 #endif /* HAVE_FTIME */
  36
  37 #if defined(__WATCOMC__) && !defined(__QNX__)
  38 #include <i86.h>
  39 #else
  40 #ifdef MS_WINDOWS
  41 #define WIN32_LEAN_AND_MEAN
  42 #include <windows.h>
  43 #include "pythread.h"
  44
  45 /* helper to allow us to interrupt sleep() on Windows*/
  46 static HANDLE hInterruptEvent = NULL;
  47 static BOOL WINAPI PyCtrlHandler(DWORD dwCtrlType)
  48 {
  49         SetEvent(hInterruptEvent);
  50         /* allow other default handlers to be called.
  51            Default Python handler will setup the
  52            KeyboardInterrupt exception.
  53         */
  54         return FALSE;
  55 }
  56 static long main_thread;
  57
  58
  59 #if defined(__BORLANDC__)
  60 /* These overrides not needed for Win32 */
  61 #define timezone _timezone
  62 #define tzname _tzname
  63 #define daylight _daylight
  64 #endif /* __BORLANDC__ */
  65 #endif /* MS_WINDOWS */
  66 #endif /* !__WATCOMC__ || __QNX__ */
  67
  68 #if defined(MS_WINDOWS) && !defined(__BORLANDC__)
  69 /* Win32 has better clock replacement; we have our own version below. */
  70 #undef HAVE_CLOCK
  71 #endif /* MS_WINDOWS && !defined(__BORLANDC__) */
  72
  73 #if defined(PYOS_OS2)
  74 #define INCL_DOS
  75 #define INCL_ERRORS
  76 #include <os2.h>
  77 #endif
  78
  79 #if defined(PYCC_VACPP)
  80 #include <sys/time.h>
  81 #endif
  82
  83 #ifdef __BEOS__
  84 #include <time.h>
  85 /* For bigtime_t, snooze(). - [cjh] */
  86 #include <support/SupportDefs.h>
  87 #include <kernel/OS.h>
  88 #endif
  89
  90 #ifdef RISCOS
  91 extern int riscos_sleep(double);
  92 #endif
  93
  94 /* Forward declarations */
  95 static int floatsleep(double);
  96 static double floattime(void);
  97
  98 /* For Y2K check */
  99 static PyObject *moddict;
 100
 101 /* Exposed in timefuncs.h. */
 102 time_t
 103 _PyTime_DoubleToTimet(double x)
 104 {
 105         time_t result;
 106         double diff;
 107
 108         result = (time_t)x;
 109         /* How much info did we lose?  time_t may be an integral or
 110          * floating type, and we don't know which.  If it's integral,
 111          * we don't know whether C truncates, rounds, returns the floor,
 112          * etc.  If we lost a second or more, the C rounding is
 113          * unreasonable, or the input just doesn't fit in a time_t;
 114          * call it an error regardless.  Note that the original cast to
 115          * time_t can cause a C error too, but nothing we can do to
 116          * worm around that.
 117          */
 118         diff = x - (double)result;
 119         if (diff <= -1.0 || diff >= 1.0) {
 120                 PyErr_SetString(PyExc_ValueError,
 121                                 "timestamp out of range for platform time_t");
 122                 result = (time_t)-1;
 123         }
 124         return result;
 125 }
 126
 127 static PyObject *
 128 time_time(PyObject *self, PyObject *unused)
 129 {
 130         double secs;
 131         secs = floattime();
 132         if (secs == 0.0) {
 133                 PyErr_SetFromErrno(PyExc_IOError);
 134                 return NULL;
 135         }
 136         return PyFloat_FromDouble(secs);
 137 }
 138
 139 PyDoc_STRVAR(time_doc,
 140 "time() -> floating point number\n\
 141 \n\
 142 Return the current time in seconds since the Epoch.\n\
 143 Fractions of a second may be present if the system clock provides them.");
 144
 145 #ifdef HAVE_CLOCK
 146
 147 #ifndef CLOCKS_PER_SEC
 148 #ifdef CLK_TCK
 149 #define CLOCKS_PER_SEC CLK_TCK
 150 #else
 151 #define CLOCKS_PER_SEC 1000000
 152 #endif
 153 #endif
 154
 155 static PyObject *
 156 time_clock(PyObject *self, PyObject *unused)
 157 {
 158         return PyFloat_FromDouble(((double)clock()) / CLOCKS_PER_SEC);
 159 }
 160 #endif /* HAVE_CLOCK */
 161
 162 #if defined(MS_WINDOWS) && !defined(__BORLANDC__)
 163 /* Due to Mark Hammond and Tim Peters */
 164 static PyObject *
 165 time_clock(PyObject *self, PyObject *unused)
 166 {
 167         static LARGE_INTEGER ctrStart;
 168         static double divisor = 0.0;
 169         LARGE_INTEGER now;
 170         double diff;
 171
 172         if (divisor == 0.0) {
 173                 LARGE_INTEGER freq;
 174                 QueryPerformanceCounter(&ctrStart);
 175                 if (!QueryPerformanceFrequency(&freq) || freq.QuadPart == 0) {
 176                         /* Unlikely to happen - this works on all intel
 177                            machines at least!  Revert to clock() */
 178                         return PyFloat_FromDouble(((double)clock()) /
 179                                                   CLOCKS_PER_SEC);
 180                 }
 181                 divisor = (double)freq.QuadPart;
 182         }
 183         QueryPerformanceCounter(&now);
 184         diff = (double)(now.QuadPart - ctrStart.QuadPart);
 185         return PyFloat_FromDouble(diff / divisor);
 186 }
 187
 188 #define HAVE_CLOCK /* So it gets included in the methods */
 189 #endif /* MS_WINDOWS && !defined(__BORLANDC__) */
 190
 191 #ifdef HAVE_CLOCK
 192 PyDoc_STRVAR(clock_doc,
 193 "clock() -> floating point number\n\
 194 \n\
 195 Return the CPU time or real time since the start of the process or since\n\
 196 the first call to clock().  This has as much precision as the system\n\
 197 records.");
 198 #endif
 199
 200 static PyObject *
 201 time_sleep(PyObject *self, PyObject *args)
 202 {
 203         double secs;
 204         if (!PyArg_ParseTuple(args, "d:sleep", &secs))
 205                 return NULL;
 206         if (floatsleep(secs) != 0)
 207                 return NULL;
 208         Py_INCREF(Py_None);
 209         return Py_None;
 210 }
 211
 212 PyDoc_STRVAR(sleep_doc,
 213 "sleep(seconds)\n\
 214 \n\
 215 Delay execution for a given number of seconds.  The argument may be\n\
 216 a floating point number for subsecond precision.");
 217
 218 static PyStructSequence_Field struct_time_type_fields[] = {
 219         {"tm_year", NULL},
 220         {"tm_mon", NULL},
 221         {"tm_mday", NULL},
 222         {"tm_hour", NULL},
 223         {"tm_min", NULL},
 224         {"tm_sec", NULL},
 225         {"tm_wday", NULL},
 226         {"tm_yday", NULL},
 227         {"tm_isdst", NULL},
 228         {0}
 229 };
 230
 231 static PyStructSequence_Desc struct_time_type_desc = {
 232         "time.struct_time",
 233         NULL,
 234         struct_time_type_fields,
 235         9,
 236 };
 237
 238 static int initialized;
 239 static PyTypeObject StructTimeType;
 240
 241 static PyObject *
 242 tmtotuple(struct tm *p)
 243 {
 244         PyObject *v = PyStructSequence_New(&StructTimeType);
 245         if (v == NULL)
 246                 return NULL;
 247
 248 #define SET(i,val) PyStructSequence_SET_ITEM(v, i, PyInt_FromLong((long) val))
 249
 250         SET(0, p->tm_year + 1900);
 251         SET(1, p->tm_mon + 1);     /* Want January == 1 */
 252         SET(2, p->tm_mday);
 253         SET(3, p->tm_hour);
 254         SET(4, p->tm_min);
 255         SET(5, p->tm_sec);
 256         SET(6, (p->tm_wday + 6) % 7); /* Want Monday == 0 */
 257         SET(7, p->tm_yday + 1);    /* Want January, 1 == 1 */
 258         SET(8, p->tm_isdst);
 259 #undef SET
 260         if (PyErr_Occurred()) {
 261                 Py_XDECREF(v);
 262                 return NULL;
 263         }
 264
 265         return v;
 266 }
 267
 268 static PyObject *
 269 time_convert(double when, struct tm * (*function)(const time_t *))
 270 {
 271         struct tm *p;
 272         time_t whent = _PyTime_DoubleToTimet(when);
 273
 274         if (whent == (time_t)-1 && PyErr_Occurred())
 275                 return NULL;
 276         errno = 0;
 277         p = function(&whent);
 278         if (p == NULL) {
 279 #ifdef EINVAL
 280                 if (errno == 0)
 281                         errno = EINVAL;
 282 #endif
 283                 return PyErr_SetFromErrno(PyExc_ValueError);
 284         }
 285         return tmtotuple(p);
 286 }
 287
 288 /* Parse arg tuple that can contain an optional float-or-None value;
 289    format needs to be "|O:name".
 290    Returns non-zero on success (parallels PyArg_ParseTuple).
 291 */
 292 static int
 293 parse_time_double_args(PyObject *args, char *format, double *pwhen)
 294 {
 295         PyObject *ot = NULL;
 296
 297         if (!PyArg_ParseTuple(args, format, &ot))
 298                 return 0;
 299         if (ot == NULL || ot == Py_None)
 300                 *pwhen = floattime();
 301         else {
 302                 double when = PyFloat_AsDouble(ot);
 303                 if (PyErr_Occurred())
 304                         return 0;
 305                 *pwhen = when;
 306         }
 307         return 1;
 308 }
 309
 310 static PyObject *
 311 time_gmtime(PyObject *self, PyObject *args)
 312 {
 313         double when;
 314         if (!parse_time_double_args(args, "|O:gmtime", &when))
 315                 return NULL;
 316         return time_convert(when, gmtime);
 317 }
 318
 319 PyDoc_STRVAR(gmtime_doc,
 320 "gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,\n\
 321                        tm_sec, tm_wday, tm_yday, tm_isdst)\n\
 322 \n\
 323 Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.\n\
 324 GMT).  When 'seconds' is not passed in, convert the current time instead.");
 325
 326 static PyObject *
 327 time_localtime(PyObject *self, PyObject *args)
 328 {
 329         double when;
 330         if (!parse_time_double_args(args, "|O:localtime", &when))
 331                 return NULL;
 332         return time_convert(when, localtime);
 333 }
 334
 335 PyDoc_STRVAR(localtime_doc,
 336 "localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)\n\
 337 \n\
 338 Convert seconds since the Epoch to a time tuple expressing local time.\n\
 339 When 'seconds' is not passed in, convert the current time instead.");
 340
 341 static int
 342 gettmarg(PyObject *args, struct tm *p)
 343 {
 344         int y;
 345         memset((void *) p, '\0', sizeof(struct tm));
 346
 347         if (!PyArg_Parse(args, "(iiiiiiiii)",
 348                          &y,
 349                          &p->tm_mon,
 350                          &p->tm_mday,
 351                          &p->tm_hour,
 352                          &p->tm_min,
 353                          &p->tm_sec,
 354                          &p->tm_wday,
 355                          &p->tm_yday,
 356                          &p->tm_isdst))
 357                 return 0;
 358         if (y < 1900) {
 359                 PyObject *accept = PyDict_GetItemString(moddict,
 360                                                         "accept2dyear");
 361                 if (accept == NULL || !PyInt_Check(accept) ||
 362                     PyInt_AsLong(accept) == 0) {
 363                         PyErr_SetString(PyExc_ValueError,
 364                                         "year >= 1900 required");
 365                         return 0;
 366                 }
 367                 if (69 <= y && y <= 99)
 368                         y += 1900;
 369                 else if (0 <= y && y <= 68)
 370                         y += 2000;
 371                 else {
 372                         PyErr_SetString(PyExc_ValueError,
 373                                         "year out of range");
 374                         return 0;
 375                 }
 376         }
 377         p->tm_year = y - 1900;
 378         p->tm_mon--;
 379         p->tm_wday = (p->tm_wday + 1) % 7;
 380         p->tm_yday--;
 381         return 1;
 382 }
 383
 384 #ifdef HAVE_STRFTIME
 385 static PyObject *
 386 time_strftime(PyObject *self, PyObject *args)
 387 {
 388         PyObject *tup = NULL;
 389         struct tm buf;
 390         const char *fmt;
 391         size_t fmtlen, buflen;
 392         char *outbuf = 0;
 393         size_t i;
 394
 395         memset((void *) &buf, '\0', sizeof(buf));
 396
 397         if (!PyArg_ParseTuple(args, "s|O:strftime", &fmt, &tup))
 398                 return NULL;
 399
 400         if (tup == NULL) {
 401                 time_t tt = time(NULL);
 402                 buf = *localtime(&tt);
 403         } else if (!gettmarg(tup, &buf))
 404                 return NULL;
 405
 406         /* Checks added to make sure strftime() does not crash Python by
 407             indexing blindly into some array for a textual representation
 408             by some bad index (fixes bug #897625).
 409
 410             Also support values of zero from Python code for arguments in which
 411             that is out of range by forcing that value to the lowest value that
 412             is valid (fixed bug #1520914).
 413
 414             Valid ranges based on what is allowed in struct tm:
 415
 416             - tm_year: [0, max(int)] (1)
 417             - tm_mon: [0, 11] (2)
 418             - tm_mday: [1, 31]
 419             - tm_hour: [0, 23]
 420             - tm_min: [0, 59]
 421             - tm_sec: [0, 60]
 422             - tm_wday: [0, 6] (1)
 423             - tm_yday: [0, 365] (2)
 424             - tm_isdst: [-max(int), max(int)]
 425
 426             (1) gettmarg() handles bounds-checking.
 427             (2) Python's acceptable range is one greater than the range in C,
 428                 thus need to check against automatic decrement by gettmarg().
 429         */
 430         if (buf.tm_mon == -1)
 431             buf.tm_mon = 0;
 432         else if (buf.tm_mon < 0 || buf.tm_mon > 11) {
 433             PyErr_SetString(PyExc_ValueError, "month out of range");
 434                         return NULL;
 435         }
 436         if (buf.tm_mday == 0)
 437             buf.tm_mday = 1;
 438         else if (buf.tm_mday < 0 || buf.tm_mday > 31) {
 439             PyErr_SetString(PyExc_ValueError, "day of month out of range");
 440                         return NULL;
 441         }
 442         if (buf.tm_hour < 0 || buf.tm_hour > 23) {
 443             PyErr_SetString(PyExc_ValueError, "hour out of range");
 444             return NULL;
 445         }
 446         if (buf.tm_min < 0 || buf.tm_min > 59) {
 447             PyErr_SetString(PyExc_ValueError, "minute out of range");
 448             return NULL;
 449         }
 450         if (buf.tm_sec < 0 || buf.tm_sec > 61) {
 451             PyErr_SetString(PyExc_ValueError, "seconds out of range");
 452             return NULL;
 453         }
 454         /* tm_wday does not need checking of its upper-bound since taking
 455         ``% 7`` in gettmarg() automatically restricts the range. */
 456         if (buf.tm_wday < 0) {
 457             PyErr_SetString(PyExc_ValueError, "day of week out of range");
 458             return NULL;
 459         }
 460         if (buf.tm_yday == -1)
 461             buf.tm_yday = 0;
 462         else if (buf.tm_yday < 0 || buf.tm_yday > 365) {
 463             PyErr_SetString(PyExc_ValueError, "day of year out of range");
 464             return NULL;
 465         }
 466         if (buf.tm_isdst < -1 || buf.tm_isdst > 1) {
 467             PyErr_SetString(PyExc_ValueError,
 468                             "daylight savings flag out of range");
 469             return NULL;
 470         }
 471
 472         fmtlen = strlen(fmt);
 473
 474         /* I hate these functions that presume you know how big the output
 475          * will be ahead of time...
 476          */
 477         for (i = 1024; ; i += i) {
 478                 outbuf = (char *)malloc(i);
 479                 if (outbuf == NULL) {
 480                         return PyErr_NoMemory();
 481                 }
 482                 buflen = strftime(outbuf, i, fmt, &buf);
 483                 if (buflen > 0 || i >= 256 * fmtlen) {
 484                         /* If the buffer is 256 times as long as the format,
 485                            it's probably not failing for lack of room!
 486                            More likely, the format yields an empty result,
 487                            e.g. an empty format, or %Z when the timezone
 488                            is unknown. */
 489                         PyObject *ret;
 490                         ret = PyString_FromStringAndSize(outbuf, buflen);
 491                         free(outbuf);
 492                         return ret;
 493                 }
 494                 free(outbuf);
 495 #if defined _MSC_VER && _MSC_VER >= 1400 && defined(__STDC_SECURE_LIB__)
 496                 /* VisualStudio .NET 2005 does this properly */
 497                 if (buflen == 0 && errno == EINVAL) {
 498                         PyErr_SetString(PyExc_ValueError, "Invalid format string");
 499                         return 0;
 500                 }
 501 #endif
 502
 503         }
 504 }
 505
 506 PyDoc_STRVAR(strftime_doc,
 507 "strftime(format[, tuple]) -> string\n\
 508 \n\
 509 Convert a time tuple to a string according to a format specification.\n\
 510 See the library reference manual for formatting codes. When the time tuple\n\
 511 is not present, current time as returned by localtime() is used.");
 512 #endif /* HAVE_STRFTIME */
 513
 514 static PyObject *
 515 time_strptime(PyObject *self, PyObject *args)
 516 {
 517     PyObject *strptime_module = PyImport_ImportModule("_strptime");
 518     PyObject *strptime_result;
 519
 520     if (!strptime_module)
 521         return NULL;
 522     strptime_result = PyObject_CallMethod(strptime_module, "strptime", "O", args);
 523     Py_DECREF(strptime_module);
 524     return strptime_result;
 525 }
 526
 527 PyDoc_STRVAR(strptime_doc,
 528 "strptime(string, format) -> struct_time\n\
 529 \n\
 530 Parse a string to a time tuple according to a format specification.\n\
 531 See the library reference manual for formatting codes (same as strftime()).");
 532
 533
 534 static PyObject *
 535 time_asctime(PyObject *self, PyObject *args)
 536 {
 537         PyObject *tup = NULL;
 538         struct tm buf;
 539         char *p;
 540         if (!PyArg_UnpackTuple(args, "asctime", 0, 1, &tup))
 541                 return NULL;
 542         if (tup == NULL) {
 543                 time_t tt = time(NULL);
 544                 buf = *localtime(&tt);
 545         } else if (!gettmarg(tup, &buf))
 546                 return NULL;
 547         p = asctime(&buf);
 548         if (p[24] == '\n')
 549                 p[24] = '\0';
 550         return PyString_FromString(p);
 551 }
 552
 553 PyDoc_STRVAR(asctime_doc,
 554 "asctime([tuple]) -> string\n\
 555 \n\
 556 Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.\n\
 557 When the time tuple is not present, current time as returned by localtime()\n\
 558 is used.");
 559
 560 static PyObject *
 561 time_ctime(PyObject *self, PyObject *args)
 562 {
 563         PyObject *ot = NULL;
 564         time_t tt;
 565         char *p;
 566
 567         if (!PyArg_UnpackTuple(args, "ctime", 0, 1, &ot))
 568                 return NULL;
 569         if (ot == NULL || ot == Py_None)
 570                 tt = time(NULL);
 571         else {
 572                 double dt = PyFloat_AsDouble(ot);
 573                 if (PyErr_Occurred())
 574                         return NULL;
 575                 tt = _PyTime_DoubleToTimet(dt);
 576                 if (tt == (time_t)-1 && PyErr_Occurred())
 577                         return NULL;
 578         }
 579         p = ctime(&tt);
 580         if (p == NULL) {
 581                 PyErr_SetString(PyExc_ValueError, "unconvertible time");
 582                 return NULL;
 583         }
 584         if (p[24] == '\n')
 585                 p[24] = '\0';
 586         return PyString_FromString(p);
 587 }
 588
 589 PyDoc_STRVAR(ctime_doc,
 590 "ctime(seconds) -> string\n\
 591 \n\
 592 Convert a time in seconds since the Epoch to a string in local time.\n\
 593 This is equivalent to asctime(localtime(seconds)). When the time tuple is\n\
 594 not present, current time as returned by localtime() is used.");
 595
 596 #ifdef HAVE_MKTIME
 597 static PyObject *
 598 time_mktime(PyObject *self, PyObject *tup)
 599 {
 600         struct tm buf;
 601         time_t tt;
 602         tt = time(&tt);
 603         buf = *localtime(&tt);
 604         if (!gettmarg(tup, &buf))
 605                 return NULL;
 606         tt = mktime(&buf);
 607         if (tt == (time_t)(-1)) {
 608                 PyErr_SetString(PyExc_OverflowError,
 609                                 "mktime argument out of range");
 610                 return NULL;
 611         }
 612         return PyFloat_FromDouble((double)tt);
 613 }
 614
 615 PyDoc_STRVAR(mktime_doc,
 616 "mktime(tuple) -> floating point number\n\
 617 \n\
 618 Convert a time tuple in local time to seconds since the Epoch.");
 619 #endif /* HAVE_MKTIME */
 620
 621 #ifdef HAVE_WORKING_TZSET
 622 void inittimezone(PyObject *module);
 623
 624 static PyObject *
 625 time_tzset(PyObject *self, PyObject *unused)
 626 {
 627         PyObject* m;
 628
 629         m = PyImport_ImportModule("time");
 630         if (m == NULL) {
 631             return NULL;
 632         }
 633
 634         tzset();
 635
 636         /* Reset timezone, altzone, daylight and tzname */
 637         inittimezone(m);
 638         Py_DECREF(m);
 639
 640         Py_INCREF(Py_None);
 641         return Py_None;
 642 }
 643
 644 PyDoc_STRVAR(tzset_doc,
 645 "tzset(zone)\n\
 646 \n\
 647 Initialize, or reinitialize, the local timezone to the value stored in\n\
 648 os.environ['TZ']. The TZ environment variable should be specified in\n\
 649 standard Unix timezone format as documented in the tzset man page\n\
 650 (eg. 'US/Eastern', 'Europe/Amsterdam'). Unknown timezones will silently\n\
 651 fall back to UTC. If the TZ environment variable is not set, the local\n\
 652 timezone is set to the systems best guess of wallclock time.\n\
 653 Changing the TZ environment variable without calling tzset *may* change\n\
 654 the local timezone used by methods such as localtime, but this behaviour\n\
 655 should not be relied on.");
 656 #endif /* HAVE_WORKING_TZSET */
 657
 658 void inittimezone(PyObject *m) {
 659     /* This code moved from inittime wholesale to allow calling it from
 660         time_tzset. In the future, some parts of it can be moved back
 661         (for platforms that don't HAVE_WORKING_TZSET, when we know what they
 662         are), and the extranious calls to tzset(3) should be removed.
 663         I havn't done this yet, as I don't want to change this code as
 664         little as possible when introducing the time.tzset and time.tzsetwall
 665         methods. This should simply be a method of doing the following once,
 666         at the top of this function and removing the call to tzset() from
 667         time_tzset():
 668
 669             #ifdef HAVE_TZSET
 670             tzset()
 671             #endif
 672
 673         And I'm lazy and hate C so nyer.
 674      */
 675 #if defined(HAVE_TZNAME) && !defined(__GLIBC__) && !defined(__CYGWIN__)
 676         tzset();
 677 #ifdef PYOS_OS2
 678         PyModule_AddIntConstant(m, "timezone", _timezone);
 679 #else /* !PYOS_OS2 */
 680         PyModule_AddIntConstant(m, "timezone", timezone);
 681 #endif /* PYOS_OS2 */
 682 #ifdef HAVE_ALTZONE
 683         PyModule_AddIntConstant(m, "altzone", altzone);
 684 #else
 685 #ifdef PYOS_OS2
 686         PyModule_AddIntConstant(m, "altzone", _timezone-3600);
 687 #else /* !PYOS_OS2 */
 688         PyModule_AddIntConstant(m, "altzone", timezone-3600);
 689 #endif /* PYOS_OS2 */
 690 #endif
 691         PyModule_AddIntConstant(m, "daylight", daylight);
 692         PyModule_AddObject(m, "tzname",
 693                            Py_BuildValue("(zz)", tzname[0], tzname[1]));
 694 #else /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
 695 #ifdef HAVE_STRUCT_TM_TM_ZONE
 696         {
 697 #define YEAR ((time_t)((365 * 24 + 6) * 3600))
 698                 time_t t;
 699                 struct tm *p;
 700                 long janzone, julyzone;
 701                 char janname[10], julyname[10];
 702                 t = (time((time_t *)0) / YEAR) * YEAR;
 703                 p = localtime(&t);
 704                 janzone = -p->tm_gmtoff;
 705                 strncpy(janname, p->tm_zone ? p->tm_zone : "   ", 9);
 706                 janname[9] = '\0';
 707                 t += YEAR/2;
 708                 p = localtime(&t);
 709                 julyzone = -p->tm_gmtoff;
 710                 strncpy(julyname, p->tm_zone ? p->tm_zone : "   ", 9);
 711                 julyname[9] = '\0';
 712
 713                 if( janzone < julyzone ) {
 714                         /* DST is reversed in the southern hemisphere */
 715                         PyModule_AddIntConstant(m, "timezone", julyzone);
 716                         PyModule_AddIntConstant(m, "altzone", janzone);
 717                         PyModule_AddIntConstant(m, "daylight",
 718                                                 janzone != julyzone);
 719                         PyModule_AddObject(m, "tzname",
 720                                            Py_BuildValue("(zz)",
 721                                                          julyname, janname));
 722                 } else {
 723                         PyModule_AddIntConstant(m, "timezone", janzone);
 724                         PyModule_AddIntConstant(m, "altzone", julyzone);
 725                         PyModule_AddIntConstant(m, "daylight",
 726                                                 janzone != julyzone);
 727                         PyModule_AddObject(m, "tzname",
 728                                            Py_BuildValue("(zz)",
 729                                                          janname, julyname));
 730                 }
 731         }
 732 #else
 733 #endif /* HAVE_STRUCT_TM_TM_ZONE */
 734 #ifdef __CYGWIN__
 735         tzset();
 736         PyModule_AddIntConstant(m, "timezone", _timezone);
 737         PyModule_AddIntConstant(m, "altzone", _timezone-3600);
 738         PyModule_AddIntConstant(m, "daylight", _daylight);
 739         PyModule_AddObject(m, "tzname",
 740                            Py_BuildValue("(zz)", _tzname[0], _tzname[1]));
 741 #endif /* __CYGWIN__ */
 742 #endif /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
 743 }
 744
 745
 746 static PyMethodDef time_methods[] = {
 747         {"time",        time_time, METH_NOARGS, time_doc},
 748 #ifdef HAVE_CLOCK
 749         {"clock",       time_clock, METH_NOARGS, clock_doc},
 750 #endif
 751         {"sleep",       time_sleep, METH_VARARGS, sleep_doc},
 752         {"gmtime",      time_gmtime, METH_VARARGS, gmtime_doc},
 753         {"localtime",   time_localtime, METH_VARARGS, localtime_doc},
 754         {"asctime",     time_asctime, METH_VARARGS, asctime_doc},
 755         {"ctime",       time_ctime, METH_VARARGS, ctime_doc},
 756 #ifdef HAVE_MKTIME
 757         {"mktime",      time_mktime, METH_O, mktime_doc},
 758 #endif
 759 #ifdef HAVE_STRFTIME
 760         {"strftime",    time_strftime, METH_VARARGS, strftime_doc},
 761 #endif
 762         {"strptime",    time_strptime, METH_VARARGS, strptime_doc},
 763 #ifdef HAVE_WORKING_TZSET
 764         {"tzset",       time_tzset, METH_NOARGS, tzset_doc},
 765 #endif
 766         {NULL,          NULL}           /* sentinel */
 767 };
 768
 769
 770 PyDoc_STRVAR(module_doc,
 771 "This module provides various functions to manipulate time values.\n\
 772 \n\
 773 There are two standard representations of time.  One is the number\n\
 774 of seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an integer\n\
 775 or a floating point number (to represent fractions of seconds).\n\
 776 The Epoch is system-defined; on Unix, it is generally January 1st, 1970.\n\
 777 The actual value can be retrieved by calling gmtime(0).\n\
 778 \n\
 779 The other representation is a tuple of 9 integers giving local time.\n\
 780 The tuple items are:\n\
 781   year (four digits, e.g. 1998)\n\
 782   month (1-12)\n\
 783   day (1-31)\n\
 784   hours (0-23)\n\
 785   minutes (0-59)\n\
 786   seconds (0-59)\n\
 787   weekday (0-6, Monday is 0)\n\
 788   Julian day (day in the year, 1-366)\n\
 789   DST (Daylight Savings Time) flag (-1, 0 or 1)\n\
 790 If the DST flag is 0, the time is given in the regular time zone;\n\
 791 if it is 1, the time is given in the DST time zone;\n\
 792 if it is -1, mktime() should guess based on the date and time.\n\
 793 \n\
 794 Variables:\n\
 795 \n\
 796 timezone -- difference in seconds between UTC and local standard time\n\
 797 altzone -- difference in  seconds between UTC and local DST time\n\
 798 daylight -- whether local time should reflect DST\n\
 799 tzname -- tuple of (standard time zone name, DST time zone name)\n\
 800 \n\
 801 Functions:\n\
 802 \n\
 803 time() -- return current time in seconds since the Epoch as a float\n\
 804 clock() -- return CPU time since process start as a float\n\
 805 sleep() -- delay for a number of seconds given as a float\n\
 806 gmtime() -- convert seconds since Epoch to UTC tuple\n\
 807 localtime() -- convert seconds since Epoch to local time tuple\n\
 808 asctime() -- convert time tuple to string\n\
 809 ctime() -- convert time in seconds to string\n\
 810 mktime() -- convert local time tuple to seconds since Epoch\n\
 811 strftime() -- convert time tuple to string according to format specification\n\
 812 strptime() -- parse string to time tuple according to format specification\n\
 813 tzset() -- change the local timezone");
 814
 815
 816 PyMODINIT_FUNC
 817 inittime(void)
 818 {
 819         PyObject *m;
 820         char *p;
 821         m = Py_InitModule3("time", time_methods, module_doc);
 822         if (m == NULL)
 823                 return;
 824
 825         /* Accept 2-digit dates unless PYTHONY2K is set and non-empty */
 826         p = Py_GETENV("PYTHONY2K");
 827         PyModule_AddIntConstant(m, "accept2dyear", (long) (!p || !*p));
 828         /* Squirrel away the module's dictionary for the y2k check */
 829         moddict = PyModule_GetDict(m);
 830         Py_INCREF(moddict);
 831
 832         /* Set, or reset, module variables like time.timezone */
 833         inittimezone(m);
 834
 835 #ifdef MS_WINDOWS
 836         /* Helper to allow interrupts for Windows.
 837            If Ctrl+C event delivered while not sleeping
 838            it will be ignored.
 839         */
 840         main_thread = PyThread_get_thread_ident();
 841         hInterruptEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 842         SetConsoleCtrlHandler( PyCtrlHandler, TRUE);
 843 #endif /* MS_WINDOWS */
 844         if (!initialized) {
 845                 PyStructSequence_InitType(&StructTimeType,
 846                                           &struct_time_type_desc);
 847         }
 848         Py_INCREF(&StructTimeType);
 849         PyModule_AddObject(m, "struct_time", (PyObject*) &StructTimeType);
 850         initialized = 1;
 851 }
 852
 853
 854 /* Implement floattime() for various platforms */
 855
 856 static double
 857 floattime(void)
 858 {
 859         /* There are three ways to get the time:
 860           (1) gettimeofday() -- resolution in microseconds
 861           (2) ftime() -- resolution in milliseconds
 862           (3) time() -- resolution in seconds
 863           In all cases the return value is a float in seconds.
 864           Since on some systems (e.g. SCO ODT 3.0) gettimeofday() may
 865           fail, so we fall back on ftime() or time().
 866           Note: clock resolution does not imply clock accuracy! */
 867 #ifdef HAVE_GETTIMEOFDAY
 868         {
 869                 struct timeval t;
 870 #ifdef GETTIMEOFDAY_NO_TZ
 871                 if (gettimeofday(&t) == 0)
 872                         return (double)t.tv_sec + t.tv_usec*0.000001;
 873 #else /* !GETTIMEOFDAY_NO_TZ */
 874                 if (gettimeofday(&t, (struct timezone *)NULL) == 0)
 875                         return (double)t.tv_sec + t.tv_usec*0.000001;
 876 #endif /* !GETTIMEOFDAY_NO_TZ */
 877         }
 878
 879 #endif /* !HAVE_GETTIMEOFDAY */
 880         {
 881 #if defined(HAVE_FTIME)
 882                 struct timeb t;
 883                 ftime(&t);
 884                 return (double)t.time + (double)t.millitm * (double)0.001;
 885 #else /* !HAVE_FTIME */
 886                 time_t secs;
 887                 time(&secs);
 888                 return (double)secs;
 889 #endif /* !HAVE_FTIME */
 890         }
 891 }
 892
 893
 894 /* Implement floatsleep() for various platforms.
 895    When interrupted (or when another error occurs), return -1 and
 896    set an exception; else return 0. */
 897
 898 static int
 899 floatsleep(double secs)
 900 {
 901 /* XXX Should test for MS_WINDOWS first! */
 902 #if defined(HAVE_SELECT) && !defined(__BEOS__) && !defined(__EMX__)
 903         struct timeval t;
 904         double frac;
 905         frac = fmod(secs, 1.0);
 906         secs = floor(secs);
 907         t.tv_sec = (long)secs;
 908         t.tv_usec = (long)(frac*1000000.0);
 909         Py_BEGIN_ALLOW_THREADS
 910         if (select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &t) != 0) {
 911 #ifdef EINTR
 912                 if (errno != EINTR) {
 913 #else
 914                 if (1) {
 915 #endif
 916                         Py_BLOCK_THREADS
 917                         PyErr_SetFromErrno(PyExc_IOError);
 918                         return -1;
 919                 }
 920         }
 921         Py_END_ALLOW_THREADS
 922 #elif defined(__WATCOMC__) && !defined(__QNX__)
 923         /* XXX Can't interrupt this sleep */
 924         Py_BEGIN_ALLOW_THREADS
 925         delay((int)(secs * 1000 + 0.5));  /* delay() uses milliseconds */
 926         Py_END_ALLOW_THREADS
 927 #elif defined(MS_WINDOWS)
 928         {
 929                 double millisecs = secs * 1000.0;
 930                 unsigned long ul_millis;
 931
 932                 if (millisecs > (double)ULONG_MAX) {
 933                         PyErr_SetString(PyExc_OverflowError,
 934                                         "sleep length is too large");
 935                         return -1;
 936                 }
 937                 Py_BEGIN_ALLOW_THREADS
 938                 /* Allow sleep(0) to maintain win32 semantics, and as decreed
 939                  * by Guido, only the main thread can be interrupted.
 940                  */
 941                 ul_millis = (unsigned long)millisecs;
 942                 if (ul_millis == 0 ||
 943                     main_thread != PyThread_get_thread_ident())
 944                         Sleep(ul_millis);
 945                 else {
 946                         DWORD rc;
 947                         ResetEvent(hInterruptEvent);
 948                         rc = WaitForSingleObject(hInterruptEvent, ul_millis);
 949                         if (rc == WAIT_OBJECT_0) {
 950                                 /* Yield to make sure real Python signal
 951                                  * handler called.
 952                                  */
 953                                 Sleep(1);
 954                                 Py_BLOCK_THREADS
 955                                 errno = EINTR;
 956                                 PyErr_SetFromErrno(PyExc_IOError);
 957                                 return -1;
 958                         }
 959                 }
 960                 Py_END_ALLOW_THREADS
 961         }
 962 #elif defined(PYOS_OS2)
 963         /* This Sleep *IS* Interruptable by Exceptions */
 964         Py_BEGIN_ALLOW_THREADS
 965         if (DosSleep(secs * 1000) != NO_ERROR) {
 966                 Py_BLOCK_THREADS
 967                 PyErr_SetFromErrno(PyExc_IOError);
 968                 return -1;
 969         }
 970         Py_END_ALLOW_THREADS
 971 #elif defined(__BEOS__)
 972         /* This sleep *CAN BE* interrupted. */
 973         {
 974                 if( secs <= 0.0 ) {
 975                         return;
 976                 }
 977
 978                 Py_BEGIN_ALLOW_THREADS
 979                 /* BeOS snooze() is in microseconds... */
 980                 if( snooze( (bigtime_t)( secs * 1000.0 * 1000.0 ) ) == B_INTERRUPTED ) {
 981                         Py_BLOCK_THREADS
 982                         PyErr_SetFromErrno( PyExc_IOError );
 983                         return -1;
 984                 }
 985                 Py_END_ALLOW_THREADS
 986         }
 987 #elif defined(RISCOS)
 988         if (secs <= 0.0)
 989                 return 0;
 990         Py_BEGIN_ALLOW_THREADS
 991         /* This sleep *CAN BE* interrupted. */
 992         if ( riscos_sleep(secs) )
 993                 return -1;
 994         Py_END_ALLOW_THREADS
 995 #elif defined(PLAN9)
 996         {
 997                 double millisecs = secs * 1000.0;
 998                 if (millisecs > (double)LONG_MAX) {
 999                         PyErr_SetString(PyExc_OverflowError, "sleep length is too large");
1000                         return -1;
1001                 }
1002                 /* This sleep *CAN BE* interrupted. */
1003                 Py_BEGIN_ALLOW_THREADS
1004                 if(sleep((long)millisecs) < 0){
1005                         Py_BLOCK_THREADS
1006                         PyErr_SetFromErrno(PyExc_IOError);
1007                         return -1;
1008                 }
1009                 Py_END_ALLOW_THREADS
1010         }
1011 #else
1012         /* XXX Can't interrupt this sleep */
1013         Py_BEGIN_ALLOW_THREADS
1014         sleep((int)secs);
1015         Py_END_ALLOW_THREADS
1016 #endif
1017
1018         return 0;
1019 }
1020
1021