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