source: vendor/python/2.5/Modules/timemodule.c

Last change on this file was 3225, checked in by bird, 18 years ago

Python 2.5
File size: 26.8 KB
Line 
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(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
191PyDoc_STRVAR(clock_doc,
192"clock() -> floating point number\n\
193\n\
194Return the CPU time or real time since the start of the process or since\n\
195the first call to clock(). This has as much precision as the system\n\
196records.");
197#endif
198
199static PyObject *
200time_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
211PyDoc_STRVAR(sleep_doc,
212"sleep(seconds)\n\
213\n\
214Delay execution for a given number of seconds. The argument may be\n\
215a floating point number for subsecond precision.");
216
217static 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
230static PyStructSequence_Desc struct_time_type_desc = {
231 "time.struct_time",
232 NULL,
233 struct_time_type_fields,
234 9,
235};
236
237static int initialized;
238static PyTypeObject StructTimeType;
239
240static PyObject *
241tmtotuple(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
267static PyObject *
268time_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*/
291static int
292parse_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
309static PyObject *
310time_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
318PyDoc_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\
322Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.\n\
323GMT). When 'seconds' is not passed in, convert the current time instead.");
324
325static PyObject *
326time_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
334PyDoc_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\
337Convert seconds since the Epoch to a time tuple expressing local time.\n\
338When 'seconds' is not passed in, convert the current time instead.");
339
340static int
341gettmarg(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
384static PyObject *
385time_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
505PyDoc_STRVAR(strftime_doc,
506"strftime(format[, tuple]) -> string\n\
507\n\
508Convert a time tuple to a string according to a format specification.\n\
509See the library reference manual for formatting codes. When the time tuple\n\
510is not present, current time as returned by localtime() is used.");
511#endif /* HAVE_STRFTIME */
512
513static PyObject *
514time_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
526PyDoc_STRVAR(strptime_doc,
527"strptime(string, format) -> struct_time\n\
528\n\
529Parse a string to a time tuple according to a format specification.\n\
530See the library reference manual for formatting codes (same as strftime()).");
531
532
533static PyObject *
534time_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
552PyDoc_STRVAR(asctime_doc,
553"asctime([tuple]) -> string\n\
554\n\
555Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.\n\
556When the time tuple is not present, current time as returned by localtime()\n\
557is used.");
558
559static PyObject *
560time_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
588PyDoc_STRVAR(ctime_doc,
589"ctime(seconds) -> string\n\
590\n\
591Convert a time in seconds since the Epoch to a string in local time.\n\
592This is equivalent to asctime(localtime(seconds)). When the time tuple is\n\
593not present, current time as returned by localtime() is used.");
594
595#ifdef HAVE_MKTIME
596static PyObject *
597time_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
614PyDoc_STRVAR(mktime_doc,
615"mktime(tuple) -> floating point number\n\
616\n\
617Convert a time tuple in local time to seconds since the Epoch.");
618#endif /* HAVE_MKTIME */
619
620#ifdef HAVE_WORKING_TZSET
621void inittimezone(PyObject *module);
622
623static PyObject *
624time_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
643PyDoc_STRVAR(tzset_doc,
644"tzset(zone)\n\
645\n\
646Initialize, or reinitialize, the local timezone to the value stored in\n\
647os.environ['TZ']. The TZ environment variable should be specified in\n\
648standard Unix timezone format as documented in the tzset man page\n\
649(eg. 'US/Eastern', 'Europe/Amsterdam'). Unknown timezones will silently\n\
650fall back to UTC. If the TZ environment variable is not set, the local\n\
651timezone is set to the systems best guess of wallclock time.\n\
652Changing the TZ environment variable without calling tzset *may* change\n\
653the local timezone used by methods such as localtime, but this behaviour\n\
654should not be relied on.");
655#endif /* HAVE_WORKING_TZSET */
656
657void 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
745static 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
769PyDoc_STRVAR(module_doc,
770"This module provides various functions to manipulate time values.\n\
771\n\
772There are two standard representations of time. One is the number\n\
773of seconds since the Epoch, in UTC (a.k.a. GMT). It may be an integer\n\
774or a floating point number (to represent fractions of seconds).\n\
775The Epoch is system-defined; on Unix, it is generally January 1st, 1970.\n\
776The actual value can be retrieved by calling gmtime(0).\n\
777\n\
778The other representation is a tuple of 9 integers giving local time.\n\
779The 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\
789If the DST flag is 0, the time is given in the regular time zone;\n\
790if it is 1, the time is given in the DST time zone;\n\
791if it is -1, mktime() should guess based on the date and time.\n\
792\n\
793Variables:\n\
794\n\
795timezone -- difference in seconds between UTC and local standard time\n\
796altzone -- difference in seconds between UTC and local DST time\n\
797daylight -- whether local time should reflect DST\n\
798tzname -- tuple of (standard time zone name, DST time zone name)\n\
799\n\
800Functions:\n\
801\n\
802time() -- return current time in seconds since the Epoch as a float\n\
803clock() -- return CPU time since process start as a float\n\
804sleep() -- delay for a number of seconds given as a float\n\
805gmtime() -- convert seconds since Epoch to UTC tuple\n\
806localtime() -- convert seconds since Epoch to local time tuple\n\
807asctime() -- convert time tuple to string\n\
808ctime() -- convert time in seconds to string\n\
809mktime() -- convert local time tuple to seconds since Epoch\n\
810strftime() -- convert time tuple to string according to format specification\n\
811strptime() -- parse string to time tuple according to format specification\n\
812tzset() -- change the local timezone");
813
814
815PyMODINIT_FUNC
816inittime(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
855static double
856floattime(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
897static int
898floatsleep(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
Note: See TracBrowser for help on using the repository browser.