• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 
2 /* Time module */
3 
4 #include "Python.h"
5 #include "structseq.h"
6 #include "timefuncs.h"
7 
8 #ifdef __APPLE__
9 #if defined(HAVE_GETTIMEOFDAY) && defined(HAVE_FTIME)
10   /*
11    * floattime falls back to ftime when getttimeofday fails because the latter
12    * might fail on some platforms. This fallback is unwanted on MacOSX because
13    * that makes it impossible to use a binary build on OSX 10.4 on earlier
14    * releases of the OS. Therefore claim we don't support ftime.
15    */
16 # undef HAVE_FTIME
17 #endif
18 #endif
19 
20 #include <ctype.h>
21 
22 #ifdef HAVE_SYS_TYPES_H
23 #include <sys/types.h>
24 #endif /* HAVE_SYS_TYPES_H */
25 
26 #ifdef QUICKWIN
27 #include <io.h>
28 #endif
29 
30 #ifdef HAVE_FTIME
31 #include <sys/timeb.h>
32 #if !defined(MS_WINDOWS) && !defined(PYOS_OS2)
33 extern int ftime(struct timeb *);
34 #endif /* MS_WINDOWS */
35 #endif /* HAVE_FTIME */
36 
37 #if defined(__WATCOMC__) && !defined(__QNX__)
38 #include <i86.h>
39 #else
40 #ifdef MS_WINDOWS
41 #define WIN32_LEAN_AND_MEAN
42 #include <windows.h>
43 #include "pythread.h"
44 
45 /* helper to allow us to interrupt sleep() on Windows*/
46 static HANDLE hInterruptEvent = NULL;
PyCtrlHandler(DWORD dwCtrlType)47 static BOOL WINAPI PyCtrlHandler(DWORD dwCtrlType)
48 {
49     SetEvent(hInterruptEvent);
50     /* allow other default handlers to be called.
51        Default Python handler will setup the
52        KeyboardInterrupt exception.
53     */
54     return FALSE;
55 }
56 static long main_thread;
57 
58 
59 #if defined(__BORLANDC__)
60 /* These overrides not needed for Win32 */
61 #define timezone _timezone
62 #define tzname _tzname
63 #define daylight _daylight
64 #endif /* __BORLANDC__ */
65 #endif /* MS_WINDOWS */
66 #endif /* !__WATCOMC__ || __QNX__ */
67 
68 #if defined(MS_WINDOWS) && !defined(__BORLANDC__)
69 /* Win32 has better clock replacement; we have our own version below. */
70 #undef HAVE_CLOCK
71 #endif /* MS_WINDOWS && !defined(__BORLANDC__) */
72 
73 #if defined(PYOS_OS2)
74 #define INCL_DOS
75 #define INCL_ERRORS
76 #include <os2.h>
77 #endif
78 
79 #if defined(PYCC_VACPP)
80 #include <sys/time.h>
81 #endif
82 
83 #ifdef __BEOS__
84 #include <time.h>
85 /* For bigtime_t, snooze(). - [cjh] */
86 #include <support/SupportDefs.h>
87 #include <kernel/OS.h>
88 #endif
89 
90 #ifdef RISCOS
91 extern int riscos_sleep(double);
92 #endif
93 
94 /* Forward declarations */
95 static int floatsleep(double);
96 static double floattime(void);
97 
98 /* For Y2K check */
99 static PyObject *moddict = NULL;
100 
101 /* Exposed in timefuncs.h. */
102 time_t
_PyTime_DoubleToTimet(double x)103 _PyTime_DoubleToTimet(double x)
104 {
105     time_t result;
106     double diff;
107 
108     result = (time_t)x;
109     /* How much info did we lose?  time_t may be an integral or
110      * floating type, and we don't know which.  If it's integral,
111      * we don't know whether C truncates, rounds, returns the floor,
112      * etc.  If we lost a second or more, the C rounding is
113      * unreasonable, or the input just doesn't fit in a time_t;
114      * call it an error regardless.  Note that the original cast to
115      * time_t can cause a C error too, but nothing we can do to
116      * worm around that.
117      */
118     diff = x - (double)result;
119     if (diff <= -1.0 || diff >= 1.0) {
120         PyErr_SetString(PyExc_ValueError,
121                         "timestamp out of range for platform time_t");
122         result = (time_t)-1;
123     }
124     return result;
125 }
126 
127 static PyObject *
time_time(PyObject * self,PyObject * unused)128 time_time(PyObject *self, PyObject *unused)
129 {
130     double secs;
131     secs = floattime();
132     if (secs == 0.0) {
133         PyErr_SetFromErrno(PyExc_IOError);
134         return NULL;
135     }
136     return PyFloat_FromDouble(secs);
137 }
138 
139 PyDoc_STRVAR(time_doc,
140 "time() -> floating point number\n\
141 \n\
142 Return the current time in seconds since the Epoch.\n\
143 Fractions of a second may be present if the system clock provides them.");
144 
145 #ifdef HAVE_CLOCK
146 
147 #ifndef CLOCKS_PER_SEC
148 #ifdef CLK_TCK
149 #define CLOCKS_PER_SEC CLK_TCK
150 #else
151 #define CLOCKS_PER_SEC 1000000
152 #endif
153 #endif
154 
155 static PyObject *
time_clock(PyObject * self,PyObject * unused)156 time_clock(PyObject *self, PyObject *unused)
157 {
158     return PyFloat_FromDouble(((double)clock()) / CLOCKS_PER_SEC);
159 }
160 #endif /* HAVE_CLOCK */
161 
162 #if defined(MS_WINDOWS) && !defined(__BORLANDC__)
163 /* Due to Mark Hammond and Tim Peters */
164 static PyObject *
time_clock(PyObject * self,PyObject * unused)165 time_clock(PyObject *self, PyObject *unused)
166 {
167     static LARGE_INTEGER ctrStart;
168     static double divisor = 0.0;
169     LARGE_INTEGER now;
170     double diff;
171 
172     if (divisor == 0.0) {
173         LARGE_INTEGER freq;
174         QueryPerformanceCounter(&ctrStart);
175         if (!QueryPerformanceFrequency(&freq) || freq.QuadPart == 0) {
176             /* Unlikely to happen - this works on all intel
177                machines at least!  Revert to clock() */
178             return PyFloat_FromDouble(((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
192 PyDoc_STRVAR(clock_doc,
193 "clock() -> floating point number\n\
194 \n\
195 Return the CPU time or real time since the start of the process or since\n\
196 the first call to clock().  This has as much precision as the system\n\
197 records.");
198 #endif
199 
200 static PyObject *
time_sleep(PyObject * self,PyObject * args)201 time_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 
212 PyDoc_STRVAR(sleep_doc,
213 "sleep(seconds)\n\
214 \n\
215 Delay execution for a given number of seconds.  The argument may be\n\
216 a floating point number for subsecond precision.");
217 
218 static PyStructSequence_Field struct_time_type_fields[] = {
219     {"tm_year", "year, for example, 1993"},
220     {"tm_mon", "month of year, range [1, 12]"},
221     {"tm_mday", "day of month, range [1, 31]"},
222     {"tm_hour", "hours, range [0, 23]"},
223     {"tm_min", "minutes, range [0, 59]"},
224     {"tm_sec", "seconds, range [0, 61])"},
225     {"tm_wday", "day of week, range [0, 6], Monday is 0"},
226     {"tm_yday", "day of year, range [1, 366]"},
227     {"tm_isdst", "1 if summer time is in effect, 0 if not, and -1 if unknown"},
228     {0}
229 };
230 
231 static PyStructSequence_Desc struct_time_type_desc = {
232     "time.struct_time",
233     "The time value as returned by gmtime(), localtime(), and strptime(), and\n"
234     " accepted by asctime(), mktime() and strftime().  May be considered as a\n"
235     " sequence of 9 integers.\n\n"
236     " Note that several fields' values are not the same as those defined by\n"
237     " the C language standard for struct tm.  For example, the value of the\n"
238     " field tm_year is the actual year, not year - 1900.  See individual\n"
239     " fields' descriptions for details.",
240     struct_time_type_fields,
241     9,
242 };
243 
244 static int initialized;
245 static PyTypeObject StructTimeType;
246 
247 static PyObject *
tmtotuple(struct tm * p)248 tmtotuple(struct tm *p)
249 {
250     PyObject *v = PyStructSequence_New(&StructTimeType);
251     if (v == NULL)
252         return NULL;
253 
254 #define SET(i,val) PyStructSequence_SET_ITEM(v, i, PyInt_FromLong((long) val))
255 
256     SET(0, p->tm_year + 1900);
257     SET(1, p->tm_mon + 1);         /* Want January == 1 */
258     SET(2, p->tm_mday);
259     SET(3, p->tm_hour);
260     SET(4, p->tm_min);
261     SET(5, p->tm_sec);
262     SET(6, (p->tm_wday + 6) % 7); /* Want Monday == 0 */
263     SET(7, p->tm_yday + 1);        /* Want January, 1 == 1 */
264     SET(8, p->tm_isdst);
265 #undef SET
266     if (PyErr_Occurred()) {
267         Py_XDECREF(v);
268         return NULL;
269     }
270 
271     return v;
272 }
273 
274 static PyObject *
time_convert(double when,struct tm * (* function)(const time_t *))275 time_convert(double when, struct tm * (*function)(const time_t *))
276 {
277     struct tm *p;
278     time_t whent = _PyTime_DoubleToTimet(when);
279 
280     if (whent == (time_t)-1 && PyErr_Occurred())
281         return NULL;
282     errno = 0;
283     p = function(&whent);
284     if (p == NULL) {
285 #ifdef EINVAL
286         if (errno == 0)
287             errno = EINVAL;
288 #endif
289         return PyErr_SetFromErrno(PyExc_ValueError);
290     }
291     return tmtotuple(p);
292 }
293 
294 /* Parse arg tuple that can contain an optional float-or-None value;
295    format needs to be "|O:name".
296    Returns non-zero on success (parallels PyArg_ParseTuple).
297 */
298 static int
parse_time_double_args(PyObject * args,char * format,double * pwhen)299 parse_time_double_args(PyObject *args, char *format, double *pwhen)
300 {
301     PyObject *ot = NULL;
302 
303     if (!PyArg_ParseTuple(args, format, &ot))
304         return 0;
305     if (ot == NULL || ot == Py_None)
306         *pwhen = floattime();
307     else {
308         double when = PyFloat_AsDouble(ot);
309         if (PyErr_Occurred())
310             return 0;
311         *pwhen = when;
312     }
313     return 1;
314 }
315 
316 static PyObject *
time_gmtime(PyObject * self,PyObject * args)317 time_gmtime(PyObject *self, PyObject *args)
318 {
319     double when;
320     if (!parse_time_double_args(args, "|O:gmtime", &when))
321         return NULL;
322     return time_convert(when, gmtime);
323 }
324 
325 PyDoc_STRVAR(gmtime_doc,
326 "gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,\n\
327                        tm_sec, tm_wday, tm_yday, tm_isdst)\n\
328 \n\
329 Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.\n\
330 GMT).  When 'seconds' is not passed in, convert the current time instead.");
331 
332 static PyObject *
time_localtime(PyObject * self,PyObject * args)333 time_localtime(PyObject *self, PyObject *args)
334 {
335     double when;
336     if (!parse_time_double_args(args, "|O:localtime", &when))
337         return NULL;
338     return time_convert(when, localtime);
339 }
340 
341 PyDoc_STRVAR(localtime_doc,
342 "localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,\n\
343                           tm_sec,tm_wday,tm_yday,tm_isdst)\n\
344 \n\
345 Convert seconds since the Epoch to a time tuple expressing local time.\n\
346 When 'seconds' is not passed in, convert the current time instead.");
347 
348 static int
gettmarg(PyObject * args,struct tm * p)349 gettmarg(PyObject *args, struct tm *p)
350 {
351     int y;
352     memset((void *) p, '\0', sizeof(struct tm));
353 
354     if (!PyArg_Parse(args, "(iiiiiiiii)",
355                      &y,
356                      &p->tm_mon,
357                      &p->tm_mday,
358                      &p->tm_hour,
359                      &p->tm_min,
360                      &p->tm_sec,
361                      &p->tm_wday,
362                      &p->tm_yday,
363                      &p->tm_isdst))
364         return 0;
365     if (y < 1900) {
366         PyObject *accept = PyDict_GetItemString(moddict,
367                                                 "accept2dyear");
368         if (accept == NULL || !PyInt_Check(accept) ||
369             PyInt_AsLong(accept) == 0) {
370             PyErr_SetString(PyExc_ValueError,
371                             "year >= 1900 required");
372             return 0;
373         }
374         if (69 <= y && y <= 99)
375             y += 1900;
376         else if (0 <= y && y <= 68)
377             y += 2000;
378         else {
379             PyErr_SetString(PyExc_ValueError,
380                             "year out of range");
381             return 0;
382         }
383     }
384     p->tm_year = y - 1900;
385     p->tm_mon--;
386     p->tm_wday = (p->tm_wday + 1) % 7;
387     p->tm_yday--;
388     return 1;
389 }
390 
391 #ifdef HAVE_STRFTIME
392 static PyObject *
time_strftime(PyObject * self,PyObject * args)393 time_strftime(PyObject *self, PyObject *args)
394 {
395     PyObject *tup = NULL;
396     struct tm buf;
397     const char *fmt;
398     size_t fmtlen, buflen;
399     char *outbuf = 0;
400     size_t i;
401 
402     memset((void *) &buf, '\0', sizeof(buf));
403 
404     if (!PyArg_ParseTuple(args, "s|O:strftime", &fmt, &tup))
405         return NULL;
406 
407     if (tup == NULL) {
408         time_t tt = time(NULL);
409         buf = *localtime(&tt);
410     } else if (!gettmarg(tup, &buf))
411         return NULL;
412 
413     /* Checks added to make sure strftime() does not crash Python by
414        indexing blindly into some array for a textual representation
415        by some bad index (fixes bug #897625).
416 
417         Also support values of zero from Python code for arguments in which
418         that is out of range by forcing that value to the lowest value that
419         is valid (fixed bug #1520914).
420 
421         Valid ranges based on what is allowed in struct tm:
422 
423         - tm_year: [0, max(int)] (1)
424         - tm_mon: [0, 11] (2)
425         - tm_mday: [1, 31]
426         - tm_hour: [0, 23]
427         - tm_min: [0, 59]
428         - tm_sec: [0, 60]
429         - tm_wday: [0, 6] (1)
430         - tm_yday: [0, 365] (2)
431         - tm_isdst: [-max(int), max(int)]
432 
433         (1) gettmarg() handles bounds-checking.
434         (2) Python's acceptable range is one greater than the range in C,
435         thus need to check against automatic decrement by gettmarg().
436     */
437     if (buf.tm_mon == -1)
438         buf.tm_mon = 0;
439     else if (buf.tm_mon < 0 || buf.tm_mon > 11) {
440         PyErr_SetString(PyExc_ValueError, "month out of range");
441             return NULL;
442     }
443     if (buf.tm_mday == 0)
444         buf.tm_mday = 1;
445     else if (buf.tm_mday < 0 || buf.tm_mday > 31) {
446         PyErr_SetString(PyExc_ValueError, "day of month out of range");
447             return NULL;
448     }
449     if (buf.tm_hour < 0 || buf.tm_hour > 23) {
450         PyErr_SetString(PyExc_ValueError, "hour out of range");
451         return NULL;
452     }
453     if (buf.tm_min < 0 || buf.tm_min > 59) {
454         PyErr_SetString(PyExc_ValueError, "minute out of range");
455         return NULL;
456     }
457     if (buf.tm_sec < 0 || buf.tm_sec > 61) {
458         PyErr_SetString(PyExc_ValueError, "seconds out of range");
459         return NULL;
460     }
461     /* tm_wday does not need checking of its upper-bound since taking
462     ``% 7`` in gettmarg() automatically restricts the range. */
463     if (buf.tm_wday < 0) {
464         PyErr_SetString(PyExc_ValueError, "day of week out of range");
465         return NULL;
466     }
467     if (buf.tm_yday == -1)
468         buf.tm_yday = 0;
469     else if (buf.tm_yday < 0 || buf.tm_yday > 365) {
470         PyErr_SetString(PyExc_ValueError, "day of year out of range");
471         return NULL;
472     }
473     /* Normalize tm_isdst just in case someone foolishly implements %Z
474        based on the assumption that tm_isdst falls within the range of
475        [-1, 1] */
476     if (buf.tm_isdst < -1)
477         buf.tm_isdst = -1;
478     else if (buf.tm_isdst > 1)
479         buf.tm_isdst = 1;
480 
481 #ifdef MS_WINDOWS
482     /* check that the format string contains only valid directives */
483     for(outbuf = strchr(fmt, '%');
484         outbuf != NULL;
485         outbuf = strchr(outbuf+2, '%'))
486     {
487         if (outbuf[1]=='#')
488             ++outbuf; /* not documented by python, */
489         if (outbuf[1]=='\0' ||
490             !strchr("aAbBcdHIjmMpSUwWxXyYzZ%", outbuf[1]))
491         {
492             PyErr_SetString(PyExc_ValueError, "Invalid format string");
493             return 0;
494         }
495     }
496 #endif
497 
498     fmtlen = strlen(fmt);
499 
500     /* I hate these functions that presume you know how big the output
501      * will be ahead of time...
502      */
503     for (i = 1024; ; i += i) {
504         outbuf = (char *)malloc(i);
505         if (outbuf == NULL) {
506             return PyErr_NoMemory();
507         }
508         buflen = strftime(outbuf, i, fmt, &buf);
509         if (buflen > 0 || i >= 256 * fmtlen) {
510             /* If the buffer is 256 times as long as the format,
511                it's probably not failing for lack of room!
512                More likely, the format yields an empty result,
513                e.g. an empty format, or %Z when the timezone
514                is unknown. */
515             PyObject *ret;
516             ret = PyString_FromStringAndSize(outbuf, buflen);
517             free(outbuf);
518             return ret;
519         }
520         free(outbuf);
521 #if defined _MSC_VER && _MSC_VER >= 1400 && defined(__STDC_SECURE_LIB__)
522         /* VisualStudio .NET 2005 does this properly */
523         if (buflen == 0 && errno == EINVAL) {
524             PyErr_SetString(PyExc_ValueError, "Invalid format string");
525             return 0;
526         }
527 #endif
528 
529     }
530 }
531 
532 PyDoc_STRVAR(strftime_doc,
533 "strftime(format[, tuple]) -> string\n\
534 \n\
535 Convert a time tuple to a string according to a format specification.\n\
536 See the library reference manual for formatting codes. When the time tuple\n\
537 is not present, current time as returned by localtime() is used.");
538 #endif /* HAVE_STRFTIME */
539 
540 static PyObject *
time_strptime(PyObject * self,PyObject * args)541 time_strptime(PyObject *self, PyObject *args)
542 {
543     PyObject *strptime_module = PyImport_ImportModuleNoBlock("_strptime");
544     PyObject *strptime_result;
545 
546     if (!strptime_module)
547         return NULL;
548     strptime_result = PyObject_CallMethod(strptime_module,
549                                             "_strptime_time", "O", args);
550     Py_DECREF(strptime_module);
551     return strptime_result;
552 }
553 
554 PyDoc_STRVAR(strptime_doc,
555 "strptime(string, format) -> struct_time\n\
556 \n\
557 Parse a string to a time tuple according to a format specification.\n\
558 See the library reference manual for formatting codes (same as strftime()).");
559 
560 
561 static PyObject *
time_asctime(PyObject * self,PyObject * args)562 time_asctime(PyObject *self, PyObject *args)
563 {
564     PyObject *tup = NULL;
565     struct tm buf;
566     char *p;
567     if (!PyArg_UnpackTuple(args, "asctime", 0, 1, &tup))
568         return NULL;
569     if (tup == NULL) {
570         time_t tt = time(NULL);
571         buf = *localtime(&tt);
572     } else if (!gettmarg(tup, &buf))
573         return NULL;
574     p = asctime(&buf);
575     if (p == NULL) {
576         PyErr_SetString(PyExc_ValueError, "invalid time");
577         return NULL;
578     }
579     if (p[24] == '\n')
580         p[24] = '\0';
581     return PyString_FromString(p);
582 }
583 
584 PyDoc_STRVAR(asctime_doc,
585 "asctime([tuple]) -> string\n\
586 \n\
587 Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.\n\
588 When the time tuple is not present, current time as returned by localtime()\n\
589 is used.");
590 
591 static PyObject *
time_ctime(PyObject * self,PyObject * args)592 time_ctime(PyObject *self, PyObject *args)
593 {
594     PyObject *ot = NULL;
595     time_t tt;
596     char *p;
597 
598     if (!PyArg_UnpackTuple(args, "ctime", 0, 1, &ot))
599         return NULL;
600     if (ot == NULL || ot == Py_None)
601         tt = time(NULL);
602     else {
603         double dt = PyFloat_AsDouble(ot);
604         if (PyErr_Occurred())
605             return NULL;
606         tt = _PyTime_DoubleToTimet(dt);
607         if (tt == (time_t)-1 && PyErr_Occurred())
608             return NULL;
609     }
610     p = ctime(&tt);
611     if (p == NULL) {
612         PyErr_SetString(PyExc_ValueError, "unconvertible time");
613         return NULL;
614     }
615     if (p[24] == '\n')
616         p[24] = '\0';
617     return PyString_FromString(p);
618 }
619 
620 PyDoc_STRVAR(ctime_doc,
621 "ctime(seconds) -> string\n\
622 \n\
623 Convert a time in seconds since the Epoch to a string in local time.\n\
624 This is equivalent to asctime(localtime(seconds)). When the time tuple is\n\
625 not present, current time as returned by localtime() is used.");
626 
627 #ifdef HAVE_MKTIME
628 static PyObject *
time_mktime(PyObject * self,PyObject * tup)629 time_mktime(PyObject *self, PyObject *tup)
630 {
631     struct tm buf;
632     time_t tt;
633     if (!gettmarg(tup, &buf))
634         return NULL;
635     buf.tm_wday = -1;  /* sentinel; original value ignored */
636     tt = mktime(&buf);
637     /* Return value of -1 does not necessarily mean an error, but tm_wday
638      * cannot remain set to -1 if mktime succeeded. */
639     if (tt == (time_t)(-1) && buf.tm_wday == -1) {
640         PyErr_SetString(PyExc_OverflowError,
641                         "mktime argument out of range");
642         return NULL;
643     }
644     return PyFloat_FromDouble((double)tt);
645 }
646 
647 PyDoc_STRVAR(mktime_doc,
648 "mktime(tuple) -> floating point number\n\
649 \n\
650 Convert a time tuple in local time to seconds since the Epoch.");
651 #endif /* HAVE_MKTIME */
652 
653 #ifdef HAVE_WORKING_TZSET
654 static void inittimezone(PyObject *module);
655 
656 static PyObject *
time_tzset(PyObject * self,PyObject * unused)657 time_tzset(PyObject *self, PyObject *unused)
658 {
659     PyObject* m;
660 
661     m = PyImport_ImportModuleNoBlock("time");
662     if (m == NULL) {
663         return NULL;
664     }
665 
666     tzset();
667 
668     /* Reset timezone, altzone, daylight and tzname */
669     inittimezone(m);
670     Py_DECREF(m);
671 
672     Py_INCREF(Py_None);
673     return Py_None;
674 }
675 
676 PyDoc_STRVAR(tzset_doc,
677 "tzset()\n\
678 \n\
679 Initialize, or reinitialize, the local timezone to the value stored in\n\
680 os.environ['TZ']. The TZ environment variable should be specified in\n\
681 standard Unix timezone format as documented in the tzset man page\n\
682 (eg. 'US/Eastern', 'Europe/Amsterdam'). Unknown timezones will silently\n\
683 fall back to UTC. If the TZ environment variable is not set, the local\n\
684 timezone is set to the systems best guess of wallclock time.\n\
685 Changing the TZ environment variable without calling tzset *may* change\n\
686 the local timezone used by methods such as localtime, but this behaviour\n\
687 should not be relied on.");
688 #endif /* HAVE_WORKING_TZSET */
689 
690 static void
inittimezone(PyObject * m)691 inittimezone(PyObject *m) {
692     /* This code moved from inittime wholesale to allow calling it from
693     time_tzset. In the future, some parts of it can be moved back
694     (for platforms that don't HAVE_WORKING_TZSET, when we know what they
695     are), and the extraneous calls to tzset(3) should be removed.
696     I haven't done this yet, as I don't want to change this code as
697     little as possible when introducing the time.tzset and time.tzsetwall
698     methods. This should simply be a method of doing the following once,
699     at the top of this function and removing the call to tzset() from
700     time_tzset():
701 
702         #ifdef HAVE_TZSET
703         tzset()
704         #endif
705 
706     And I'm lazy and hate C so nyer.
707      */
708 #if defined(HAVE_TZNAME) && !defined(__GLIBC__) && !defined(__CYGWIN__)
709     tzset();
710 #ifdef PYOS_OS2
711     PyModule_AddIntConstant(m, "timezone", _timezone);
712 #else /* !PYOS_OS2 */
713     PyModule_AddIntConstant(m, "timezone", timezone);
714 #endif /* PYOS_OS2 */
715 #ifdef HAVE_ALTZONE
716     PyModule_AddIntConstant(m, "altzone", altzone);
717 #else
718 #ifdef PYOS_OS2
719     PyModule_AddIntConstant(m, "altzone", _timezone-3600);
720 #else /* !PYOS_OS2 */
721     PyModule_AddIntConstant(m, "altzone", timezone-3600);
722 #endif /* PYOS_OS2 */
723 #endif
724     PyModule_AddIntConstant(m, "daylight", daylight);
725     PyModule_AddObject(m, "tzname",
726                        Py_BuildValue("(zz)", tzname[0], tzname[1]));
727 #else /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
728 #ifdef HAVE_STRUCT_TM_TM_ZONE
729     {
730 #define YEAR ((time_t)((365 * 24 + 6) * 3600))
731         time_t t;
732         struct tm *p;
733         long janzone, julyzone;
734         char janname[10], julyname[10];
735         t = (time((time_t *)0) / YEAR) * YEAR;
736         p = localtime(&t);
737         janzone = -p->tm_gmtoff;
738         strncpy(janname, p->tm_zone ? p->tm_zone : "   ", 9);
739         janname[9] = '\0';
740         t += YEAR/2;
741         p = localtime(&t);
742         julyzone = -p->tm_gmtoff;
743         strncpy(julyname, p->tm_zone ? p->tm_zone : "   ", 9);
744         julyname[9] = '\0';
745 
746         if( janzone < julyzone ) {
747             /* DST is reversed in the southern hemisphere */
748             PyModule_AddIntConstant(m, "timezone", julyzone);
749             PyModule_AddIntConstant(m, "altzone", janzone);
750             PyModule_AddIntConstant(m, "daylight",
751                                     janzone != julyzone);
752             PyModule_AddObject(m, "tzname",
753                                Py_BuildValue("(zz)",
754                                              julyname, janname));
755         } else {
756             PyModule_AddIntConstant(m, "timezone", janzone);
757             PyModule_AddIntConstant(m, "altzone", julyzone);
758             PyModule_AddIntConstant(m, "daylight",
759                                     janzone != julyzone);
760             PyModule_AddObject(m, "tzname",
761                                Py_BuildValue("(zz)",
762                                              janname, julyname));
763         }
764     }
765 #else
766 #endif /* HAVE_STRUCT_TM_TM_ZONE */
767 #ifdef __CYGWIN__
768     tzset();
769     PyModule_AddIntConstant(m, "timezone", _timezone);
770     PyModule_AddIntConstant(m, "altzone", _timezone-3600);
771     PyModule_AddIntConstant(m, "daylight", _daylight);
772     PyModule_AddObject(m, "tzname",
773                        Py_BuildValue("(zz)", _tzname[0], _tzname[1]));
774 #endif /* __CYGWIN__ */
775 #endif /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
776 }
777 
778 
779 static PyMethodDef time_methods[] = {
780     {"time",            time_time, METH_NOARGS, time_doc},
781 #ifdef HAVE_CLOCK
782     {"clock",           time_clock, METH_NOARGS, clock_doc},
783 #endif
784     {"sleep",           time_sleep, METH_VARARGS, sleep_doc},
785     {"gmtime",          time_gmtime, METH_VARARGS, gmtime_doc},
786     {"localtime",       time_localtime, METH_VARARGS, localtime_doc},
787     {"asctime",         time_asctime, METH_VARARGS, asctime_doc},
788     {"ctime",           time_ctime, METH_VARARGS, ctime_doc},
789 #ifdef HAVE_MKTIME
790     {"mktime",          time_mktime, METH_O, mktime_doc},
791 #endif
792 #ifdef HAVE_STRFTIME
793     {"strftime",        time_strftime, METH_VARARGS, strftime_doc},
794 #endif
795     {"strptime",        time_strptime, METH_VARARGS, strptime_doc},
796 #ifdef HAVE_WORKING_TZSET
797     {"tzset",           time_tzset, METH_NOARGS, tzset_doc},
798 #endif
799     {NULL,              NULL}           /* sentinel */
800 };
801 
802 
803 PyDoc_STRVAR(module_doc,
804 "This module provides various functions to manipulate time values.\n\
805 \n\
806 There are two standard representations of time.  One is the number\n\
807 of seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an integer\n\
808 or a floating point number (to represent fractions of seconds).\n\
809 The Epoch is system-defined; on Unix, it is generally January 1st, 1970.\n\
810 The actual value can be retrieved by calling gmtime(0).\n\
811 \n\
812 The other representation is a tuple of 9 integers giving local time.\n\
813 The tuple items are:\n\
814   year (four digits, e.g. 1998)\n\
815   month (1-12)\n\
816   day (1-31)\n\
817   hours (0-23)\n\
818   minutes (0-59)\n\
819   seconds (0-59)\n\
820   weekday (0-6, Monday is 0)\n\
821   Julian day (day in the year, 1-366)\n\
822   DST (Daylight Savings Time) flag (-1, 0 or 1)\n\
823 If the DST flag is 0, the time is given in the regular time zone;\n\
824 if it is 1, the time is given in the DST time zone;\n\
825 if it is -1, mktime() should guess based on the date and time.\n\
826 \n\
827 Variables:\n\
828 \n\
829 timezone -- difference in seconds between UTC and local standard time\n\
830 altzone -- difference in  seconds between UTC and local DST time\n\
831 daylight -- whether local time should reflect DST\n\
832 tzname -- tuple of (standard time zone name, DST time zone name)\n\
833 \n\
834 Functions:\n\
835 \n\
836 time() -- return current time in seconds since the Epoch as a float\n\
837 clock() -- return CPU time since process start as a float\n\
838 sleep() -- delay for a number of seconds given as a float\n\
839 gmtime() -- convert seconds since Epoch to UTC tuple\n\
840 localtime() -- convert seconds since Epoch to local time tuple\n\
841 asctime() -- convert time tuple to string\n\
842 ctime() -- convert time in seconds to string\n\
843 mktime() -- convert local time tuple to seconds since Epoch\n\
844 strftime() -- convert time tuple to string according to format specification\n\
845 strptime() -- parse string to time tuple according to format specification\n\
846 tzset() -- change the local timezone");
847 
848 
849 PyMODINIT_FUNC
inittime(void)850 inittime(void)
851 {
852     PyObject *m;
853     char *p;
854     m = Py_InitModule3("time", time_methods, module_doc);
855     if (m == NULL)
856         return;
857 
858     /* Accept 2-digit dates unless PYTHONY2K is set and non-empty */
859     p = Py_GETENV("PYTHONY2K");
860     PyModule_AddIntConstant(m, "accept2dyear", (long) (!p || !*p));
861     /* If an embedded interpreter is shutdown and reinitialized the old
862        moddict was not decrefed on shutdown and the next import of this
863        module leads to a leak.  Conditionally decref here to prevent that.
864     */
865     Py_XDECREF(moddict);
866     /* Squirrel away the module's dictionary for the y2k check */
867     moddict = PyModule_GetDict(m);
868     Py_INCREF(moddict);
869 
870     /* Set, or reset, module variables like time.timezone */
871     inittimezone(m);
872 
873 #ifdef MS_WINDOWS
874     /* Helper to allow interrupts for Windows.
875        If Ctrl+C event delivered while not sleeping
876        it will be ignored.
877     */
878     main_thread = PyThread_get_thread_ident();
879     hInterruptEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
880     SetConsoleCtrlHandler( PyCtrlHandler, TRUE);
881 #endif /* MS_WINDOWS */
882     if (!initialized) {
883         PyStructSequence_InitType(&StructTimeType,
884                                   &struct_time_type_desc);
885     }
886     Py_INCREF(&StructTimeType);
887     PyModule_AddObject(m, "struct_time", (PyObject*) &StructTimeType);
888     initialized = 1;
889 }
890 
891 
892 /* Implement floattime() for various platforms */
893 
894 static double
floattime(void)895 floattime(void)
896 {
897     /* There are three ways to get the time:
898       (1) gettimeofday() -- resolution in microseconds
899       (2) ftime() -- resolution in milliseconds
900       (3) time() -- resolution in seconds
901       In all cases the return value is a float in seconds.
902       Since on some systems (e.g. SCO ODT 3.0) gettimeofday() may
903       fail, so we fall back on ftime() or time().
904       Note: clock resolution does not imply clock accuracy! */
905 #ifdef HAVE_GETTIMEOFDAY
906     {
907         struct timeval t;
908 #ifdef GETTIMEOFDAY_NO_TZ
909         if (gettimeofday(&t) == 0)
910             return (double)t.tv_sec + t.tv_usec*0.000001;
911 #else /* !GETTIMEOFDAY_NO_TZ */
912         if (gettimeofday(&t, (struct timezone *)NULL) == 0)
913             return (double)t.tv_sec + t.tv_usec*0.000001;
914 #endif /* !GETTIMEOFDAY_NO_TZ */
915     }
916 
917 #endif /* !HAVE_GETTIMEOFDAY */
918     {
919 #if defined(HAVE_FTIME)
920         struct timeb t;
921         ftime(&t);
922         return (double)t.time + (double)t.millitm * (double)0.001;
923 #else /* !HAVE_FTIME */
924         time_t secs;
925         time(&secs);
926         return (double)secs;
927 #endif /* !HAVE_FTIME */
928     }
929 }
930 
931 
932 /* Implement floatsleep() for various platforms.
933    When interrupted (or when another error occurs), return -1 and
934    set an exception; else return 0. */
935 
936 static int
floatsleep(double secs)937 floatsleep(double secs)
938 {
939 /* XXX Should test for MS_WINDOWS first! */
940 #if defined(HAVE_SELECT) && !defined(__BEOS__) && !defined(__EMX__)
941     struct timeval t;
942     double frac;
943     frac = fmod(secs, 1.0);
944     secs = floor(secs);
945     t.tv_sec = (long)secs;
946     t.tv_usec = (long)(frac*1000000.0);
947     Py_BEGIN_ALLOW_THREADS
948     if (select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &t) != 0) {
949 #ifdef EINTR
950         if (errno != EINTR) {
951 #else
952         if (1) {
953 #endif
954             Py_BLOCK_THREADS
955             PyErr_SetFromErrno(PyExc_IOError);
956             return -1;
957         }
958     }
959     Py_END_ALLOW_THREADS
960 #elif defined(__WATCOMC__) && !defined(__QNX__)
961     /* XXX Can't interrupt this sleep */
962     Py_BEGIN_ALLOW_THREADS
963     delay((int)(secs * 1000 + 0.5));  /* delay() uses milliseconds */
964     Py_END_ALLOW_THREADS
965 #elif defined(MS_WINDOWS)
966     {
967         double millisecs = secs * 1000.0;
968         unsigned long ul_millis;
969 
970         if (millisecs > (double)ULONG_MAX) {
971             PyErr_SetString(PyExc_OverflowError,
972                             "sleep length is too large");
973             return -1;
974         }
975         Py_BEGIN_ALLOW_THREADS
976         /* Allow sleep(0) to maintain win32 semantics, and as decreed
977          * by Guido, only the main thread can be interrupted.
978          */
979         ul_millis = (unsigned long)millisecs;
980         if (ul_millis == 0 ||
981             main_thread != PyThread_get_thread_ident())
982             Sleep(ul_millis);
983         else {
984             DWORD rc;
985             ResetEvent(hInterruptEvent);
986             rc = WaitForSingleObject(hInterruptEvent, ul_millis);
987             if (rc == WAIT_OBJECT_0) {
988                 /* Yield to make sure real Python signal
989                  * handler called.
990                  */
991                 Sleep(1);
992                 Py_BLOCK_THREADS
993                 errno = EINTR;
994                 PyErr_SetFromErrno(PyExc_IOError);
995                 return -1;
996             }
997         }
998         Py_END_ALLOW_THREADS
999     }
1000 #elif defined(PYOS_OS2)
1001     /* This Sleep *IS* Interruptable by Exceptions */
1002     Py_BEGIN_ALLOW_THREADS
1003     if (DosSleep(secs * 1000) != NO_ERROR) {
1004         Py_BLOCK_THREADS
1005         PyErr_SetFromErrno(PyExc_IOError);
1006         return -1;
1007     }
1008     Py_END_ALLOW_THREADS
1009 #elif defined(__BEOS__)
1010     /* This sleep *CAN BE* interrupted. */
1011     {
1012         if( secs <= 0.0 ) {
1013             return;
1014         }
1015 
1016         Py_BEGIN_ALLOW_THREADS
1017         /* BeOS snooze() is in microseconds... */
1018         if( snooze( (bigtime_t)( secs * 1000.0 * 1000.0 ) ) == B_INTERRUPTED ) {
1019             Py_BLOCK_THREADS
1020             PyErr_SetFromErrno( PyExc_IOError );
1021             return -1;
1022         }
1023         Py_END_ALLOW_THREADS
1024     }
1025 #elif defined(RISCOS)
1026     if (secs <= 0.0)
1027         return 0;
1028     Py_BEGIN_ALLOW_THREADS
1029     /* This sleep *CAN BE* interrupted. */
1030     if ( riscos_sleep(secs) )
1031         return -1;
1032     Py_END_ALLOW_THREADS
1033 #elif defined(PLAN9)
1034     {
1035         double millisecs = secs * 1000.0;
1036         if (millisecs > (double)LONG_MAX) {
1037             PyErr_SetString(PyExc_OverflowError, "sleep length is too large");
1038             return -1;
1039         }
1040         /* This sleep *CAN BE* interrupted. */
1041         Py_BEGIN_ALLOW_THREADS
1042         if(sleep((long)millisecs) < 0){
1043             Py_BLOCK_THREADS
1044             PyErr_SetFromErrno(PyExc_IOError);
1045             return -1;
1046         }
1047         Py_END_ALLOW_THREADS
1048     }
1049 #else
1050     /* XXX Can't interrupt this sleep */
1051     Py_BEGIN_ALLOW_THREADS
1052     sleep((int)secs);
1053     Py_END_ALLOW_THREADS
1054 #endif
1055 
1056     return 0;
1057 }
1058 
1059 /* export floattime to socketmodule.c */
1060 PyAPI_FUNC(double)
1061 _PyTime_FloatTime(void)
1062 {
1063     return floattime();
1064 }
1065