|
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; |
|
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; |
|
100 |
|
101 /* Exposed in timefuncs.h. */ |
|
102 time_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 |
|
127 static PyObject * |
|
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 * |
|
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 * |
|
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 * |
|
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", 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 |
|
231 static PyStructSequence_Desc struct_time_type_desc = { |
|
232 "time.struct_time", |
|
233 NULL, |
|
234 struct_time_type_fields, |
|
235 9, |
|
236 }; |
|
237 |
|
238 static int initialized; |
|
239 static PyTypeObject StructTimeType; |
|
240 |
|
241 static PyObject * |
|
242 tmtotuple(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 |
|
268 static PyObject * |
|
269 time_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 */ |
|
292 static int |
|
293 parse_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 |
|
310 static PyObject * |
|
311 time_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 |
|
319 PyDoc_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\ |
|
323 Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.\n\ |
|
324 GMT). When 'seconds' is not passed in, convert the current time instead."); |
|
325 |
|
326 static PyObject * |
|
327 time_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 |
|
335 PyDoc_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\ |
|
339 Convert seconds since the Epoch to a time tuple expressing local time.\n\ |
|
340 When 'seconds' is not passed in, convert the current time instead."); |
|
341 |
|
342 static int |
|
343 gettmarg(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 |
|
386 static PyObject * |
|
387 time_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 |
|
507 PyDoc_STRVAR(strftime_doc, |
|
508 "strftime(format[, tuple]) -> string\n\ |
|
509 \n\ |
|
510 Convert a time tuple to a string according to a format specification.\n\ |
|
511 See the library reference manual for formatting codes. When the time tuple\n\ |
|
512 is not present, current time as returned by localtime() is used."); |
|
513 #endif /* HAVE_STRFTIME */ |
|
514 |
|
515 static PyObject * |
|
516 time_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 |
|
528 PyDoc_STRVAR(strptime_doc, |
|
529 "strptime(string, format) -> struct_time\n\ |
|
530 \n\ |
|
531 Parse a string to a time tuple according to a format specification.\n\ |
|
532 See the library reference manual for formatting codes (same as strftime())."); |
|
533 |
|
534 |
|
535 static PyObject * |
|
536 time_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 |
|
554 PyDoc_STRVAR(asctime_doc, |
|
555 "asctime([tuple]) -> string\n\ |
|
556 \n\ |
|
557 Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.\n\ |
|
558 When the time tuple is not present, current time as returned by localtime()\n\ |
|
559 is used."); |
|
560 |
|
561 static PyObject * |
|
562 time_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 |
|
590 PyDoc_STRVAR(ctime_doc, |
|
591 "ctime(seconds) -> string\n\ |
|
592 \n\ |
|
593 Convert a time in seconds since the Epoch to a string in local time.\n\ |
|
594 This is equivalent to asctime(localtime(seconds)). When the time tuple is\n\ |
|
595 not present, current time as returned by localtime() is used."); |
|
596 |
|
597 #ifdef HAVE_MKTIME |
|
598 static PyObject * |
|
599 time_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 |
|
614 PyDoc_STRVAR(mktime_doc, |
|
615 "mktime(tuple) -> floating point number\n\ |
|
616 \n\ |
|
617 Convert a time tuple in local time to seconds since the Epoch."); |
|
618 #endif /* HAVE_MKTIME */ |
|
619 |
|
620 #ifdef HAVE_WORKING_TZSET |
|
621 static void inittimezone(PyObject *module); |
|
622 |
|
623 static PyObject * |
|
624 time_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 |
|
643 PyDoc_STRVAR(tzset_doc, |
|
644 "tzset(zone)\n\ |
|
645 \n\ |
|
646 Initialize, or reinitialize, the local timezone to the value stored in\n\ |
|
647 os.environ['TZ']. The TZ environment variable should be specified in\n\ |
|
648 standard Unix timezone format as documented in the tzset man page\n\ |
|
649 (eg. 'US/Eastern', 'Europe/Amsterdam'). Unknown timezones will silently\n\ |
|
650 fall back to UTC. If the TZ environment variable is not set, the local\n\ |
|
651 timezone is set to the systems best guess of wallclock time.\n\ |
|
652 Changing the TZ environment variable without calling tzset *may* change\n\ |
|
653 the local timezone used by methods such as localtime, but this behaviour\n\ |
|
654 should not be relied on."); |
|
655 #endif /* HAVE_WORKING_TZSET */ |
|
656 |
|
657 static void |
|
658 inittimezone(PyObject *m) { |
|
659 /* This code moved from inittime wholesale to allow calling it from |
|
660 time_tzset. In the future, some parts of it can be moved back |
|
661 (for platforms that don't HAVE_WORKING_TZSET, when we know what they |
|
662 are), and the 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 |
|
746 static 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 |
|
770 PyDoc_STRVAR(module_doc, |
|
771 "This module provides various functions to manipulate time values.\n\ |
|
772 \n\ |
|
773 There are two standard representations of time. One is the number\n\ |
|
774 of seconds since the Epoch, in UTC (a.k.a. GMT). It may be an integer\n\ |
|
775 or a floating point number (to represent fractions of seconds).\n\ |
|
776 The Epoch is system-defined; on Unix, it is generally January 1st, 1970.\n\ |
|
777 The actual value can be retrieved by calling gmtime(0).\n\ |
|
778 \n\ |
|
779 The other representation is a tuple of 9 integers giving local time.\n\ |
|
780 The 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\ |
|
790 If the DST flag is 0, the time is given in the regular time zone;\n\ |
|
791 if it is 1, the time is given in the DST time zone;\n\ |
|
792 if it is -1, mktime() should guess based on the date and time.\n\ |
|
793 \n\ |
|
794 Variables:\n\ |
|
795 \n\ |
|
796 timezone -- difference in seconds between UTC and local standard time\n\ |
|
797 altzone -- difference in seconds between UTC and local DST time\n\ |
|
798 daylight -- whether local time should reflect DST\n\ |
|
799 tzname -- tuple of (standard time zone name, DST time zone name)\n\ |
|
800 \n\ |
|
801 Functions:\n\ |
|
802 \n\ |
|
803 time() -- return current time in seconds since the Epoch as a float\n\ |
|
804 clock() -- return CPU time since process start as a float\n\ |
|
805 sleep() -- delay for a number of seconds given as a float\n\ |
|
806 gmtime() -- convert seconds since Epoch to UTC tuple\n\ |
|
807 localtime() -- convert seconds since Epoch to local time tuple\n\ |
|
808 asctime() -- convert time tuple to string\n\ |
|
809 ctime() -- convert time in seconds to string\n\ |
|
810 mktime() -- convert local time tuple to seconds since Epoch\n\ |
|
811 strftime() -- convert time tuple to string according to format specification\n\ |
|
812 strptime() -- parse string to time tuple according to format specification\n\ |
|
813 tzset() -- change the local timezone"); |
|
814 |
|
815 |
|
816 PyMODINIT_FUNC |
|
817 inittime(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 |
|
856 static double |
|
857 floattime(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 |
|
898 static int |
|
899 floatsleep(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 |