timemodule.c revision 30712ab82f7c545cfe89ddf56de135bfbf0ccb67
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_day, 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_day,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)\n\ 337\n\ 338Convert seconds since the Epoch to a time tuple expressing local time.\n\ 339When 'seconds' is not passed in, convert the current time instead."); 340 341static int 342gettmarg(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 385static PyObject * 386time_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 506PyDoc_STRVAR(strftime_doc, 507"strftime(format[, tuple]) -> string\n\ 508\n\ 509Convert a time tuple to a string according to a format specification.\n\ 510See the library reference manual for formatting codes. When the time tuple\n\ 511is not present, current time as returned by localtime() is used."); 512#endif /* HAVE_STRFTIME */ 513 514static PyObject * 515time_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 527PyDoc_STRVAR(strptime_doc, 528"strptime(string, format) -> struct_time\n\ 529\n\ 530Parse a string to a time tuple according to a format specification.\n\ 531See the library reference manual for formatting codes (same as strftime())."); 532 533 534static PyObject * 535time_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 553PyDoc_STRVAR(asctime_doc, 554"asctime([tuple]) -> string\n\ 555\n\ 556Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.\n\ 557When the time tuple is not present, current time as returned by localtime()\n\ 558is used."); 559 560static PyObject * 561time_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 589PyDoc_STRVAR(ctime_doc, 590"ctime(seconds) -> string\n\ 591\n\ 592Convert a time in seconds since the Epoch to a string in local time.\n\ 593This is equivalent to asctime(localtime(seconds)). When the time tuple is\n\ 594not present, current time as returned by localtime() is used."); 595 596#ifdef HAVE_MKTIME 597static PyObject * 598time_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 615PyDoc_STRVAR(mktime_doc, 616"mktime(tuple) -> floating point number\n\ 617\n\ 618Convert a time tuple in local time to seconds since the Epoch."); 619#endif /* HAVE_MKTIME */ 620 621#ifdef HAVE_WORKING_TZSET 622void inittimezone(PyObject *module); 623 624static PyObject * 625time_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 644PyDoc_STRVAR(tzset_doc, 645"tzset(zone)\n\ 646\n\ 647Initialize, or reinitialize, the local timezone to the value stored in\n\ 648os.environ['TZ']. The TZ environment variable should be specified in\n\ 649standard Unix timezone format as documented in the tzset man page\n\ 650(eg. 'US/Eastern', 'Europe/Amsterdam'). Unknown timezones will silently\n\ 651fall back to UTC. If the TZ environment variable is not set, the local\n\ 652timezone is set to the systems best guess of wallclock time.\n\ 653Changing the TZ environment variable without calling tzset *may* change\n\ 654the local timezone used by methods such as localtime, but this behaviour\n\ 655should not be relied on."); 656#endif /* HAVE_WORKING_TZSET */ 657 658void 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 haven'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 746static 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 770PyDoc_STRVAR(module_doc, 771"This module provides various functions to manipulate time values.\n\ 772\n\ 773There are two standard representations of time. One is the number\n\ 774of seconds since the Epoch, in UTC (a.k.a. GMT). It may be an integer\n\ 775or a floating point number (to represent fractions of seconds).\n\ 776The Epoch is system-defined; on Unix, it is generally January 1st, 1970.\n\ 777The actual value can be retrieved by calling gmtime(0).\n\ 778\n\ 779The other representation is a tuple of 9 integers giving local time.\n\ 780The 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\ 790If the DST flag is 0, the time is given in the regular time zone;\n\ 791if it is 1, the time is given in the DST time zone;\n\ 792if it is -1, mktime() should guess based on the date and time.\n\ 793\n\ 794Variables:\n\ 795\n\ 796timezone -- difference in seconds between UTC and local standard time\n\ 797altzone -- difference in seconds between UTC and local DST time\n\ 798daylight -- whether local time should reflect DST\n\ 799tzname -- tuple of (standard time zone name, DST time zone name)\n\ 800\n\ 801Functions:\n\ 802\n\ 803time() -- return current time in seconds since the Epoch as a float\n\ 804clock() -- return CPU time since process start as a float\n\ 805sleep() -- delay for a number of seconds given as a float\n\ 806gmtime() -- convert seconds since Epoch to UTC tuple\n\ 807localtime() -- convert seconds since Epoch to local time tuple\n\ 808asctime() -- convert time tuple to string\n\ 809ctime() -- convert time in seconds to string\n\ 810mktime() -- convert local time tuple to seconds since Epoch\n\ 811strftime() -- convert time tuple to string according to format specification\n\ 812strptime() -- parse string to time tuple according to format specification\n\ 813tzset() -- change the local timezone"); 814 815 816PyMODINIT_FUNC 817inittime(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 856static double 857floattime(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 898static int 899floatsleep(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 1022