source: python/trunk/Modules/timemodule.c@ 20

Last change on this file since 20 was 2, checked in by Yuri Dario, 15 years ago

Initial import for vendor code.
  • Property svn:eol-style set to native
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(((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 = PyString_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 PyString_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 PyString_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 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
621static void inittimezone(PyObject *module);
622
623static PyObject *
624time_tzset(PyObject *self, PyObject *unused)
625{
626 PyObject* m;
627
628 m = PyImport_ImportModuleNoBlock("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
657static void
658inittimezone(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 extraneous 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
Note: See TracBrowser for help on using the repository browser.