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