1991-02-19 20:39:46 +08:00
|
|
|
|
1990-10-14 20:07:46 +08:00
|
|
|
/* Time module */
|
|
|
|
|
1996-12-07 07:32:14 +08:00
|
|
|
#include "Python.h"
|
SF patch #462296: Add attributes to os.stat results; by Nick Mathewson.
This is a big one, touching lots of files. Some of the platforms
aren't tested yet. Briefly, this changes the return value of the
os/posix functions stat(), fstat(), statvfs(), fstatvfs(), and the
time functions localtime(), gmtime(), and strptime() from tuples into
pseudo-sequences. When accessed as a sequence, they behave exactly as
before. But they also have attributes like st_mtime or tm_year. The
stat return value, moreover, has a few platform-specific attributes
that are not available through the sequence interface (because
everybody expects the sequence to have a fixed length, these couldn't
be added there). If your platform's struct stat doesn't define
st_blksize, st_blocks or st_rdev, they won't be accessible from Python
either.
(Still missing is a documentation update.)
2001-10-19 04:34:25 +08:00
|
|
|
#include "structseq.h"
|
1990-12-20 23:06:42 +08:00
|
|
|
|
1998-06-10 00:30:31 +08:00
|
|
|
#include <ctype.h>
|
|
|
|
|
1994-08-01 19:34:53 +08:00
|
|
|
#ifdef macintosh
|
|
|
|
#include <time.h>
|
2000-04-27 04:40:13 +08:00
|
|
|
#include <OSUtils.h>
|
1994-08-01 19:34:53 +08:00
|
|
|
#else
|
|
|
|
#include <sys/types.h>
|
1993-01-04 17:09:59 +08:00
|
|
|
#endif
|
|
|
|
|
1994-08-01 19:34:53 +08:00
|
|
|
#ifdef QUICKWIN
|
|
|
|
#include <io.h>
|
1992-08-14 21:49:30 +08:00
|
|
|
#endif
|
|
|
|
|
1994-08-01 19:34:53 +08:00
|
|
|
#ifdef HAVE_FTIME
|
|
|
|
#include <sys/timeb.h>
|
1997-11-23 05:53:48 +08:00
|
|
|
#if !defined(MS_WINDOWS) && !defined(PYOS_OS2)
|
2000-07-23 07:57:55 +08:00
|
|
|
extern int ftime(struct timeb *);
|
1996-12-10 02:38:52 +08:00
|
|
|
#endif /* MS_WINDOWS */
|
|
|
|
#endif /* HAVE_FTIME */
|
1994-08-01 19:34:53 +08:00
|
|
|
|
1997-12-03 04:34:19 +08:00
|
|
|
#if defined(__WATCOMC__) && !defined(__QNX__)
|
1996-05-24 06:53:47 +08:00
|
|
|
#include <i86.h>
|
|
|
|
#else
|
1996-09-06 21:34:02 +08:00
|
|
|
#ifdef MS_WINDOWS
|
2002-07-16 09:29:19 +08:00
|
|
|
#define WIN32_LEAN_AND_MEAN
|
2001-03-02 14:53:29 +08:00
|
|
|
#include <windows.h>
|
2002-07-16 09:29:19 +08:00
|
|
|
#include "pythread.h"
|
|
|
|
|
|
|
|
/* helper to allow us to interrupt sleep() on Windows*/
|
|
|
|
static HANDLE hInterruptEvent = NULL;
|
|
|
|
static BOOL WINAPI PyCtrlHandler(DWORD dwCtrlType)
|
|
|
|
{
|
|
|
|
SetEvent(hInterruptEvent);
|
|
|
|
/* allow other default handlers to be called.
|
|
|
|
Default Python handler will setup the
|
|
|
|
KeyboardInterrupt exception.
|
|
|
|
*/
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
static long main_thread;
|
|
|
|
|
|
|
|
|
2002-06-30 23:26:10 +08:00
|
|
|
#if defined(__BORLANDC__)
|
1996-09-07 08:47:35 +08:00
|
|
|
/* These overrides not needed for Win32 */
|
1994-08-01 19:34:53 +08:00
|
|
|
#define timezone _timezone
|
1995-03-14 23:05:41 +08:00
|
|
|
#define tzname _tzname
|
1996-09-06 21:34:02 +08:00
|
|
|
#define daylight _daylight
|
2002-06-30 23:26:10 +08:00
|
|
|
#endif /* __BORLANDC__ */
|
1996-09-06 21:34:02 +08:00
|
|
|
#endif /* MS_WINDOWS */
|
1997-12-03 04:34:19 +08:00
|
|
|
#endif /* !__WATCOMC__ || __QNX__ */
|
1993-06-17 20:35:49 +08:00
|
|
|
|
2002-06-30 23:26:10 +08:00
|
|
|
#if defined(MS_WINDOWS) && !defined(MS_WIN64) && !defined(__BORLANDC__)
|
2000-06-30 04:56:28 +08:00
|
|
|
/* Win32 has better clock replacement
|
|
|
|
XXX Win64 does not yet, but might when the platform matures. */
|
1997-04-02 13:35:28 +08:00
|
|
|
#undef HAVE_CLOCK /* We have our own version down below */
|
2002-06-30 23:26:10 +08:00
|
|
|
#endif /* MS_WINDOWS && !MS_WIN64 */
|
1997-04-02 13:35:28 +08:00
|
|
|
|
2002-03-03 10:59:16 +08:00
|
|
|
#if defined(PYOS_OS2)
|
|
|
|
#define INCL_DOS
|
|
|
|
#define INCL_ERRORS
|
|
|
|
#include <os2.h>
|
|
|
|
#endif
|
|
|
|
|
1997-11-23 05:53:48 +08:00
|
|
|
#if defined(PYCC_VACPP)
|
1998-09-29 06:07:11 +08:00
|
|
|
#include <sys/time.h>
|
1997-11-23 05:53:48 +08:00
|
|
|
#endif
|
|
|
|
|
1998-08-05 06:53:56 +08:00
|
|
|
#ifdef __BEOS__
|
2000-08-16 02:52:33 +08:00
|
|
|
#include <time.h>
|
1998-08-05 06:53:56 +08:00
|
|
|
/* For bigtime_t, snooze(). - [cjh] */
|
|
|
|
#include <support/SupportDefs.h>
|
|
|
|
#include <kernel/OS.h>
|
|
|
|
#endif
|
|
|
|
|
1993-06-17 20:35:49 +08:00
|
|
|
/* Forward declarations */
|
2000-07-09 11:09:57 +08:00
|
|
|
static int floatsleep(double);
|
2000-07-24 23:26:39 +08:00
|
|
|
static double floattime(void);
|
1990-10-14 20:07:46 +08:00
|
|
|
|
1998-08-25 22:51:12 +08:00
|
|
|
/* For Y2K check */
|
|
|
|
static PyObject *moddict;
|
|
|
|
|
1997-10-08 23:27:56 +08:00
|
|
|
#ifdef macintosh
|
|
|
|
/* Our own timezone. We have enough information to deduce whether
|
|
|
|
** DST is on currently, but unfortunately we cannot put it to good
|
|
|
|
** use because we don't know the rules (and that is needed to have
|
|
|
|
** localtime() return correct tm_isdst values for times other than
|
|
|
|
** the current time. So, we cop out and only tell the user the current
|
|
|
|
** timezone.
|
|
|
|
*/
|
|
|
|
static long timezone;
|
|
|
|
|
2001-09-25 21:59:01 +08:00
|
|
|
static void
|
2000-07-21 14:00:07 +08:00
|
|
|
initmactimezone(void)
|
1997-10-08 23:27:56 +08:00
|
|
|
{
|
|
|
|
MachineLocation loc;
|
|
|
|
long delta;
|
|
|
|
|
|
|
|
ReadLocation(&loc);
|
2001-09-25 21:59:01 +08:00
|
|
|
|
1997-10-08 23:27:56 +08:00
|
|
|
if (loc.latitude == 0 && loc.longitude == 0 && loc.u.gmtDelta == 0)
|
|
|
|
return;
|
2001-09-25 21:59:01 +08:00
|
|
|
|
1997-10-08 23:27:56 +08:00
|
|
|
delta = loc.u.gmtDelta & 0x00FFFFFF;
|
2001-09-25 21:59:01 +08:00
|
|
|
|
1997-10-08 23:27:56 +08:00
|
|
|
if (delta & 0x00800000)
|
|
|
|
delta |= 0xFF000000;
|
2001-09-25 21:59:01 +08:00
|
|
|
|
1997-10-08 23:27:56 +08:00
|
|
|
timezone = -delta;
|
|
|
|
}
|
|
|
|
#endif /* macintosh */
|
|
|
|
|
|
|
|
|
1996-12-07 07:32:14 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
time_time(PyObject *self, PyObject *args)
|
1990-10-14 20:07:46 +08:00
|
|
|
{
|
1994-08-01 19:34:53 +08:00
|
|
|
double secs;
|
2001-01-20 07:16:56 +08:00
|
|
|
if (!PyArg_ParseTuple(args, ":time"))
|
1993-01-04 17:09:59 +08:00
|
|
|
return NULL;
|
1994-08-01 19:34:53 +08:00
|
|
|
secs = floattime();
|
|
|
|
if (secs == 0.0) {
|
1996-12-07 07:32:14 +08:00
|
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
1993-01-04 17:09:59 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
1996-12-07 07:32:14 +08:00
|
|
|
return PyFloat_FromDouble(secs);
|
1990-10-14 20:07:46 +08:00
|
|
|
}
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
PyDoc_STRVAR(time_doc,
|
1998-06-28 04:38:36 +08:00
|
|
|
"time() -> floating point number\n\
|
|
|
|
\n\
|
|
|
|
Return the current time in seconds since the Epoch.\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
Fractions of a second may be present if the system clock provides them.");
|
1998-06-28 04:38:36 +08:00
|
|
|
|
1994-08-01 19:34:53 +08:00
|
|
|
#ifdef HAVE_CLOCK
|
1990-10-14 20:07:46 +08:00
|
|
|
|
1994-08-01 19:34:53 +08:00
|
|
|
#ifndef CLOCKS_PER_SEC
|
1996-02-25 12:50:33 +08:00
|
|
|
#ifdef CLK_TCK
|
|
|
|
#define CLOCKS_PER_SEC CLK_TCK
|
|
|
|
#else
|
1994-08-01 19:34:53 +08:00
|
|
|
#define CLOCKS_PER_SEC 1000000
|
|
|
|
#endif
|
1996-02-25 12:50:33 +08:00
|
|
|
#endif
|
1990-10-14 20:07:46 +08:00
|
|
|
|
1996-12-07 07:32:14 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
time_clock(PyObject *self, PyObject *args)
|
1990-10-14 20:07:46 +08:00
|
|
|
{
|
2001-01-20 07:16:56 +08:00
|
|
|
if (!PyArg_ParseTuple(args, ":clock"))
|
1990-10-14 20:07:46 +08:00
|
|
|
return NULL;
|
1996-12-07 07:32:14 +08:00
|
|
|
return PyFloat_FromDouble(((double)clock()) / CLOCKS_PER_SEC);
|
1990-10-14 20:07:46 +08:00
|
|
|
}
|
1994-08-01 19:34:53 +08:00
|
|
|
#endif /* HAVE_CLOCK */
|
1990-10-14 20:07:46 +08:00
|
|
|
|
2002-06-30 23:26:10 +08:00
|
|
|
#if defined(MS_WINDOWS) && !defined(MS_WIN64) && !defined(__BORLANDC__)
|
2002-02-12 12:02:33 +08:00
|
|
|
/* Due to Mark Hammond and Tim Peters */
|
1997-04-02 13:35:28 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
time_clock(PyObject *self, PyObject *args)
|
1997-04-02 13:35:28 +08:00
|
|
|
{
|
2002-02-13 13:14:18 +08:00
|
|
|
static LARGE_INTEGER ctrStart;
|
2002-02-12 12:02:33 +08:00
|
|
|
static double divisor = 0.0;
|
2002-02-13 13:14:18 +08:00
|
|
|
LARGE_INTEGER now;
|
2002-02-12 12:02:33 +08:00
|
|
|
double diff;
|
1997-04-02 13:35:28 +08:00
|
|
|
|
2001-01-20 07:16:56 +08:00
|
|
|
if (!PyArg_ParseTuple(args, ":clock"))
|
1997-04-02 13:35:28 +08:00
|
|
|
return NULL;
|
|
|
|
|
2002-02-12 12:02:33 +08:00
|
|
|
if (divisor == 0.0) {
|
2002-02-13 13:14:18 +08:00
|
|
|
LARGE_INTEGER freq;
|
|
|
|
QueryPerformanceCounter(&ctrStart);
|
|
|
|
if (!QueryPerformanceFrequency(&freq) || freq.QuadPart == 0) {
|
2002-02-12 12:02:33 +08:00
|
|
|
/* Unlikely to happen - this works on all intel
|
|
|
|
machines at least! Revert to clock() */
|
1997-04-02 13:35:28 +08:00
|
|
|
return PyFloat_FromDouble(clock());
|
|
|
|
}
|
2002-02-13 13:14:18 +08:00
|
|
|
divisor = (double)freq.QuadPart;
|
1997-04-02 13:35:28 +08:00
|
|
|
}
|
2002-02-13 13:14:18 +08:00
|
|
|
QueryPerformanceCounter(&now);
|
|
|
|
diff = (double)(now.QuadPart - ctrStart.QuadPart);
|
2002-02-12 12:02:33 +08:00
|
|
|
return PyFloat_FromDouble(diff / divisor);
|
1997-04-02 13:35:28 +08:00
|
|
|
}
|
1998-06-28 04:38:36 +08:00
|
|
|
|
1997-04-02 13:35:28 +08:00
|
|
|
#define HAVE_CLOCK /* So it gets included in the methods */
|
2002-06-30 23:26:10 +08:00
|
|
|
#endif /* MS_WINDOWS && !MS_WIN64 */
|
1997-04-02 13:35:28 +08:00
|
|
|
|
1998-06-28 04:38:36 +08:00
|
|
|
#ifdef HAVE_CLOCK
|
2002-06-14 04:33:02 +08:00
|
|
|
PyDoc_STRVAR(clock_doc,
|
1998-06-28 04:38:36 +08:00
|
|
|
"clock() -> floating point number\n\
|
|
|
|
\n\
|
|
|
|
Return the CPU time or real time since the start of the process or since\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
the first call to clock(). This has as much precision as the system\n\
|
|
|
|
records.");
|
1998-06-28 04:38:36 +08:00
|
|
|
#endif
|
|
|
|
|
1996-12-07 07:32:14 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
time_sleep(PyObject *self, PyObject *args)
|
1990-10-14 20:07:46 +08:00
|
|
|
{
|
1994-08-01 19:34:53 +08:00
|
|
|
double secs;
|
2001-01-20 07:16:56 +08:00
|
|
|
if (!PyArg_ParseTuple(args, "d:sleep", &secs))
|
1990-10-14 20:07:46 +08:00
|
|
|
return NULL;
|
1997-11-04 06:04:46 +08:00
|
|
|
if (floatsleep(secs) != 0)
|
|
|
|
return NULL;
|
|
|
|
Py_INCREF(Py_None);
|
1996-12-07 07:32:14 +08:00
|
|
|
return Py_None;
|
1990-10-14 20:07:46 +08:00
|
|
|
}
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
PyDoc_STRVAR(sleep_doc,
|
1998-06-28 04:38:36 +08:00
|
|
|
"sleep(seconds)\n\
|
|
|
|
\n\
|
|
|
|
Delay execution for a given number of seconds. The argument may be\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
a floating point number for subsecond precision.");
|
1998-06-28 04:38:36 +08:00
|
|
|
|
SF patch #462296: Add attributes to os.stat results; by Nick Mathewson.
This is a big one, touching lots of files. Some of the platforms
aren't tested yet. Briefly, this changes the return value of the
os/posix functions stat(), fstat(), statvfs(), fstatvfs(), and the
time functions localtime(), gmtime(), and strptime() from tuples into
pseudo-sequences. When accessed as a sequence, they behave exactly as
before. But they also have attributes like st_mtime or tm_year. The
stat return value, moreover, has a few platform-specific attributes
that are not available through the sequence interface (because
everybody expects the sequence to have a fixed length, these couldn't
be added there). If your platform's struct stat doesn't define
st_blksize, st_blocks or st_rdev, they won't be accessible from Python
either.
(Still missing is a documentation update.)
2001-10-19 04:34:25 +08:00
|
|
|
static PyStructSequence_Field struct_time_type_fields[] = {
|
|
|
|
{"tm_year", NULL},
|
|
|
|
{"tm_mon", NULL},
|
|
|
|
{"tm_mday", NULL},
|
|
|
|
{"tm_hour", NULL},
|
|
|
|
{"tm_min", NULL},
|
|
|
|
{"tm_sec", NULL},
|
|
|
|
{"tm_wday", NULL},
|
|
|
|
{"tm_yday", NULL},
|
|
|
|
{"tm_isdst", NULL},
|
|
|
|
{0}
|
|
|
|
};
|
|
|
|
|
|
|
|
static PyStructSequence_Desc struct_time_type_desc = {
|
2001-12-09 02:02:58 +08:00
|
|
|
"time.struct_time",
|
SF patch #462296: Add attributes to os.stat results; by Nick Mathewson.
This is a big one, touching lots of files. Some of the platforms
aren't tested yet. Briefly, this changes the return value of the
os/posix functions stat(), fstat(), statvfs(), fstatvfs(), and the
time functions localtime(), gmtime(), and strptime() from tuples into
pseudo-sequences. When accessed as a sequence, they behave exactly as
before. But they also have attributes like st_mtime or tm_year. The
stat return value, moreover, has a few platform-specific attributes
that are not available through the sequence interface (because
everybody expects the sequence to have a fixed length, these couldn't
be added there). If your platform's struct stat doesn't define
st_blksize, st_blocks or st_rdev, they won't be accessible from Python
either.
(Still missing is a documentation update.)
2001-10-19 04:34:25 +08:00
|
|
|
NULL,
|
|
|
|
struct_time_type_fields,
|
|
|
|
9,
|
|
|
|
};
|
2002-02-13 13:14:18 +08:00
|
|
|
|
SF patch #462296: Add attributes to os.stat results; by Nick Mathewson.
This is a big one, touching lots of files. Some of the platforms
aren't tested yet. Briefly, this changes the return value of the
os/posix functions stat(), fstat(), statvfs(), fstatvfs(), and the
time functions localtime(), gmtime(), and strptime() from tuples into
pseudo-sequences. When accessed as a sequence, they behave exactly as
before. But they also have attributes like st_mtime or tm_year. The
stat return value, moreover, has a few platform-specific attributes
that are not available through the sequence interface (because
everybody expects the sequence to have a fixed length, these couldn't
be added there). If your platform's struct stat doesn't define
st_blksize, st_blocks or st_rdev, they won't be accessible from Python
either.
(Still missing is a documentation update.)
2001-10-19 04:34:25 +08:00
|
|
|
static PyTypeObject StructTimeType;
|
|
|
|
|
1998-06-10 00:30:31 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
tmtotuple(struct tm *p)
|
1998-06-10 00:30:31 +08:00
|
|
|
{
|
SF patch #462296: Add attributes to os.stat results; by Nick Mathewson.
This is a big one, touching lots of files. Some of the platforms
aren't tested yet. Briefly, this changes the return value of the
os/posix functions stat(), fstat(), statvfs(), fstatvfs(), and the
time functions localtime(), gmtime(), and strptime() from tuples into
pseudo-sequences. When accessed as a sequence, they behave exactly as
before. But they also have attributes like st_mtime or tm_year. The
stat return value, moreover, has a few platform-specific attributes
that are not available through the sequence interface (because
everybody expects the sequence to have a fixed length, these couldn't
be added there). If your platform's struct stat doesn't define
st_blksize, st_blocks or st_rdev, they won't be accessible from Python
either.
(Still missing is a documentation update.)
2001-10-19 04:34:25 +08:00
|
|
|
PyObject *v = PyStructSequence_New(&StructTimeType);
|
|
|
|
if (v == NULL)
|
|
|
|
return NULL;
|
2002-02-13 13:14:18 +08:00
|
|
|
|
SF patch #462296: Add attributes to os.stat results; by Nick Mathewson.
This is a big one, touching lots of files. Some of the platforms
aren't tested yet. Briefly, this changes the return value of the
os/posix functions stat(), fstat(), statvfs(), fstatvfs(), and the
time functions localtime(), gmtime(), and strptime() from tuples into
pseudo-sequences. When accessed as a sequence, they behave exactly as
before. But they also have attributes like st_mtime or tm_year. The
stat return value, moreover, has a few platform-specific attributes
that are not available through the sequence interface (because
everybody expects the sequence to have a fixed length, these couldn't
be added there). If your platform's struct stat doesn't define
st_blksize, st_blocks or st_rdev, they won't be accessible from Python
either.
(Still missing is a documentation update.)
2001-10-19 04:34:25 +08:00
|
|
|
#define SET(i,val) PyStructSequence_SET_ITEM(v, i, PyInt_FromLong((long) val))
|
|
|
|
|
|
|
|
SET(0, p->tm_year + 1900);
|
|
|
|
SET(1, p->tm_mon + 1); /* Want January == 1 */
|
|
|
|
SET(2, p->tm_mday);
|
|
|
|
SET(3, p->tm_hour);
|
|
|
|
SET(4, p->tm_min);
|
|
|
|
SET(5, p->tm_sec);
|
|
|
|
SET(6, (p->tm_wday + 6) % 7); /* Want Monday == 0 */
|
|
|
|
SET(7, p->tm_yday + 1); /* Want January, 1 == 1 */
|
|
|
|
SET(8, p->tm_isdst);
|
|
|
|
#undef SET
|
|
|
|
if (PyErr_Occurred()) {
|
|
|
|
Py_XDECREF(v);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return v;
|
1998-06-10 00:30:31 +08:00
|
|
|
}
|
|
|
|
|
1996-12-07 07:32:14 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
time_convert(time_t when, struct tm * (*function)(const time_t *))
|
1993-06-17 20:35:49 +08:00
|
|
|
{
|
1996-10-08 22:19:52 +08:00
|
|
|
struct tm *p;
|
|
|
|
errno = 0;
|
|
|
|
p = function(&when);
|
|
|
|
if (p == NULL) {
|
|
|
|
#ifdef EINVAL
|
1996-11-03 01:31:22 +08:00
|
|
|
if (errno == 0)
|
1996-10-08 22:19:52 +08:00
|
|
|
errno = EINVAL;
|
|
|
|
#endif
|
1996-12-07 07:32:14 +08:00
|
|
|
return PyErr_SetFromErrno(PyExc_IOError);
|
1996-10-08 22:19:52 +08:00
|
|
|
}
|
1998-06-10 00:30:31 +08:00
|
|
|
return tmtotuple(p);
|
1993-06-17 20:35:49 +08:00
|
|
|
}
|
|
|
|
|
1996-12-07 07:32:14 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
time_gmtime(PyObject *self, PyObject *args)
|
1993-06-17 20:35:49 +08:00
|
|
|
{
|
|
|
|
double when;
|
2001-01-20 07:16:56 +08:00
|
|
|
if (PyTuple_Size(args) == 0)
|
|
|
|
when = floattime();
|
|
|
|
if (!PyArg_ParseTuple(args, "|d:gmtime", &when))
|
1993-06-17 20:35:49 +08:00
|
|
|
return NULL;
|
|
|
|
return time_convert((time_t)when, gmtime);
|
|
|
|
}
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
PyDoc_STRVAR(gmtime_doc,
|
2002-03-13 05:38:49 +08:00
|
|
|
"gmtime([seconds]) -> (tm_year, tm_mon, tm_day, tm_hour, tm_min,\n\
|
|
|
|
tm_sec, tm_wday, tm_yday, tm_isdst)\n\
|
1998-06-28 04:38:36 +08:00
|
|
|
\n\
|
2001-01-20 07:16:56 +08:00
|
|
|
Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
GMT). When 'seconds' is not passed in, convert the current time instead.");
|
1998-06-28 04:38:36 +08:00
|
|
|
|
1996-12-07 07:32:14 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
time_localtime(PyObject *self, PyObject *args)
|
1993-06-17 20:35:49 +08:00
|
|
|
{
|
|
|
|
double when;
|
2001-01-20 07:16:56 +08:00
|
|
|
if (PyTuple_Size(args) == 0)
|
|
|
|
when = floattime();
|
|
|
|
if (!PyArg_ParseTuple(args, "|d:localtime", &when))
|
1993-06-17 20:35:49 +08:00
|
|
|
return NULL;
|
|
|
|
return time_convert((time_t)when, localtime);
|
|
|
|
}
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
PyDoc_STRVAR(localtime_doc,
|
2002-03-13 05:38:49 +08:00
|
|
|
"localtime([seconds]) -> (tm_year,tm_mon,tm_day,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)\n\
|
2001-12-02 20:27:43 +08:00
|
|
|
\n\
|
2001-01-20 07:16:56 +08:00
|
|
|
Convert seconds since the Epoch to a time tuple expressing local time.\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
When 'seconds' is not passed in, convert the current time instead.");
|
1998-06-28 04:38:36 +08:00
|
|
|
|
1993-06-24 19:10:19 +08:00
|
|
|
static int
|
2000-07-10 20:15:54 +08:00
|
|
|
gettmarg(PyObject *args, struct tm *p)
|
1993-06-24 19:10:19 +08:00
|
|
|
{
|
1998-08-25 22:51:12 +08:00
|
|
|
int y;
|
2000-07-25 20:56:38 +08:00
|
|
|
memset((void *) p, '\0', sizeof(struct tm));
|
1998-08-25 22:51:12 +08:00
|
|
|
|
1996-12-07 07:32:14 +08:00
|
|
|
if (!PyArg_Parse(args, "(iiiiiiiii)",
|
1998-08-25 22:51:12 +08:00
|
|
|
&y,
|
1997-01-14 06:44:55 +08:00
|
|
|
&p->tm_mon,
|
|
|
|
&p->tm_mday,
|
|
|
|
&p->tm_hour,
|
|
|
|
&p->tm_min,
|
|
|
|
&p->tm_sec,
|
|
|
|
&p->tm_wday,
|
|
|
|
&p->tm_yday,
|
|
|
|
&p->tm_isdst))
|
1993-06-24 19:10:19 +08:00
|
|
|
return 0;
|
1998-08-25 22:51:12 +08:00
|
|
|
if (y < 1900) {
|
|
|
|
PyObject *accept = PyDict_GetItemString(moddict,
|
|
|
|
"accept2dyear");
|
|
|
|
if (accept == NULL || !PyInt_Check(accept) ||
|
|
|
|
PyInt_AsLong(accept) == 0) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"year >= 1900 required");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (69 <= y && y <= 99)
|
|
|
|
y += 1900;
|
|
|
|
else if (0 <= y && y <= 68)
|
|
|
|
y += 2000;
|
|
|
|
else {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
2001-08-22 20:39:16 +08:00
|
|
|
"year out of range");
|
1998-08-25 22:51:12 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
p->tm_year = y - 1900;
|
1993-06-24 19:10:19 +08:00
|
|
|
p->tm_mon--;
|
|
|
|
p->tm_wday = (p->tm_wday + 1) % 7;
|
|
|
|
p->tm_yday--;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
1995-09-14 01:38:35 +08:00
|
|
|
#ifdef HAVE_STRFTIME
|
1996-12-07 07:32:14 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
time_strftime(PyObject *self, PyObject *args)
|
1995-09-14 01:38:35 +08:00
|
|
|
{
|
2001-01-20 07:16:56 +08:00
|
|
|
PyObject *tup = NULL;
|
1995-09-14 01:38:35 +08:00
|
|
|
struct tm buf;
|
|
|
|
const char *fmt;
|
2000-06-29 05:33:59 +08:00
|
|
|
size_t fmtlen, buflen;
|
1995-09-14 01:38:35 +08:00
|
|
|
char *outbuf = 0;
|
2000-06-29 05:33:59 +08:00
|
|
|
size_t i;
|
1995-09-14 01:38:35 +08:00
|
|
|
|
2000-07-25 20:56:38 +08:00
|
|
|
memset((void *) &buf, '\0', sizeof(buf));
|
1998-04-28 03:04:26 +08:00
|
|
|
|
2001-01-20 07:16:56 +08:00
|
|
|
if (!PyArg_ParseTuple(args, "s|O:strftime", &fmt, &tup))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (tup == NULL) {
|
|
|
|
time_t tt = time(NULL);
|
|
|
|
buf = *localtime(&tt);
|
|
|
|
} else if (!gettmarg(tup, &buf))
|
1995-09-14 01:38:35 +08:00
|
|
|
return NULL;
|
2001-09-25 21:59:01 +08:00
|
|
|
|
1999-02-23 08:00:10 +08:00
|
|
|
fmtlen = strlen(fmt);
|
|
|
|
|
1997-01-14 06:44:55 +08:00
|
|
|
/* I hate these functions that presume you know how big the output
|
|
|
|
* will be ahead of time...
|
|
|
|
*/
|
1999-02-23 08:00:10 +08:00
|
|
|
for (i = 1024; ; i += i) {
|
1995-09-14 01:38:35 +08:00
|
|
|
outbuf = malloc(i);
|
|
|
|
if (outbuf == NULL) {
|
1996-12-07 07:32:14 +08:00
|
|
|
return PyErr_NoMemory();
|
1995-09-14 01:38:35 +08:00
|
|
|
}
|
1999-02-23 08:00:10 +08:00
|
|
|
buflen = strftime(outbuf, i, fmt, &buf);
|
|
|
|
if (buflen > 0 || i >= 256 * fmtlen) {
|
|
|
|
/* If the buffer is 256 times as long as the format,
|
|
|
|
it's probably not failing for lack of room!
|
|
|
|
More likely, the format yields an empty result,
|
|
|
|
e.g. an empty format, or %Z when the timezone
|
|
|
|
is unknown. */
|
1996-12-07 07:32:14 +08:00
|
|
|
PyObject *ret;
|
1999-02-23 08:00:10 +08:00
|
|
|
ret = PyString_FromStringAndSize(outbuf, buflen);
|
1995-09-14 01:38:35 +08:00
|
|
|
free(outbuf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
free(outbuf);
|
|
|
|
}
|
|
|
|
}
|
1998-06-28 04:38:36 +08:00
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
PyDoc_STRVAR(strftime_doc,
|
2001-01-20 07:16:56 +08:00
|
|
|
"strftime(format[, tuple]) -> string\n\
|
1998-06-28 04:38:36 +08:00
|
|
|
\n\
|
|
|
|
Convert a time tuple to a string according to a format specification.\n\
|
2001-01-20 07:16:56 +08:00
|
|
|
See the library reference manual for formatting codes. When the time tuple\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
is not present, current time as returned by localtime() is used.");
|
1995-09-14 01:38:35 +08:00
|
|
|
#endif /* HAVE_STRFTIME */
|
|
|
|
|
2002-07-20 01:06:47 +08:00
|
|
|
#undef HAVE_STRPTIME
|
1998-06-10 00:30:31 +08:00
|
|
|
#ifdef HAVE_STRPTIME
|
2000-05-10 03:52:40 +08:00
|
|
|
|
|
|
|
#if 0
|
2000-07-23 07:57:55 +08:00
|
|
|
/* Enable this if it's not declared in <time.h> */
|
|
|
|
extern char *strptime(const char *, const char *, struct tm *);
|
2000-05-10 03:52:40 +08:00
|
|
|
#endif
|
1998-10-08 00:35:25 +08:00
|
|
|
|
1998-06-10 00:30:31 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
time_strptime(PyObject *self, PyObject *args)
|
1998-06-10 00:30:31 +08:00
|
|
|
{
|
|
|
|
struct tm tm;
|
|
|
|
char *fmt = "%a %b %d %H:%M:%S %Y";
|
|
|
|
char *buf;
|
|
|
|
char *s;
|
|
|
|
|
2000-03-15 05:17:16 +08:00
|
|
|
if (!PyArg_ParseTuple(args, "s|s:strptime", &buf, &fmt))
|
|
|
|
return NULL;
|
2000-07-25 20:56:38 +08:00
|
|
|
memset((void *) &tm, '\0', sizeof(tm));
|
1998-06-10 00:30:31 +08:00
|
|
|
s = strptime(buf, fmt, &tm);
|
|
|
|
if (s == NULL) {
|
|
|
|
PyErr_SetString(PyExc_ValueError, "format mismatch");
|
|
|
|
return NULL;
|
|
|
|
}
|
2001-03-06 20:12:02 +08:00
|
|
|
while (*s && isspace(Py_CHARMASK(*s)))
|
1998-06-10 00:30:31 +08:00
|
|
|
s++;
|
|
|
|
if (*s) {
|
|
|
|
PyErr_Format(PyExc_ValueError,
|
|
|
|
"unconverted data remains: '%.400s'", s);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return tmtotuple(&tm);
|
|
|
|
}
|
1998-06-28 04:38:36 +08:00
|
|
|
|
2002-07-20 01:06:47 +08:00
|
|
|
#endif /* HAVE_STRPTIME */
|
|
|
|
|
|
|
|
#ifndef HAVE_STRPTIME
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
time_strptime(PyObject *self, PyObject *args)
|
|
|
|
{
|
|
|
|
PyObject *strptime_module = PyImport_ImportModule("_strptime");
|
|
|
|
|
|
|
|
if (!strptime_module)
|
|
|
|
return NULL;
|
|
|
|
return PyObject_CallMethod(strptime_module, "strptime", "O", args);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* !HAVE_STRPTIME */
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
PyDoc_STRVAR(strptime_doc,
|
1999-01-08 02:29:26 +08:00
|
|
|
"strptime(string, format) -> tuple\n\
|
2001-12-02 20:27:43 +08:00
|
|
|
\n\
|
1998-06-28 04:38:36 +08:00
|
|
|
Parse a string to a time tuple according to a format specification.\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
See the library reference manual for formatting codes (same as strftime()).");
|
2002-07-20 01:06:47 +08:00
|
|
|
|
1998-06-10 00:30:31 +08:00
|
|
|
|
1996-12-07 07:32:14 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
time_asctime(PyObject *self, PyObject *args)
|
1993-06-24 19:10:19 +08:00
|
|
|
{
|
2001-01-20 07:16:56 +08:00
|
|
|
PyObject *tup = NULL;
|
1993-06-24 19:10:19 +08:00
|
|
|
struct tm buf;
|
|
|
|
char *p;
|
2001-01-20 07:16:56 +08:00
|
|
|
if (!PyArg_ParseTuple(args, "|O:asctime", &tup))
|
2000-01-13 00:38:20 +08:00
|
|
|
return NULL;
|
2001-01-20 07:16:56 +08:00
|
|
|
if (tup == NULL) {
|
|
|
|
time_t tt = time(NULL);
|
|
|
|
buf = *localtime(&tt);
|
|
|
|
} else if (!gettmarg(tup, &buf))
|
1993-06-24 19:10:19 +08:00
|
|
|
return NULL;
|
|
|
|
p = asctime(&buf);
|
|
|
|
if (p[24] == '\n')
|
|
|
|
p[24] = '\0';
|
1996-12-07 07:32:14 +08:00
|
|
|
return PyString_FromString(p);
|
1993-06-24 19:10:19 +08:00
|
|
|
}
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
PyDoc_STRVAR(asctime_doc,
|
2001-01-20 07:16:56 +08:00
|
|
|
"asctime([tuple]) -> string\n\
|
1998-06-28 04:38:36 +08:00
|
|
|
\n\
|
2001-01-20 07:16:56 +08:00
|
|
|
Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.\n\
|
|
|
|
When the time tuple is not present, current time as returned by localtime()\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
is used.");
|
1998-06-28 04:38:36 +08:00
|
|
|
|
1996-12-07 07:32:14 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
time_ctime(PyObject *self, PyObject *args)
|
1993-06-24 19:10:19 +08:00
|
|
|
{
|
|
|
|
double dt;
|
|
|
|
time_t tt;
|
|
|
|
char *p;
|
2001-09-25 21:59:01 +08:00
|
|
|
|
2001-01-20 07:16:56 +08:00
|
|
|
if (PyTuple_Size(args) == 0)
|
|
|
|
tt = time(NULL);
|
|
|
|
else {
|
|
|
|
if (!PyArg_ParseTuple(args, "|d:ctime", &dt))
|
|
|
|
return NULL;
|
|
|
|
tt = (time_t)dt;
|
|
|
|
}
|
1993-06-24 19:10:19 +08:00
|
|
|
p = ctime(&tt);
|
1998-03-04 06:19:10 +08:00
|
|
|
if (p == NULL) {
|
|
|
|
PyErr_SetString(PyExc_ValueError, "unconvertible time");
|
|
|
|
return NULL;
|
|
|
|
}
|
1993-06-24 19:10:19 +08:00
|
|
|
if (p[24] == '\n')
|
|
|
|
p[24] = '\0';
|
1996-12-07 07:32:14 +08:00
|
|
|
return PyString_FromString(p);
|
1993-06-24 19:10:19 +08:00
|
|
|
}
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
PyDoc_STRVAR(ctime_doc,
|
1998-06-28 04:38:36 +08:00
|
|
|
"ctime(seconds) -> string\n\
|
|
|
|
\n\
|
|
|
|
Convert a time in seconds since the Epoch to a string in local time.\n\
|
2001-01-20 07:16:56 +08:00
|
|
|
This is equivalent to asctime(localtime(seconds)). When the time tuple is\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
not present, current time as returned by localtime() is used.");
|
1998-06-28 04:38:36 +08:00
|
|
|
|
1998-03-07 01:16:21 +08:00
|
|
|
#ifdef HAVE_MKTIME
|
1996-12-07 07:32:14 +08:00
|
|
|
static PyObject *
|
2000-07-10 20:15:54 +08:00
|
|
|
time_mktime(PyObject *self, PyObject *args)
|
1993-06-17 20:35:49 +08:00
|
|
|
{
|
2000-01-13 00:38:20 +08:00
|
|
|
PyObject *tup;
|
1993-06-17 20:35:49 +08:00
|
|
|
struct tm buf;
|
1996-05-24 06:53:47 +08:00
|
|
|
time_t tt;
|
2000-02-29 21:59:29 +08:00
|
|
|
if (!PyArg_ParseTuple(args, "O:mktime", &tup))
|
2000-01-13 00:38:20 +08:00
|
|
|
return NULL;
|
1996-05-24 06:53:47 +08:00
|
|
|
tt = time(&tt);
|
|
|
|
buf = *localtime(&tt);
|
2000-01-13 00:38:20 +08:00
|
|
|
if (!gettmarg(tup, &buf))
|
1993-06-17 20:35:49 +08:00
|
|
|
return NULL;
|
1996-05-24 06:53:47 +08:00
|
|
|
tt = mktime(&buf);
|
|
|
|
if (tt == (time_t)(-1)) {
|
1996-12-07 07:32:14 +08:00
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
2001-09-25 21:59:01 +08:00
|
|
|
"mktime argument out of range");
|
1996-05-24 06:53:47 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
1996-12-07 07:32:14 +08:00
|
|
|
return PyFloat_FromDouble((double)tt);
|
1993-06-17 20:35:49 +08:00
|
|
|
}
|
1998-06-28 04:38:36 +08:00
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
PyDoc_STRVAR(mktime_doc,
|
1998-06-28 04:38:36 +08:00
|
|
|
"mktime(tuple) -> floating point number\n\
|
|
|
|
\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
Convert a time tuple in local time to seconds since the Epoch.");
|
1998-03-07 01:16:21 +08:00
|
|
|
#endif /* HAVE_MKTIME */
|
1993-06-17 20:35:49 +08:00
|
|
|
|
1996-12-07 07:32:14 +08:00
|
|
|
static PyMethodDef time_methods[] = {
|
2001-01-20 07:16:56 +08:00
|
|
|
{"time", time_time, METH_VARARGS, time_doc},
|
1994-08-01 19:34:53 +08:00
|
|
|
#ifdef HAVE_CLOCK
|
2001-01-20 07:16:56 +08:00
|
|
|
{"clock", time_clock, METH_VARARGS, clock_doc},
|
1994-08-01 19:34:53 +08:00
|
|
|
#endif
|
2001-01-20 07:16:56 +08:00
|
|
|
{"sleep", time_sleep, METH_VARARGS, sleep_doc},
|
|
|
|
{"gmtime", time_gmtime, METH_VARARGS, gmtime_doc},
|
|
|
|
{"localtime", time_localtime, METH_VARARGS, localtime_doc},
|
2000-08-03 10:06:16 +08:00
|
|
|
{"asctime", time_asctime, METH_VARARGS, asctime_doc},
|
2001-01-20 07:16:56 +08:00
|
|
|
{"ctime", time_ctime, METH_VARARGS, ctime_doc},
|
1998-03-07 01:16:21 +08:00
|
|
|
#ifdef HAVE_MKTIME
|
2000-08-03 10:06:16 +08:00
|
|
|
{"mktime", time_mktime, METH_VARARGS, mktime_doc},
|
1998-03-07 01:16:21 +08:00
|
|
|
#endif
|
1995-09-14 01:38:35 +08:00
|
|
|
#ifdef HAVE_STRFTIME
|
2000-08-03 10:06:16 +08:00
|
|
|
{"strftime", time_strftime, METH_VARARGS, strftime_doc},
|
1998-06-10 00:30:31 +08:00
|
|
|
#endif
|
2000-08-03 10:06:16 +08:00
|
|
|
{"strptime", time_strptime, METH_VARARGS, strptime_doc},
|
1990-10-14 20:07:46 +08:00
|
|
|
{NULL, NULL} /* sentinel */
|
|
|
|
};
|
|
|
|
|
2000-09-01 17:01:32 +08:00
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
PyDoc_STRVAR(module_doc,
|
1998-06-28 04:38:36 +08:00
|
|
|
"This module provides various functions to manipulate time values.\n\
|
|
|
|
\n\
|
|
|
|
There are two standard representations of time. One is the number\n\
|
|
|
|
of seconds since the Epoch, in UTC (a.k.a. GMT). It may be an integer\n\
|
|
|
|
or a floating point number (to represent fractions of seconds).\n\
|
|
|
|
The Epoch is system-defined; on Unix, it is generally January 1st, 1970.\n\
|
|
|
|
The actual value can be retrieved by calling gmtime(0).\n\
|
|
|
|
\n\
|
|
|
|
The other representation is a tuple of 9 integers giving local time.\n\
|
|
|
|
The tuple items are:\n\
|
|
|
|
year (four digits, e.g. 1998)\n\
|
|
|
|
month (1-12)\n\
|
|
|
|
day (1-31)\n\
|
|
|
|
hours (0-23)\n\
|
|
|
|
minutes (0-59)\n\
|
1999-02-23 00:19:52 +08:00
|
|
|
seconds (0-59)\n\
|
1998-06-28 04:38:36 +08:00
|
|
|
weekday (0-6, Monday is 0)\n\
|
|
|
|
Julian day (day in the year, 1-366)\n\
|
|
|
|
DST (Daylight Savings Time) flag (-1, 0 or 1)\n\
|
|
|
|
If the DST flag is 0, the time is given in the regular time zone;\n\
|
|
|
|
if it is 1, the time is given in the DST time zone;\n\
|
|
|
|
if it is -1, mktime() should guess based on the date and time.\n\
|
|
|
|
\n\
|
|
|
|
Variables:\n\
|
|
|
|
\n\
|
|
|
|
timezone -- difference in seconds between UTC and local standard time\n\
|
|
|
|
altzone -- difference in seconds between UTC and local DST time\n\
|
|
|
|
daylight -- whether local time should reflect DST\n\
|
|
|
|
tzname -- tuple of (standard time zone name, DST time zone name)\n\
|
|
|
|
\n\
|
|
|
|
Functions:\n\
|
|
|
|
\n\
|
|
|
|
time() -- return current time in seconds since the Epoch as a float\n\
|
|
|
|
clock() -- return CPU time since process start as a float\n\
|
|
|
|
sleep() -- delay for a number of seconds given as a float\n\
|
|
|
|
gmtime() -- convert seconds since Epoch to UTC tuple\n\
|
|
|
|
localtime() -- convert seconds since Epoch to local time tuple\n\
|
|
|
|
asctime() -- convert time tuple to string\n\
|
|
|
|
ctime() -- convert time in seconds to string\n\
|
|
|
|
mktime() -- convert local time tuple to seconds since Epoch\n\
|
|
|
|
strftime() -- convert time tuple to string according to format specification\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
strptime() -- parse string to time tuple according to format specification");
|
2001-09-25 21:59:01 +08:00
|
|
|
|
1998-06-28 04:38:36 +08:00
|
|
|
|
1998-12-05 02:50:17 +08:00
|
|
|
DL_EXPORT(void)
|
2000-07-21 14:00:07 +08:00
|
|
|
inittime(void)
|
1990-10-14 20:07:46 +08:00
|
|
|
{
|
2002-04-01 22:49:59 +08:00
|
|
|
PyObject *m;
|
1998-08-25 22:51:12 +08:00
|
|
|
char *p;
|
1998-06-28 04:38:36 +08:00
|
|
|
m = Py_InitModule3("time", time_methods, module_doc);
|
2002-04-01 22:49:59 +08:00
|
|
|
|
1998-10-08 00:35:25 +08:00
|
|
|
/* Accept 2-digit dates unless PYTHONY2K is set and non-empty */
|
2001-07-24 00:30:27 +08:00
|
|
|
p = Py_GETENV("PYTHONY2K");
|
2002-04-01 22:49:59 +08:00
|
|
|
PyModule_AddIntConstant(m, "accept2dyear", (long) (!p || !*p));
|
1998-10-08 00:35:25 +08:00
|
|
|
/* Squirrel away the module's dictionary for the y2k check */
|
2002-04-01 22:49:59 +08:00
|
|
|
moddict = PyModule_GetDict(m);
|
|
|
|
Py_INCREF(moddict);
|
2001-09-25 21:59:01 +08:00
|
|
|
#if defined(HAVE_TZNAME) && !defined(__GLIBC__) && !defined(__CYGWIN__)
|
1993-06-17 20:35:49 +08:00
|
|
|
tzset();
|
1998-09-29 06:07:11 +08:00
|
|
|
#ifdef PYOS_OS2
|
2002-04-01 22:49:59 +08:00
|
|
|
PyModule_AddIntConstant(m, "timezone", _timezone);
|
1998-09-29 06:07:11 +08:00
|
|
|
#else /* !PYOS_OS2 */
|
2002-04-01 22:49:59 +08:00
|
|
|
PyModule_AddIntConstant(m, "timezone", timezone);
|
1998-09-29 06:07:11 +08:00
|
|
|
#endif /* PYOS_OS2 */
|
1994-08-01 19:34:53 +08:00
|
|
|
#ifdef HAVE_ALTZONE
|
2002-04-01 22:49:59 +08:00
|
|
|
PyModule_AddIntConstant(m, "altzone", altzone);
|
1994-08-01 19:34:53 +08:00
|
|
|
#else
|
1998-09-29 06:07:11 +08:00
|
|
|
#ifdef PYOS_OS2
|
2002-04-01 22:49:59 +08:00
|
|
|
PyModule_AddIntConstant(m, "altzone", _timezone-3600);
|
1998-09-29 06:07:11 +08:00
|
|
|
#else /* !PYOS_OS2 */
|
2002-04-01 22:49:59 +08:00
|
|
|
PyModule_AddIntConstant(m, "altzone", timezone-3600);
|
1998-09-29 06:07:11 +08:00
|
|
|
#endif /* PYOS_OS2 */
|
1994-08-01 19:34:53 +08:00
|
|
|
#endif
|
2002-04-01 22:49:59 +08:00
|
|
|
PyModule_AddIntConstant(m, "daylight", daylight);
|
|
|
|
PyModule_AddObject(m, "tzname",
|
|
|
|
Py_BuildValue("(zz)", tzname[0], tzname[1]));
|
2001-09-25 21:59:01 +08:00
|
|
|
#else /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
|
1999-04-06 05:54:14 +08:00
|
|
|
#ifdef HAVE_TM_ZONE
|
1993-06-17 20:35:49 +08:00
|
|
|
{
|
|
|
|
#define YEAR ((time_t)((365 * 24 + 6) * 3600))
|
|
|
|
time_t t;
|
|
|
|
struct tm *p;
|
1999-03-30 03:12:04 +08:00
|
|
|
long janzone, julyzone;
|
|
|
|
char janname[10], julyname[10];
|
1993-06-17 20:35:49 +08:00
|
|
|
t = (time((time_t *)0) / YEAR) * YEAR;
|
|
|
|
p = localtime(&t);
|
1999-03-30 03:12:04 +08:00
|
|
|
janzone = -p->tm_gmtoff;
|
|
|
|
strncpy(janname, p->tm_zone ? p->tm_zone : " ", 9);
|
|
|
|
janname[9] = '\0';
|
1993-06-17 20:35:49 +08:00
|
|
|
t += YEAR/2;
|
|
|
|
p = localtime(&t);
|
1999-03-30 03:12:04 +08:00
|
|
|
julyzone = -p->tm_gmtoff;
|
|
|
|
strncpy(julyname, p->tm_zone ? p->tm_zone : " ", 9);
|
|
|
|
julyname[9] = '\0';
|
2001-09-25 21:59:01 +08:00
|
|
|
|
1999-03-30 03:12:04 +08:00
|
|
|
if( janzone < julyzone ) {
|
|
|
|
/* DST is reversed in the southern hemisphere */
|
2002-04-01 22:49:59 +08:00
|
|
|
PyModule_AddIntConstant(m, "timezone", julyzone);
|
|
|
|
PyModule_AddIntConstant(m, "altzone", janzone);
|
|
|
|
PyModule_AddIntConstant(m, "daylight",
|
|
|
|
janzone != julyzone);
|
|
|
|
PyModule_AddObject(m, "tzname",
|
|
|
|
Py_BuildValue("(zz)",
|
|
|
|
julyname, janname));
|
1999-03-30 03:12:04 +08:00
|
|
|
} else {
|
2002-04-01 22:49:59 +08:00
|
|
|
PyModule_AddIntConstant(m, "timezone", janzone);
|
|
|
|
PyModule_AddIntConstant(m, "altzone", julyzone);
|
|
|
|
PyModule_AddIntConstant(m, "daylight",
|
|
|
|
janzone != julyzone);
|
|
|
|
PyModule_AddObject(m, "tzname",
|
|
|
|
Py_BuildValue("(zz)",
|
|
|
|
janname, julyname));
|
1999-03-30 03:12:04 +08:00
|
|
|
}
|
1993-06-17 20:35:49 +08:00
|
|
|
}
|
1997-10-08 23:27:56 +08:00
|
|
|
#else
|
|
|
|
#ifdef macintosh
|
1997-12-09 05:56:43 +08:00
|
|
|
/* The only thing we can obtain is the current timezone
|
|
|
|
** (and whether dst is currently _active_, but that is not what
|
|
|
|
** we're looking for:-( )
|
|
|
|
*/
|
1997-10-08 23:27:56 +08:00
|
|
|
initmactimezone();
|
2002-04-01 22:49:59 +08:00
|
|
|
PyModule_AddIntConstant(m, "timezone", timezone);
|
|
|
|
PyModule_AddIntConstant(m, "altzone", timezone);
|
|
|
|
PyModule_AddIntConstant(m, "daylight", 0);
|
|
|
|
PyModule_AddObject(m, "tzname", Py_BuildValue("(zz)", "", ""));
|
1997-10-08 23:27:56 +08:00
|
|
|
#endif /* macintosh */
|
1994-08-01 19:34:53 +08:00
|
|
|
#endif /* HAVE_TM_ZONE */
|
2001-03-20 11:26:49 +08:00
|
|
|
#ifdef __CYGWIN__
|
|
|
|
tzset();
|
2002-04-01 22:49:59 +08:00
|
|
|
PyModule_AddIntConstant(m, "timezone", _timezone);
|
|
|
|
PyModule_AddIntConstant(m, "altzone", _timezone);
|
|
|
|
PyModule_AddIntConstant(m, "daylight", _daylight);
|
|
|
|
PyModule_AddObject(m, "tzname",
|
|
|
|
Py_BuildValue("(zz)", _tzname[0], _tzname[1]));
|
2001-03-20 11:26:49 +08:00
|
|
|
#endif /* __CYGWIN__ */
|
2001-09-25 21:59:01 +08:00
|
|
|
#endif /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
|
2002-07-16 09:29:19 +08:00
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
/* Helper to allow interrupts for Windows.
|
|
|
|
If Ctrl+C event delivered while not sleeping
|
|
|
|
it will be ignored.
|
|
|
|
*/
|
|
|
|
main_thread = PyThread_get_thread_ident();
|
|
|
|
hInterruptEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
|
|
SetConsoleCtrlHandler( PyCtrlHandler, TRUE);
|
|
|
|
#endif /* MS_WINDOWS */
|
SF patch #462296: Add attributes to os.stat results; by Nick Mathewson.
This is a big one, touching lots of files. Some of the platforms
aren't tested yet. Briefly, this changes the return value of the
os/posix functions stat(), fstat(), statvfs(), fstatvfs(), and the
time functions localtime(), gmtime(), and strptime() from tuples into
pseudo-sequences. When accessed as a sequence, they behave exactly as
before. But they also have attributes like st_mtime or tm_year. The
stat return value, moreover, has a few platform-specific attributes
that are not available through the sequence interface (because
everybody expects the sequence to have a fixed length, these couldn't
be added there). If your platform's struct stat doesn't define
st_blksize, st_blocks or st_rdev, they won't be accessible from Python
either.
(Still missing is a documentation update.)
2001-10-19 04:34:25 +08:00
|
|
|
PyStructSequence_InitType(&StructTimeType, &struct_time_type_desc);
|
2002-04-01 22:49:59 +08:00
|
|
|
Py_INCREF(&StructTimeType);
|
|
|
|
PyModule_AddObject(m, "struct_time", (PyObject*) &StructTimeType);
|
1990-10-14 20:07:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1994-08-01 19:34:53 +08:00
|
|
|
/* Implement floattime() for various platforms */
|
1990-10-14 20:07:46 +08:00
|
|
|
|
1994-08-01 19:34:53 +08:00
|
|
|
static double
|
2000-07-21 14:00:07 +08:00
|
|
|
floattime(void)
|
1990-10-14 20:07:46 +08:00
|
|
|
{
|
1994-08-01 19:34:53 +08:00
|
|
|
/* There are three ways to get the time:
|
1997-01-14 06:44:55 +08:00
|
|
|
(1) gettimeofday() -- resolution in microseconds
|
|
|
|
(2) ftime() -- resolution in milliseconds
|
|
|
|
(3) time() -- resolution in seconds
|
|
|
|
In all cases the return value is a float in seconds.
|
|
|
|
Since on some systems (e.g. SCO ODT 3.0) gettimeofday() may
|
|
|
|
fail, so we fall back on ftime() or time().
|
|
|
|
Note: clock resolution does not imply clock accuracy! */
|
1994-08-01 19:34:53 +08:00
|
|
|
#ifdef HAVE_GETTIMEOFDAY
|
1997-01-14 06:44:55 +08:00
|
|
|
{
|
|
|
|
struct timeval t;
|
1995-01-03 03:30:30 +08:00
|
|
|
#ifdef GETTIMEOFDAY_NO_TZ
|
1997-01-14 06:44:55 +08:00
|
|
|
if (gettimeofday(&t) == 0)
|
|
|
|
return (double)t.tv_sec + t.tv_usec*0.000001;
|
1995-01-03 03:30:30 +08:00
|
|
|
#else /* !GETTIMEOFDAY_NO_TZ */
|
1997-01-14 06:44:55 +08:00
|
|
|
if (gettimeofday(&t, (struct timezone *)NULL) == 0)
|
|
|
|
return (double)t.tv_sec + t.tv_usec*0.000001;
|
1995-01-03 03:30:30 +08:00
|
|
|
#endif /* !GETTIMEOFDAY_NO_TZ */
|
1997-01-14 06:44:55 +08:00
|
|
|
}
|
1994-08-01 19:34:53 +08:00
|
|
|
#endif /* !HAVE_GETTIMEOFDAY */
|
1997-01-14 06:44:55 +08:00
|
|
|
{
|
1999-03-10 00:07:23 +08:00
|
|
|
#if defined(HAVE_FTIME)
|
1997-01-14 06:44:55 +08:00
|
|
|
struct timeb t;
|
|
|
|
ftime(&t);
|
|
|
|
return (double)t.time + (double)t.millitm * (double)0.001;
|
1994-08-01 19:34:53 +08:00
|
|
|
#else /* !HAVE_FTIME */
|
1997-01-14 06:44:55 +08:00
|
|
|
time_t secs;
|
|
|
|
time(&secs);
|
|
|
|
return (double)secs;
|
1994-08-01 19:34:53 +08:00
|
|
|
#endif /* !HAVE_FTIME */
|
1997-01-14 06:44:55 +08:00
|
|
|
}
|
1990-10-14 20:07:46 +08:00
|
|
|
}
|
|
|
|
|
1991-02-19 20:27:35 +08:00
|
|
|
|
1994-08-01 19:34:53 +08:00
|
|
|
/* Implement floatsleep() for various platforms.
|
|
|
|
When interrupted (or when another error occurs), return -1 and
|
|
|
|
set an exception; else return 0. */
|
1991-02-19 20:27:35 +08:00
|
|
|
|
1994-08-01 19:34:53 +08:00
|
|
|
static int
|
1995-03-09 20:14:15 +08:00
|
|
|
floatsleep(double secs)
|
1992-08-06 03:58:53 +08:00
|
|
|
{
|
2002-06-30 23:26:10 +08:00
|
|
|
/* XXX Should test for MS_WINDOWS first! */
|
2002-03-03 10:59:16 +08:00
|
|
|
#if defined(HAVE_SELECT) && !defined(__BEOS__) && !defined(__EMX__)
|
1992-08-06 03:58:53 +08:00
|
|
|
struct timeval t;
|
1993-01-10 01:18:52 +08:00
|
|
|
double frac;
|
|
|
|
frac = fmod(secs, 1.0);
|
|
|
|
secs = floor(secs);
|
|
|
|
t.tv_sec = (long)secs;
|
|
|
|
t.tv_usec = (long)(frac*1000000.0);
|
1997-11-04 06:04:46 +08:00
|
|
|
Py_BEGIN_ALLOW_THREADS
|
1994-08-01 19:34:53 +08:00
|
|
|
if (select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &t) != 0) {
|
1999-11-08 23:32:27 +08:00
|
|
|
#ifdef EINTR
|
1999-08-19 22:40:27 +08:00
|
|
|
if (errno != EINTR) {
|
1999-11-08 23:32:27 +08:00
|
|
|
#else
|
|
|
|
if (1) {
|
|
|
|
#endif
|
2000-03-25 04:35:20 +08:00
|
|
|
Py_BLOCK_THREADS
|
1999-08-19 22:40:27 +08:00
|
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
|
|
|
return -1;
|
|
|
|
}
|
1994-08-01 19:34:53 +08:00
|
|
|
}
|
1997-11-04 06:04:46 +08:00
|
|
|
Py_END_ALLOW_THREADS
|
2002-01-16 19:04:06 +08:00
|
|
|
#elif defined(macintosh)
|
1994-08-01 19:34:53 +08:00
|
|
|
#define MacTicks (* (long *)0x16A)
|
|
|
|
long deadline;
|
|
|
|
deadline = MacTicks + (long)(secs * 60.0);
|
|
|
|
while (MacTicks < deadline) {
|
1997-11-04 06:04:46 +08:00
|
|
|
/* XXX Should call some yielding function here */
|
1996-12-07 07:32:14 +08:00
|
|
|
if (PyErr_CheckSignals())
|
1994-08-01 19:34:53 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2002-01-16 19:04:06 +08:00
|
|
|
#elif defined(__WATCOMC__) && !defined(__QNX__)
|
1996-05-24 06:53:47 +08:00
|
|
|
/* XXX Can't interrupt this sleep */
|
1997-11-04 06:04:46 +08:00
|
|
|
Py_BEGIN_ALLOW_THREADS
|
1996-05-24 06:53:47 +08:00
|
|
|
delay((int)(secs * 1000 + 0.5)); /* delay() uses milliseconds */
|
1997-11-04 06:04:46 +08:00
|
|
|
Py_END_ALLOW_THREADS
|
2002-06-30 23:26:10 +08:00
|
|
|
#elif defined(MS_WINDOWS)
|
2000-06-30 05:31:02 +08:00
|
|
|
{
|
|
|
|
double millisecs = secs * 1000.0;
|
|
|
|
if (millisecs > (double)ULONG_MAX) {
|
|
|
|
PyErr_SetString(PyExc_OverflowError, "sleep length is too large");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2002-07-16 09:29:19 +08:00
|
|
|
/* allow sleep(0) to maintain win32 semantics, and as decreed by
|
|
|
|
Guido, only the main thread can be interrupted. */
|
|
|
|
if ((unsigned long)millisecs==0 || main_thread != PyThread_get_thread_ident())
|
|
|
|
Sleep((unsigned long)millisecs);
|
|
|
|
else {
|
|
|
|
DWORD rc;
|
|
|
|
ResetEvent(hInterruptEvent);
|
|
|
|
rc = WaitForSingleObject(hInterruptEvent, (unsigned long)millisecs);
|
|
|
|
if (rc==WAIT_OBJECT_0) {
|
|
|
|
/* yield to make sure real Python signal handler called */
|
|
|
|
Sleep(1);
|
|
|
|
Py_BLOCK_THREADS
|
|
|
|
/* PyErr_SetFromErrno() does the "right thing" wrt signals
|
|
|
|
if errno=EINTR
|
|
|
|
*/
|
|
|
|
errno = EINTR;
|
|
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2000-06-30 05:31:02 +08:00
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
}
|
2002-01-16 19:04:06 +08:00
|
|
|
#elif defined(PYOS_OS2)
|
1997-11-23 05:53:48 +08:00
|
|
|
/* This Sleep *IS* Interruptable by Exceptions */
|
1997-12-30 04:03:10 +08:00
|
|
|
Py_BEGIN_ALLOW_THREADS
|
1997-11-23 05:53:48 +08:00
|
|
|
if (DosSleep(secs * 1000) != NO_ERROR) {
|
1997-12-30 04:03:10 +08:00
|
|
|
Py_BLOCK_THREADS
|
1997-11-23 05:53:48 +08:00
|
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
|
|
|
return -1;
|
|
|
|
}
|
1997-12-30 04:03:10 +08:00
|
|
|
Py_END_ALLOW_THREADS
|
2002-01-16 19:04:06 +08:00
|
|
|
#elif defined(__BEOS__)
|
1998-08-05 06:53:56 +08:00
|
|
|
/* This sleep *CAN BE* interrupted. */
|
|
|
|
{
|
|
|
|
if( secs <= 0.0 ) {
|
|
|
|
return;
|
|
|
|
}
|
2001-09-25 21:59:01 +08:00
|
|
|
|
1998-08-05 06:53:56 +08:00
|
|
|
Py_BEGIN_ALLOW_THREADS
|
1999-03-10 00:07:23 +08:00
|
|
|
/* BeOS snooze() is in microseconds... */
|
|
|
|
if( snooze( (bigtime_t)( secs * 1000.0 * 1000.0 ) ) == B_INTERRUPTED ) {
|
1998-08-05 06:53:56 +08:00
|
|
|
Py_BLOCK_THREADS
|
|
|
|
PyErr_SetFromErrno( PyExc_IOError );
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
}
|
2002-01-16 19:04:06 +08:00
|
|
|
#elif defined(RISCOS)
|
2001-04-11 06:07:43 +08:00
|
|
|
if (secs <= 0.0)
|
|
|
|
return 0;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
|
|
/* This sleep *CAN BE* interrupted. */
|
|
|
|
if ( sleep(secs) )
|
|
|
|
return -1;
|
|
|
|
Py_END_ALLOW_THREADS
|
2002-01-16 19:04:06 +08:00
|
|
|
#elif defined(PLAN9)
|
|
|
|
{
|
|
|
|
double millisecs = secs * 1000.0;
|
|
|
|
if (millisecs > (double)LONG_MAX) {
|
|
|
|
PyErr_SetString(PyExc_OverflowError, "sleep length is too large");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
/* This sleep *CAN BE* interrupted. */
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
|
|
if(sleep((long)millisecs) < 0){
|
|
|
|
Py_BLOCK_THREADS
|
|
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
}
|
|
|
|
#else
|
1994-08-01 19:34:53 +08:00
|
|
|
/* XXX Can't interrupt this sleep */
|
1997-11-04 06:04:46 +08:00
|
|
|
Py_BEGIN_ALLOW_THREADS
|
1994-08-01 19:34:53 +08:00
|
|
|
sleep((int)secs);
|
1997-11-04 06:04:46 +08:00
|
|
|
Py_END_ALLOW_THREADS
|
2002-01-16 19:04:06 +08:00
|
|
|
#endif
|
SF patch #462296: Add attributes to os.stat results; by Nick Mathewson.
This is a big one, touching lots of files. Some of the platforms
aren't tested yet. Briefly, this changes the return value of the
os/posix functions stat(), fstat(), statvfs(), fstatvfs(), and the
time functions localtime(), gmtime(), and strptime() from tuples into
pseudo-sequences. When accessed as a sequence, they behave exactly as
before. But they also have attributes like st_mtime or tm_year. The
stat return value, moreover, has a few platform-specific attributes
that are not available through the sequence interface (because
everybody expects the sequence to have a fixed length, these couldn't
be added there). If your platform's struct stat doesn't define
st_blksize, st_blocks or st_rdev, they won't be accessible from Python
either.
(Still missing is a documentation update.)
2001-10-19 04:34:25 +08:00
|
|
|
|
1994-08-01 19:34:53 +08:00
|
|
|
return 0;
|
1993-07-05 18:31:29 +08:00
|
|
|
}
|