9 #if defined(HAVE_GETTIMEOFDAY) && defined(HAVE_FTIME)
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.
22 #ifdef HAVE_SYS_TYPES_H
23 #include <sys/types.h>
24 #endif /* HAVE_SYS_TYPES_H */
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 */
37 #if defined(__WATCOMC__) && !defined(__QNX__)
41 #define WIN32_LEAN_AND_MEAN
45 /* helper to allow us to interrupt sleep() on Windows*/
46 static HANDLE hInterruptEvent
= NULL
;
47 static BOOL WINAPI
PyCtrlHandler(DWORD dwCtrlType
)
49 SetEvent(hInterruptEvent
);
50 /* allow other default handlers to be called.
51 Default Python handler will setup the
52 KeyboardInterrupt exception.
56 static long main_thread
;
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__ */
68 #if defined(MS_WINDOWS) && !defined(__BORLANDC__)
69 /* Win32 has better clock replacement; we have our own version below. */
71 #endif /* MS_WINDOWS && !defined(__BORLANDC__) */
79 #if defined(PYCC_VACPP)
85 /* For bigtime_t, snooze(). - [cjh] */
86 #include <support/SupportDefs.h>
87 #include <kernel/OS.h>
91 extern int riscos_sleep(double);
94 /* Forward declarations */
95 static int floatsleep(double);
96 static double floattime(void);
99 static PyObject
*moddict
;
101 /* Exposed in timefuncs.h. */
103 _PyTime_DoubleToTimet(double 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
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");
128 time_time(PyObject
*self
, PyObject
*unused
)
133 PyErr_SetFromErrno(PyExc_IOError
);
136 return PyFloat_FromDouble(secs
);
139 PyDoc_STRVAR(time_doc
,
140 "time() -> floating point number\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.");
147 #ifndef CLOCKS_PER_SEC
149 #define CLOCKS_PER_SEC CLK_TCK
151 #define CLOCKS_PER_SEC 1000000
156 time_clock(PyObject
*self
, PyObject
*unused
)
158 return PyFloat_FromDouble(((double)clock()) / CLOCKS_PER_SEC
);
160 #endif /* HAVE_CLOCK */
162 #if defined(MS_WINDOWS) && !defined(__BORLANDC__)
163 /* Due to Mark Hammond and Tim Peters */
165 time_clock(PyObject
*self
, PyObject
*unused
)
167 static LARGE_INTEGER ctrStart
;
168 static double divisor
= 0.0;
172 if (divisor
== 0.0) {
174 QueryPerformanceCounter(&ctrStart
);
175 if (!QueryPerformanceFrequency(&freq
) || freq
.QuadPart
== 0) {
176 /* Unlikely to happen - this works on all intel
177 machines at least! Revert to clock() */
178 return PyFloat_FromDouble(clock());
180 divisor
= (double)freq
.QuadPart
;
182 QueryPerformanceCounter(&now
);
183 diff
= (double)(now
.QuadPart
- ctrStart
.QuadPart
);
184 return PyFloat_FromDouble(diff
/ divisor
);
187 #define HAVE_CLOCK /* So it gets included in the methods */
188 #endif /* MS_WINDOWS && !defined(__BORLANDC__) */
191 PyDoc_STRVAR(clock_doc
,
192 "clock() -> floating point number\n\
194 Return the CPU time or real time since the start of the process or since\n\
195 the first call to clock(). This has as much precision as the system\n\
200 time_sleep(PyObject
*self
, PyObject
*args
)
203 if (!PyArg_ParseTuple(args
, "d:sleep", &secs
))
205 if (floatsleep(secs
) != 0)
211 PyDoc_STRVAR(sleep_doc
,
214 Delay execution for a given number of seconds. The argument may be\n\
215 a floating point number for subsecond precision.");
217 static PyStructSequence_Field struct_time_type_fields
[] = {
230 static PyStructSequence_Desc struct_time_type_desc
= {
233 struct_time_type_fields
,
237 static int initialized
;
238 static PyTypeObject StructTimeType
;
241 tmtotuple(struct tm
*p
)
243 PyObject
*v
= PyStructSequence_New(&StructTimeType
);
247 #define SET(i,val) PyStructSequence_SET_ITEM(v, i, PyInt_FromLong((long) val))
249 SET(0, p
->tm_year
+ 1900);
250 SET(1, p
->tm_mon
+ 1); /* Want January == 1 */
255 SET(6, (p
->tm_wday
+ 6) % 7); /* Want Monday == 0 */
256 SET(7, p
->tm_yday
+ 1); /* Want January, 1 == 1 */
259 if (PyErr_Occurred()) {
268 time_convert(double when
, struct tm
* (*function
)(const time_t *))
271 time_t whent
= _PyTime_DoubleToTimet(when
);
273 if (whent
== (time_t)-1 && PyErr_Occurred())
276 p
= function(&whent
);
282 return PyErr_SetFromErrno(PyExc_ValueError
);
287 /* Parse arg tuple that can contain an optional float-or-None value;
288 format needs to be "|O:name".
289 Returns non-zero on success (parallels PyArg_ParseTuple).
292 parse_time_double_args(PyObject
*args
, char *format
, double *pwhen
)
296 if (!PyArg_ParseTuple(args
, format
, &ot
))
298 if (ot
== NULL
|| ot
== Py_None
)
299 *pwhen
= floattime();
301 double when
= PyFloat_AsDouble(ot
);
302 if (PyErr_Occurred())
310 time_gmtime(PyObject
*self
, PyObject
*args
)
313 if (!parse_time_double_args(args
, "|O:gmtime", &when
))
315 return time_convert(when
, gmtime
);
318 PyDoc_STRVAR(gmtime_doc
,
319 "gmtime([seconds]) -> (tm_year, tm_mon, tm_day, tm_hour, tm_min,\n\
320 tm_sec, tm_wday, tm_yday, tm_isdst)\n\
322 Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.\n\
323 GMT). When 'seconds' is not passed in, convert the current time instead.");
326 time_localtime(PyObject
*self
, PyObject
*args
)
329 if (!parse_time_double_args(args
, "|O:localtime", &when
))
331 return time_convert(when
, localtime
);
334 PyDoc_STRVAR(localtime_doc
,
335 "localtime([seconds]) -> (tm_year,tm_mon,tm_day,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)\n\
337 Convert seconds since the Epoch to a time tuple expressing local time.\n\
338 When 'seconds' is not passed in, convert the current time instead.");
341 gettmarg(PyObject
*args
, struct tm
*p
)
344 memset((void *) p
, '\0', sizeof(struct tm
));
346 if (!PyArg_Parse(args
, "(iiiiiiiii)",
358 PyObject
*accept
= PyDict_GetItemString(moddict
,
360 if (accept
== NULL
|| !PyInt_Check(accept
) ||
361 PyInt_AsLong(accept
) == 0) {
362 PyErr_SetString(PyExc_ValueError
,
363 "year >= 1900 required");
366 if (69 <= y
&& y
<= 99)
368 else if (0 <= y
&& y
<= 68)
371 PyErr_SetString(PyExc_ValueError
,
372 "year out of range");
376 p
->tm_year
= y
- 1900;
378 p
->tm_wday
= (p
->tm_wday
+ 1) % 7;
385 time_strftime(PyObject
*self
, PyObject
*args
)
387 PyObject
*tup
= NULL
;
390 size_t fmtlen
, buflen
;
394 memset((void *) &buf
, '\0', sizeof(buf
));
396 if (!PyArg_ParseTuple(args
, "s|O:strftime", &fmt
, &tup
))
400 time_t tt
= time(NULL
);
401 buf
= *localtime(&tt
);
402 } else if (!gettmarg(tup
, &buf
))
405 /* Checks added to make sure strftime() does not crash Python by
406 indexing blindly into some array for a textual representation
407 by some bad index (fixes bug #897625).
409 Also support values of zero from Python code for arguments in which
410 that is out of range by forcing that value to the lowest value that
411 is valid (fixed bug #1520914).
413 Valid ranges based on what is allowed in struct tm:
415 - tm_year: [0, max(int)] (1)
416 - tm_mon: [0, 11] (2)
421 - tm_wday: [0, 6] (1)
422 - tm_yday: [0, 365] (2)
423 - tm_isdst: [-max(int), max(int)]
425 (1) gettmarg() handles bounds-checking.
426 (2) Python's acceptable range is one greater than the range in C,
427 thus need to check against automatic decrement by gettmarg().
429 if (buf
.tm_mon
== -1)
431 else if (buf
.tm_mon
< 0 || buf
.tm_mon
> 11) {
432 PyErr_SetString(PyExc_ValueError
, "month out of range");
435 if (buf
.tm_mday
== 0)
437 else if (buf
.tm_mday
< 0 || buf
.tm_mday
> 31) {
438 PyErr_SetString(PyExc_ValueError
, "day of month out of range");
441 if (buf
.tm_hour
< 0 || buf
.tm_hour
> 23) {
442 PyErr_SetString(PyExc_ValueError
, "hour out of range");
445 if (buf
.tm_min
< 0 || buf
.tm_min
> 59) {
446 PyErr_SetString(PyExc_ValueError
, "minute out of range");
449 if (buf
.tm_sec
< 0 || buf
.tm_sec
> 61) {
450 PyErr_SetString(PyExc_ValueError
, "seconds out of range");
453 /* tm_wday does not need checking of its upper-bound since taking
454 ``% 7`` in gettmarg() automatically restricts the range. */
455 if (buf
.tm_wday
< 0) {
456 PyErr_SetString(PyExc_ValueError
, "day of week out of range");
459 if (buf
.tm_yday
== -1)
461 else if (buf
.tm_yday
< 0 || buf
.tm_yday
> 365) {
462 PyErr_SetString(PyExc_ValueError
, "day of year out of range");
465 if (buf
.tm_isdst
< -1 || buf
.tm_isdst
> 1) {
466 PyErr_SetString(PyExc_ValueError
,
467 "daylight savings flag out of range");
471 fmtlen
= strlen(fmt
);
473 /* I hate these functions that presume you know how big the output
474 * will be ahead of time...
476 for (i
= 1024; ; i
+= i
) {
477 outbuf
= (char *)malloc(i
);
478 if (outbuf
== NULL
) {
479 return PyErr_NoMemory();
481 buflen
= strftime(outbuf
, i
, fmt
, &buf
);
482 if (buflen
> 0 || i
>= 256 * fmtlen
) {
483 /* If the buffer is 256 times as long as the format,
484 it's probably not failing for lack of room!
485 More likely, the format yields an empty result,
486 e.g. an empty format, or %Z when the timezone
489 ret
= PyString_FromStringAndSize(outbuf
, buflen
);
494 #if defined _MSC_VER && _MSC_VER >= 1400 && defined(__STDC_SECURE_LIB__)
495 /* VisualStudio .NET 2005 does this properly */
496 if (buflen
== 0 && errno
== EINVAL
) {
497 PyErr_SetString(PyExc_ValueError
, "Invalid format string");
505 PyDoc_STRVAR(strftime_doc
,
506 "strftime(format[, tuple]) -> string\n\
508 Convert a time tuple to a string according to a format specification.\n\
509 See the library reference manual for formatting codes. When the time tuple\n\
510 is not present, current time as returned by localtime() is used.");
511 #endif /* HAVE_STRFTIME */
514 time_strptime(PyObject
*self
, PyObject
*args
)
516 PyObject
*strptime_module
= PyImport_ImportModule("_strptime");
517 PyObject
*strptime_result
;
519 if (!strptime_module
)
521 strptime_result
= PyObject_CallMethod(strptime_module
, "strptime", "O", args
);
522 Py_DECREF(strptime_module
);
523 return strptime_result
;
526 PyDoc_STRVAR(strptime_doc
,
527 "strptime(string, format) -> struct_time\n\
529 Parse a string to a time tuple according to a format specification.\n\
530 See the library reference manual for formatting codes (same as strftime()).");
534 time_asctime(PyObject
*self
, PyObject
*args
)
536 PyObject
*tup
= NULL
;
539 if (!PyArg_UnpackTuple(args
, "asctime", 0, 1, &tup
))
542 time_t tt
= time(NULL
);
543 buf
= *localtime(&tt
);
544 } else if (!gettmarg(tup
, &buf
))
549 return PyString_FromString(p
);
552 PyDoc_STRVAR(asctime_doc
,
553 "asctime([tuple]) -> string\n\
555 Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.\n\
556 When the time tuple is not present, current time as returned by localtime()\n\
560 time_ctime(PyObject
*self
, PyObject
*args
)
566 if (!PyArg_UnpackTuple(args
, "ctime", 0, 1, &ot
))
568 if (ot
== NULL
|| ot
== Py_None
)
571 double dt
= PyFloat_AsDouble(ot
);
572 if (PyErr_Occurred())
574 tt
= _PyTime_DoubleToTimet(dt
);
575 if (tt
== (time_t)-1 && PyErr_Occurred())
580 PyErr_SetString(PyExc_ValueError
, "unconvertible time");
585 return PyString_FromString(p
);
588 PyDoc_STRVAR(ctime_doc
,
589 "ctime(seconds) -> string\n\
591 Convert a time in seconds since the Epoch to a string in local time.\n\
592 This is equivalent to asctime(localtime(seconds)). When the time tuple is\n\
593 not present, current time as returned by localtime() is used.");
597 time_mktime(PyObject
*self
, PyObject
*tup
)
602 buf
= *localtime(&tt
);
603 if (!gettmarg(tup
, &buf
))
606 if (tt
== (time_t)(-1)) {
607 PyErr_SetString(PyExc_OverflowError
,
608 "mktime argument out of range");
611 return PyFloat_FromDouble((double)tt
);
614 PyDoc_STRVAR(mktime_doc
,
615 "mktime(tuple) -> floating point number\n\
617 Convert a time tuple in local time to seconds since the Epoch.");
618 #endif /* HAVE_MKTIME */
620 #ifdef HAVE_WORKING_TZSET
621 void inittimezone(PyObject
*module
);
624 time_tzset(PyObject
*self
, PyObject
*unused
)
628 m
= PyImport_ImportModule("time");
635 /* Reset timezone, altzone, daylight and tzname */
643 PyDoc_STRVAR(tzset_doc
,
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 */
657 void inittimezone(PyObject
*m
) {
658 /* This code moved from inittime wholesale to allow calling it from
659 time_tzset. In the future, some parts of it can be moved back
660 (for platforms that don't HAVE_WORKING_TZSET, when we know what they
661 are), and the extranious calls to tzset(3) should be removed.
662 I havn't done this yet, as I don't want to change this code as
663 little as possible when introducing the time.tzset and time.tzsetwall
664 methods. This should simply be a method of doing the following once,
665 at the top of this function and removing the call to tzset() from
672 And I'm lazy and hate C so nyer.
674 #if defined(HAVE_TZNAME) && !defined(__GLIBC__) && !defined(__CYGWIN__)
677 PyModule_AddIntConstant(m
, "timezone", _timezone
);
678 #else /* !PYOS_OS2 */
679 PyModule_AddIntConstant(m
, "timezone", timezone
);
680 #endif /* PYOS_OS2 */
682 PyModule_AddIntConstant(m
, "altzone", altzone
);
685 PyModule_AddIntConstant(m
, "altzone", _timezone
-3600);
686 #else /* !PYOS_OS2 */
687 PyModule_AddIntConstant(m
, "altzone", timezone
-3600);
688 #endif /* PYOS_OS2 */
690 PyModule_AddIntConstant(m
, "daylight", daylight
);
691 PyModule_AddObject(m
, "tzname",
692 Py_BuildValue("(zz)", tzname
[0], tzname
[1]));
693 #else /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
694 #ifdef HAVE_STRUCT_TM_TM_ZONE
696 #define YEAR ((time_t)((365 * 24 + 6) * 3600))
699 long janzone
, julyzone
;
700 char janname
[10], julyname
[10];
701 t
= (time((time_t *)0) / YEAR
) * YEAR
;
703 janzone
= -p
->tm_gmtoff
;
704 strncpy(janname
, p
->tm_zone
? p
->tm_zone
: " ", 9);
708 julyzone
= -p
->tm_gmtoff
;
709 strncpy(julyname
, p
->tm_zone
? p
->tm_zone
: " ", 9);
712 if( janzone
< julyzone
) {
713 /* DST is reversed in the southern hemisphere */
714 PyModule_AddIntConstant(m
, "timezone", julyzone
);
715 PyModule_AddIntConstant(m
, "altzone", janzone
);
716 PyModule_AddIntConstant(m
, "daylight",
717 janzone
!= julyzone
);
718 PyModule_AddObject(m
, "tzname",
719 Py_BuildValue("(zz)",
722 PyModule_AddIntConstant(m
, "timezone", janzone
);
723 PyModule_AddIntConstant(m
, "altzone", julyzone
);
724 PyModule_AddIntConstant(m
, "daylight",
725 janzone
!= julyzone
);
726 PyModule_AddObject(m
, "tzname",
727 Py_BuildValue("(zz)",
732 #endif /* HAVE_STRUCT_TM_TM_ZONE */
735 PyModule_AddIntConstant(m
, "timezone", _timezone
);
736 PyModule_AddIntConstant(m
, "altzone", _timezone
-3600);
737 PyModule_AddIntConstant(m
, "daylight", _daylight
);
738 PyModule_AddObject(m
, "tzname",
739 Py_BuildValue("(zz)", _tzname
[0], _tzname
[1]));
740 #endif /* __CYGWIN__ */
741 #endif /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
745 static PyMethodDef time_methods
[] = {
746 {"time", time_time
, METH_NOARGS
, time_doc
},
748 {"clock", time_clock
, METH_NOARGS
, clock_doc
},
750 {"sleep", time_sleep
, METH_VARARGS
, sleep_doc
},
751 {"gmtime", time_gmtime
, METH_VARARGS
, gmtime_doc
},
752 {"localtime", time_localtime
, METH_VARARGS
, localtime_doc
},
753 {"asctime", time_asctime
, METH_VARARGS
, asctime_doc
},
754 {"ctime", time_ctime
, METH_VARARGS
, ctime_doc
},
756 {"mktime", time_mktime
, METH_O
, mktime_doc
},
759 {"strftime", time_strftime
, METH_VARARGS
, strftime_doc
},
761 {"strptime", time_strptime
, METH_VARARGS
, strptime_doc
},
762 #ifdef HAVE_WORKING_TZSET
763 {"tzset", time_tzset
, METH_NOARGS
, tzset_doc
},
765 {NULL
, NULL
} /* sentinel */
769 PyDoc_STRVAR(module_doc
,
770 "This module provides various functions to manipulate time values.\n\
772 There are two standard representations of time. One is the number\n\
773 of seconds since the Epoch, in UTC (a.k.a. GMT). It may be an integer\n\
774 or a floating point number (to represent fractions of seconds).\n\
775 The Epoch is system-defined; on Unix, it is generally January 1st, 1970.\n\
776 The actual value can be retrieved by calling gmtime(0).\n\
778 The other representation is a tuple of 9 integers giving local time.\n\
779 The tuple items are:\n\
780 year (four digits, e.g. 1998)\n\
786 weekday (0-6, Monday is 0)\n\
787 Julian day (day in the year, 1-366)\n\
788 DST (Daylight Savings Time) flag (-1, 0 or 1)\n\
789 If the DST flag is 0, the time is given in the regular time zone;\n\
790 if it is 1, the time is given in the DST time zone;\n\
791 if it is -1, mktime() should guess based on the date and time.\n\
795 timezone -- difference in seconds between UTC and local standard time\n\
796 altzone -- difference in seconds between UTC and local DST time\n\
797 daylight -- whether local time should reflect DST\n\
798 tzname -- tuple of (standard time zone name, DST time zone name)\n\
802 time() -- return current time in seconds since the Epoch as a float\n\
803 clock() -- return CPU time since process start as a float\n\
804 sleep() -- delay for a number of seconds given as a float\n\
805 gmtime() -- convert seconds since Epoch to UTC tuple\n\
806 localtime() -- convert seconds since Epoch to local time tuple\n\
807 asctime() -- convert time tuple to string\n\
808 ctime() -- convert time in seconds to string\n\
809 mktime() -- convert local time tuple to seconds since Epoch\n\
810 strftime() -- convert time tuple to string according to format specification\n\
811 strptime() -- parse string to time tuple according to format specification\n\
812 tzset() -- change the local timezone");
820 m
= Py_InitModule3("time", time_methods
, module_doc
);
824 /* Accept 2-digit dates unless PYTHONY2K is set and non-empty */
825 p
= Py_GETENV("PYTHONY2K");
826 PyModule_AddIntConstant(m
, "accept2dyear", (long) (!p
|| !*p
));
827 /* Squirrel away the module's dictionary for the y2k check */
828 moddict
= PyModule_GetDict(m
);
831 /* Set, or reset, module variables like time.timezone */
835 /* Helper to allow interrupts for Windows.
836 If Ctrl+C event delivered while not sleeping
839 main_thread
= PyThread_get_thread_ident();
840 hInterruptEvent
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
841 SetConsoleCtrlHandler( PyCtrlHandler
, TRUE
);
842 #endif /* MS_WINDOWS */
844 PyStructSequence_InitType(&StructTimeType
,
845 &struct_time_type_desc
);
847 Py_INCREF(&StructTimeType
);
848 PyModule_AddObject(m
, "struct_time", (PyObject
*) &StructTimeType
);
853 /* Implement floattime() for various platforms */
858 /* There are three ways to get the time:
859 (1) gettimeofday() -- resolution in microseconds
860 (2) ftime() -- resolution in milliseconds
861 (3) time() -- resolution in seconds
862 In all cases the return value is a float in seconds.
863 Since on some systems (e.g. SCO ODT 3.0) gettimeofday() may
864 fail, so we fall back on ftime() or time().
865 Note: clock resolution does not imply clock accuracy! */
866 #ifdef HAVE_GETTIMEOFDAY
869 #ifdef GETTIMEOFDAY_NO_TZ
870 if (gettimeofday(&t
) == 0)
871 return (double)t
.tv_sec
+ t
.tv_usec
*0.000001;
872 #else /* !GETTIMEOFDAY_NO_TZ */
873 if (gettimeofday(&t
, (struct timezone
*)NULL
) == 0)
874 return (double)t
.tv_sec
+ t
.tv_usec
*0.000001;
875 #endif /* !GETTIMEOFDAY_NO_TZ */
878 #endif /* !HAVE_GETTIMEOFDAY */
880 #if defined(HAVE_FTIME)
883 return (double)t
.time
+ (double)t
.millitm
* (double)0.001;
884 #else /* !HAVE_FTIME */
888 #endif /* !HAVE_FTIME */
893 /* Implement floatsleep() for various platforms.
894 When interrupted (or when another error occurs), return -1 and
895 set an exception; else return 0. */
898 floatsleep(double secs
)
900 /* XXX Should test for MS_WINDOWS first! */
901 #if defined(HAVE_SELECT) && !defined(__BEOS__) && !defined(__EMX__)
904 frac
= fmod(secs
, 1.0);
906 t
.tv_sec
= (long)secs
;
907 t
.tv_usec
= (long)(frac
*1000000.0);
908 Py_BEGIN_ALLOW_THREADS
909 if (select(0, (fd_set
*)0, (fd_set
*)0, (fd_set
*)0, &t
) != 0) {
911 if (errno
!= EINTR
) {
916 PyErr_SetFromErrno(PyExc_IOError
);
921 #elif defined(__WATCOMC__) && !defined(__QNX__)
922 /* XXX Can't interrupt this sleep */
923 Py_BEGIN_ALLOW_THREADS
924 delay((int)(secs
* 1000 + 0.5)); /* delay() uses milliseconds */
926 #elif defined(MS_WINDOWS)
928 double millisecs
= secs
* 1000.0;
929 unsigned long ul_millis
;
931 if (millisecs
> (double)ULONG_MAX
) {
932 PyErr_SetString(PyExc_OverflowError
,
933 "sleep length is too large");
936 Py_BEGIN_ALLOW_THREADS
937 /* Allow sleep(0) to maintain win32 semantics, and as decreed
938 * by Guido, only the main thread can be interrupted.
940 ul_millis
= (unsigned long)millisecs
;
941 if (ul_millis
== 0 ||
942 main_thread
!= PyThread_get_thread_ident())
946 ResetEvent(hInterruptEvent
);
947 rc
= WaitForSingleObject(hInterruptEvent
, ul_millis
);
948 if (rc
== WAIT_OBJECT_0
) {
949 /* Yield to make sure real Python signal
955 PyErr_SetFromErrno(PyExc_IOError
);
961 #elif defined(PYOS_OS2)
962 /* This Sleep *IS* Interruptable by Exceptions */
963 Py_BEGIN_ALLOW_THREADS
964 if (DosSleep(secs
* 1000) != NO_ERROR
) {
966 PyErr_SetFromErrno(PyExc_IOError
);
970 #elif defined(__BEOS__)
971 /* This sleep *CAN BE* interrupted. */
977 Py_BEGIN_ALLOW_THREADS
978 /* BeOS snooze() is in microseconds... */
979 if( snooze( (bigtime_t
)( secs
* 1000.0 * 1000.0 ) ) == B_INTERRUPTED
) {
981 PyErr_SetFromErrno( PyExc_IOError
);
986 #elif defined(RISCOS)
989 Py_BEGIN_ALLOW_THREADS
990 /* This sleep *CAN BE* interrupted. */
991 if ( riscos_sleep(secs
) )
996 double millisecs
= secs
* 1000.0;
997 if (millisecs
> (double)LONG_MAX
) {
998 PyErr_SetString(PyExc_OverflowError
, "sleep length is too large");
1001 /* This sleep *CAN BE* interrupted. */
1002 Py_BEGIN_ALLOW_THREADS
1003 if(sleep((long)millisecs
) < 0){
1005 PyErr_SetFromErrno(PyExc_IOError
);
1008 Py_END_ALLOW_THREADS
1011 /* XXX Can't interrupt this sleep */
1012 Py_BEGIN_ALLOW_THREADS
1014 Py_END_ALLOW_THREADS