#ifdef __APPLE__
/*
- * Step 1 of support for weak-linking a number of symbols existing on
+ * Step 1 of support for weak-linking a number of symbols existing on
* OSX 10.4 and later, see the comment in the #ifdef __APPLE__ block
* at the end of this file for more information.
*/
#endif /* HAVE_SYS_STAT_H */
#ifdef HAVE_SYS_WAIT_H
-#include <sys/wait.h> /* For WNOHANG */
+#include <sys/wait.h> /* For WNOHANG */
#endif
#ifdef HAVE_SIGNAL_H
#if defined(PYCC_VACPP) && defined(PYOS_OS2)
#include <process.h>
#else
-#if defined(__WATCOMC__) && !defined(__QNX__) /* Watcom compiler */
+#if defined(__WATCOMC__) && !defined(__QNX__) /* Watcom compiler */
#define HAVE_GETCWD 1
#define HAVE_OPENDIR 1
-#define HAVE_SYSTEM 1
+#define HAVE_SYSTEM 1
#if defined(__OS2__)
#define HAVE_EXECV 1
#define HAVE_WAIT 1
#endif
#include <process.h>
#else
-#ifdef __BORLANDC__ /* Borland compiler */
+#ifdef __BORLANDC__ /* Borland compiler */
#define HAVE_EXECV 1
#define HAVE_GETCWD 1
#define HAVE_OPENDIR 1
#define HAVE_PIPE 1
-#define HAVE_SYSTEM 1
+#define HAVE_SYSTEM 1
#define HAVE_WAIT 1
#else
-#ifdef _MSC_VER /* Microsoft compiler */
+#ifdef _MSC_VER /* Microsoft compiler */
#define HAVE_GETCWD 1
-#define HAVE_SPAWNV 1
+#define HAVE_SPAWNV 1
#define HAVE_EXECV 1
#define HAVE_PIPE 1
-#define HAVE_SYSTEM 1
-#define HAVE_CWAIT 1
-#define HAVE_FSYNC 1
+#define HAVE_SYSTEM 1
+#define HAVE_CWAIT 1
+#define HAVE_FSYNC 1
#define fsync _commit
#else
#if defined(PYOS_OS2) && defined(PYCC_GCC) || defined(__VMS)
/* Everything needed is defined in PC/os2emx/pyconfig.h or vms/pyconfig.h */
-#else /* all other compilers */
+#else /* all other compilers */
/* Unix functions that the configure script doesn't check for */
#define HAVE_EXECV 1
#define HAVE_FORK 1
-#if defined(__USLC__) && defined(__SCO_VERSION__) /* SCO UDK Compiler */
+#if defined(__USLC__) && defined(__SCO_VERSION__) /* SCO UDK Compiler */
#define HAVE_FORK1 1
#endif
#define HAVE_GETCWD 1
#define HAVE_KILL 1
#define HAVE_OPENDIR 1
#define HAVE_PIPE 1
-#define HAVE_SYSTEM 1
+#define HAVE_SYSTEM 1
#define HAVE_WAIT 1
-#define HAVE_TTYNAME 1
+#define HAVE_TTYNAME 1
#endif /* PYOS_OS2 && PYCC_GCC && __VMS */
#endif /* _MSC_VER */
#endif /* __BORLANDC__ */
#include "osdefs.h"
#include <malloc.h>
#include <windows.h>
-#include <shellapi.h> /* for ShellExecute() */
+#include <shellapi.h> /* for ShellExecute() */
#endif /* _MSC_VER */
#if defined(PYCC_VACPP) && defined(PYOS_OS2)
/* choose the appropriate stat and fstat functions and return structs */
#undef STAT
#if defined(MS_WIN64) || defined(MS_WINDOWS)
-# define STAT win32_stat
-# define FSTAT win32_fstat
-# define STRUCT_STAT struct win32_stat
+# define STAT win32_stat
+# define FSTAT win32_fstat
+# define STRUCT_STAT struct win32_stat
#else
-# define STAT stat
-# define FSTAT fstat
-# define STRUCT_STAT struct stat
+# define STAT stat
+# define FSTAT fstat
+# define STRUCT_STAT struct stat
#endif
#if defined(MAJOR_IN_MKDEV)
* as a fd and should merely raise a python exception on error.
* The Microsoft CRT doesn't provide an official way to check for the
* validity of a file descriptor, but we can emulate its internal behaviour
- * by using the exported __pinfo data member and knowledge of the
+ * by using the exported __pinfo data member and knowledge of the
* internal structures involved.
* The structures below must be updated for each version of visual studio
* according to the file internal.h in the CRT source, until MS comes
* Only the first items must be present.
*/
typedef struct {
- intptr_t osfhnd;
- char osfile;
+ intptr_t osfhnd;
+ char osfile;
} my_ioinfo;
extern __declspec(dllimport) char * __pioinfo[];
int
_PyVerify_fd(int fd)
{
- const int i1 = fd >> IOINFO_L2E;
- const int i2 = fd & ((1 << IOINFO_L2E) - 1);
-
- static int sizeof_ioinfo = 0;
-
- /* Determine the actual size of the ioinfo structure,
- * as used by the CRT loaded in memory
- */
- if (sizeof_ioinfo == 0 && __pioinfo[0] != NULL) {
- sizeof_ioinfo = _msize(__pioinfo[0]) / IOINFO_ARRAY_ELTS;
- }
- if (sizeof_ioinfo == 0) {
- /* This should not happen... */
- goto fail;
- }
-
- /* See that it isn't a special CLEAR fileno */
- if (fd != _NO_CONSOLE_FILENO) {
- /* Microsoft CRT would check that 0<=fd<_nhandle but we can't do that. Instead
- * we check pointer validity and other info
- */
- if (0 <= i1 && i1 < IOINFO_ARRAYS && __pioinfo[i1] != NULL) {
- /* finally, check that the file is open */
- my_ioinfo* info = (my_ioinfo*)(__pioinfo[i1] + i2 * sizeof_ioinfo);
- if (info->osfile & FOPEN) {
- return 1;
- }
- }
- }
+ const int i1 = fd >> IOINFO_L2E;
+ const int i2 = fd & ((1 << IOINFO_L2E) - 1);
+
+ static int sizeof_ioinfo = 0;
+
+ /* Determine the actual size of the ioinfo structure,
+ * as used by the CRT loaded in memory
+ */
+ if (sizeof_ioinfo == 0 && __pioinfo[0] != NULL) {
+ sizeof_ioinfo = _msize(__pioinfo[0]) / IOINFO_ARRAY_ELTS;
+ }
+ if (sizeof_ioinfo == 0) {
+ /* This should not happen... */
+ goto fail;
+ }
+
+ /* See that it isn't a special CLEAR fileno */
+ if (fd != _NO_CONSOLE_FILENO) {
+ /* Microsoft CRT would check that 0<=fd<_nhandle but we can't do that. Instead
+ * we check pointer validity and other info
+ */
+ if (0 <= i1 && i1 < IOINFO_ARRAYS && __pioinfo[i1] != NULL) {
+ /* finally, check that the file is open */
+ my_ioinfo* info = (my_ioinfo*)(__pioinfo[i1] + i2 * sizeof_ioinfo);
+ if (info->osfile & FOPEN) {
+ return 1;
+ }
+ }
+ }
fail:
- errno = EBADF;
- return 0;
+ errno = EBADF;
+ return 0;
}
/* the special case of checking dup2. The target fd must be in a sensible range */
static int
_PyVerify_fd_dup2(int fd1, int fd2)
{
- if (!_PyVerify_fd(fd1))
- return 0;
- if (fd2 == _NO_CONSOLE_FILENO)
- return 0;
- if ((unsigned)fd2 < _NHANDLE_)
- return 1;
- else
- return 0;
+ if (!_PyVerify_fd(fd1))
+ return 0;
+ if (fd2 == _NO_CONSOLE_FILENO)
+ return 0;
+ if ((unsigned)fd2 < _NHANDLE_)
+ return 1;
+ else
+ return 0;
}
#else
/* dummy version. _PyVerify_fd() is already defined in fileobject.h */
static PyObject *
convertenviron(void)
{
- PyObject *d;
+ PyObject *d;
#ifdef MS_WINDOWS
- wchar_t **e;
+ wchar_t **e;
#else
- char **e;
+ char **e;
+#endif
+#if defined(PYOS_OS2)
+ APIRET rc;
+ char buffer[1024]; /* OS/2 Provides a Documented Max of 1024 Chars */
#endif
- d = PyDict_New();
- if (d == NULL)
- return NULL;
+
+ d = PyDict_New();
+ if (d == NULL)
+ return NULL;
#ifdef WITH_NEXT_FRAMEWORK
- if (environ == NULL)
- environ = *_NSGetEnviron();
+ if (environ == NULL)
+ environ = *_NSGetEnviron();
#endif
#ifdef MS_WINDOWS
- /* _wenviron must be initialized in this way if the program is started
- through main() instead of wmain(). */
- _wgetenv(L"");
- if (_wenviron == NULL)
- return d;
- /* This part ignores errors */
- for (e = _wenviron; *e != NULL; e++) {
- PyObject *k;
- PyObject *v;
- wchar_t *p = wcschr(*e, L'=');
- if (p == NULL)
- continue;
- k = PyUnicode_FromWideChar(*e, (Py_ssize_t)(p-*e));
- if (k == NULL) {
- PyErr_Clear();
- continue;
- }
- v = PyUnicode_FromWideChar(p+1, wcslen(p+1));
- if (v == NULL) {
- PyErr_Clear();
- Py_DECREF(k);
- continue;
- }
- if (PyDict_GetItem(d, k) == NULL) {
- if (PyDict_SetItem(d, k, v) != 0)
- PyErr_Clear();
- }
- Py_DECREF(k);
- Py_DECREF(v);
- }
+ /* _wenviron must be initialized in this way if the program is started
+ through main() instead of wmain(). */
+ _wgetenv(L"");
+ if (_wenviron == NULL)
+ return d;
+ /* This part ignores errors */
+ for (e = _wenviron; *e != NULL; e++) {
+ PyObject *k;
+ PyObject *v;
+ wchar_t *p = wcschr(*e, L'=');
+ if (p == NULL)
+ continue;
+ k = PyUnicode_FromWideChar(*e, (Py_ssize_t)(p-*e));
+ if (k == NULL) {
+ PyErr_Clear();
+ continue;
+ }
+ v = PyUnicode_FromWideChar(p+1, wcslen(p+1));
+ if (v == NULL) {
+ PyErr_Clear();
+ Py_DECREF(k);
+ continue;
+ }
+ if (PyDict_GetItem(d, k) == NULL) {
+ if (PyDict_SetItem(d, k, v) != 0)
+ PyErr_Clear();
+ }
+ Py_DECREF(k);
+ Py_DECREF(v);
+ }
#else
- if (environ == NULL)
- return d;
- /* This part ignores errors */
- for (e = environ; *e != NULL; e++) {
- PyObject *k;
- PyObject *v;
- char *p = strchr(*e, '=');
- if (p == NULL)
- continue;
- k = PyUnicode_Decode(*e, (int)(p-*e),
- Py_FileSystemDefaultEncoding, "surrogateescape");
- if (k == NULL) {
- PyErr_Clear();
- continue;
- }
- v = PyUnicode_Decode(p+1, strlen(p+1),
- Py_FileSystemDefaultEncoding, "surrogateescape");
- if (v == NULL) {
- PyErr_Clear();
- Py_DECREF(k);
- continue;
- }
- if (PyDict_GetItem(d, k) == NULL) {
- if (PyDict_SetItem(d, k, v) != 0)
- PyErr_Clear();
- }
- Py_DECREF(k);
- Py_DECREF(v);
- }
-#endif
-#if defined(PYOS_OS2)
- {
- APIRET rc;
- char buffer[1024]; /* OS/2 Provides a Documented Max of 1024 Chars */
-
- rc = DosQueryExtLIBPATH(buffer, BEGIN_LIBPATH);
- if (rc == NO_ERROR) { /* (not a type, envname is NOT 'BEGIN_LIBPATH') */
- PyObject *v = PyBytes_FromString(buffer);
- PyDict_SetItemString(d, "BEGINLIBPATH", v);
- Py_DECREF(v);
+ if (environ == NULL)
+ return d;
+ /* This part ignores errors */
+ for (e = environ; *e != NULL; e++) {
+ PyObject *k;
+ PyObject *v;
+ char *p = strchr(*e, '=');
+ if (p == NULL)
+ continue;
+ k = PyUnicode_Decode(*e, (int)(p-*e),
+ Py_FileSystemDefaultEncoding, "surrogateescape");
+ if (k == NULL) {
+ PyErr_Clear();
+ continue;
}
- rc = DosQueryExtLIBPATH(buffer, END_LIBPATH);
- if (rc == NO_ERROR) { /* (not a typo, envname is NOT 'END_LIBPATH') */
- PyObject *v = PyBytes_FromString(buffer);
- PyDict_SetItemString(d, "ENDLIBPATH", v);
- Py_DECREF(v);
+ v = PyUnicode_Decode(p+1, strlen(p+1),
+ Py_FileSystemDefaultEncoding, "surrogateescape");
+ if (v == NULL) {
+ PyErr_Clear();
+ Py_DECREF(k);
+ continue;
}
+ if (PyDict_GetItem(d, k) == NULL) {
+ if (PyDict_SetItem(d, k, v) != 0)
+ PyErr_Clear();
+ }
+ Py_DECREF(k);
+ Py_DECREF(v);
+ }
+#endif
+#if defined(PYOS_OS2)
+ rc = DosQueryExtLIBPATH(buffer, BEGIN_LIBPATH);
+ if (rc == NO_ERROR) { /* (not a type, envname is NOT 'BEGIN_LIBPATH') */
+ PyObject *v = PyBytes_FromString(buffer);
+ PyDict_SetItemString(d, "BEGINLIBPATH", v);
+ Py_DECREF(v);
+ }
+ rc = DosQueryExtLIBPATH(buffer, END_LIBPATH);
+ if (rc == NO_ERROR) { /* (not a typo, envname is NOT 'END_LIBPATH') */
+ PyObject *v = PyBytes_FromString(buffer);
+ PyDict_SetItemString(d, "ENDLIBPATH", v);
+ Py_DECREF(v);
}
#endif
- return d;
+ return d;
}
/* Set a POSIX-specific error from errno, and return NULL */
static PyObject *
posix_error(void)
{
- return PyErr_SetFromErrno(PyExc_OSError);
+ return PyErr_SetFromErrno(PyExc_OSError);
}
static PyObject *
posix_error_with_filename(char* name)
{
- return PyErr_SetFromErrnoWithFilename(PyExc_OSError, name);
+ return PyErr_SetFromErrnoWithFilename(PyExc_OSError, name);
}
#ifdef MS_WINDOWS
static PyObject *
posix_error_with_unicode_filename(Py_UNICODE* name)
{
- return PyErr_SetFromErrnoWithUnicodeFilename(PyExc_OSError, name);
+ return PyErr_SetFromErrnoWithUnicodeFilename(PyExc_OSError, name);
}
#endif /* MS_WINDOWS */
static PyObject *
posix_error_with_allocated_filename(PyObject* name)
{
- PyObject *rc = PyErr_SetFromErrnoWithFilename(PyExc_OSError,
- PyBytes_AsString(name));
- Py_DECREF(name);
- return rc;
+ PyObject *rc = PyErr_SetFromErrnoWithFilename(PyExc_OSError,
+ PyBytes_AsString(name));
+ Py_DECREF(name);
+ return rc;
}
#ifdef MS_WINDOWS
static PyObject *
win32_error(char* function, char* filename)
{
- /* XXX We should pass the function name along in the future.
- (winreg.c also wants to pass the function name.)
- This would however require an additional param to the
- Windows error object, which is non-trivial.
- */
- errno = GetLastError();
- if (filename)
- return PyErr_SetFromWindowsErrWithFilename(errno, filename);
- else
- return PyErr_SetFromWindowsErr(errno);
+ /* XXX We should pass the function name along in the future.
+ (winreg.c also wants to pass the function name.)
+ This would however require an additional param to the
+ Windows error object, which is non-trivial.
+ */
+ errno = GetLastError();
+ if (filename)
+ return PyErr_SetFromWindowsErrWithFilename(errno, filename);
+ else
+ return PyErr_SetFromWindowsErr(errno);
}
static PyObject *
win32_error_unicode(char* function, Py_UNICODE* filename)
{
- /* XXX - see win32_error for comments on 'function' */
- errno = GetLastError();
- if (filename)
- return PyErr_SetFromWindowsErrWithUnicodeFilename(errno, filename);
- else
- return PyErr_SetFromWindowsErr(errno);
+ /* XXX - see win32_error for comments on 'function' */
+ errno = GetLastError();
+ if (filename)
+ return PyErr_SetFromWindowsErrWithUnicodeFilename(errno, filename);
+ else
+ return PyErr_SetFromWindowsErr(errno);
}
static int
convert_to_unicode(PyObject **param)
{
- if (PyUnicode_CheckExact(*param))
- Py_INCREF(*param);
- else if (PyUnicode_Check(*param))
- /* For a Unicode subtype that's not a Unicode object,
- return a true Unicode object with the same data. */
- *param = PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(*param),
- PyUnicode_GET_SIZE(*param));
- else
- *param = PyUnicode_FromEncodedObject(*param,
- Py_FileSystemDefaultEncoding,
- "strict");
- return (*param) != NULL;
+ if (PyUnicode_CheckExact(*param))
+ Py_INCREF(*param);
+ else if (PyUnicode_Check(*param))
+ /* For a Unicode subtype that's not a Unicode object,
+ return a true Unicode object with the same data. */
+ *param = PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(*param),
+ PyUnicode_GET_SIZE(*param));
+ else
+ *param = PyUnicode_FromEncodedObject(*param,
+ Py_FileSystemDefaultEncoding,
+ "strict");
+ return (*param) != NULL;
}
#endif /* MS_WINDOWS */
/**********************************************************************
* Helper Function to Trim and Format OS/2 Messages
**********************************************************************/
- static void
+static void
os2_formatmsg(char *msgbuf, int msglen, char *reason)
{
msgbuf[msglen] = '\0'; /* OS/2 Doesn't Guarantee a Terminator */
* the file OSO001.MSG in the \OS2 directory hierarchy.
*
**********************************************************************/
- static char *
+static char *
os2_strerror(char *msgbuf, int msgbuflen, int errorcode, char *reason)
{
APIRET rc;
os2_formatmsg(msgbuf, msglen, reason);
else
PyOS_snprintf(msgbuf, msgbuflen,
- "unknown OS error #%d", errorcode);
+ "unknown OS error #%d", errorcode);
return msgbuf;
}
errors are not in a global variable e.g. 'errno' nor are
they congruent with posix error numbers. */
-static PyObject * os2_error(int code)
+static PyObject *
+os2_error(int code)
{
char text[1024];
PyObject *v;
static PyObject *
posix_fildes(PyObject *fdobj, int (*func)(int))
{
- int fd;
- int res;
- fd = PyObject_AsFileDescriptor(fdobj);
- if (fd < 0)
- return NULL;
- if (!_PyVerify_fd(fd))
- return posix_error();
- Py_BEGIN_ALLOW_THREADS
- res = (*func)(fd);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ int fd;
+ int res;
+ fd = PyObject_AsFileDescriptor(fdobj);
+ if (fd < 0)
+ return NULL;
+ if (!_PyVerify_fd(fd))
+ return posix_error();
+ Py_BEGIN_ALLOW_THREADS
+ res = (*func)(fd);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *
posix_1str(PyObject *args, char *format, int (*func)(const char*))
{
- PyObject *opath1 = NULL;
- char *path1;
- int res;
- if (!PyArg_ParseTuple(args, format,
- PyUnicode_FSConverter, &opath1))
- return NULL;
- path1 = PyBytes_AsString(opath1);
- Py_BEGIN_ALLOW_THREADS
- res = (*func)(path1);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error_with_allocated_filename(opath1);
- Py_DECREF(opath1);
- Py_INCREF(Py_None);
- return Py_None;
+ PyObject *opath1 = NULL;
+ char *path1;
+ int res;
+ if (!PyArg_ParseTuple(args, format,
+ PyUnicode_FSConverter, &opath1))
+ return NULL;
+ path1 = PyBytes_AsString(opath1);
+ Py_BEGIN_ALLOW_THREADS
+ res = (*func)(path1);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error_with_allocated_filename(opath1);
+ Py_DECREF(opath1);
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *
posix_2str(PyObject *args,
- char *format,
- int (*func)(const char *, const char *))
-{
- PyObject *opath1 = NULL, *opath2 = NULL;
- char *path1, *path2;
- int res;
- if (!PyArg_ParseTuple(args, format,
- PyUnicode_FSConverter, &opath1,
- PyUnicode_FSConverter, &opath2)) {
- return NULL;
- }
- path1 = PyBytes_AsString(opath1);
- path2 = PyBytes_AsString(opath2);
- Py_BEGIN_ALLOW_THREADS
- res = (*func)(path1, path2);
- Py_END_ALLOW_THREADS
- Py_DECREF(opath1);
- Py_DECREF(opath2);
- if (res != 0)
- /* XXX how to report both path1 and path2??? */
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ char *format,
+ int (*func)(const char *, const char *))
+{
+ PyObject *opath1 = NULL, *opath2 = NULL;
+ char *path1, *path2;
+ int res;
+ if (!PyArg_ParseTuple(args, format,
+ PyUnicode_FSConverter, &opath1,
+ PyUnicode_FSConverter, &opath2)) {
+ return NULL;
+ }
+ path1 = PyBytes_AsString(opath1);
+ path2 = PyBytes_AsString(opath2);
+ Py_BEGIN_ALLOW_THREADS
+ res = (*func)(path1, path2);
+ Py_END_ALLOW_THREADS
+ Py_DECREF(opath1);
+ Py_DECREF(opath2);
+ if (res != 0)
+ /* XXX how to report both path1 and path2??? */
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#ifdef MS_WINDOWS
static PyObject*
-win32_1str(PyObject* args, char* func,
- char* format, BOOL (__stdcall *funcA)(LPCSTR),
- char* wformat, BOOL (__stdcall *funcW)(LPWSTR))
-{
- PyObject *uni;
- char *ansi;
- BOOL result;
-
- if (!PyArg_ParseTuple(args, wformat, &uni))
- PyErr_Clear();
- else {
- Py_BEGIN_ALLOW_THREADS
- result = funcW(PyUnicode_AsUnicode(uni));
- Py_END_ALLOW_THREADS
- if (!result)
- return win32_error_unicode(func, PyUnicode_AsUnicode(uni));
- Py_INCREF(Py_None);
- return Py_None;
- }
- if (!PyArg_ParseTuple(args, format, &ansi))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- result = funcA(ansi);
- Py_END_ALLOW_THREADS
- if (!result)
- return win32_error(func, ansi);
- Py_INCREF(Py_None);
- return Py_None;
+win32_1str(PyObject* args, char* func,
+ char* format, BOOL (__stdcall *funcA)(LPCSTR),
+ char* wformat, BOOL (__stdcall *funcW)(LPWSTR))
+{
+ PyObject *uni;
+ char *ansi;
+ BOOL result;
+
+ if (!PyArg_ParseTuple(args, wformat, &uni))
+ PyErr_Clear();
+ else {
+ Py_BEGIN_ALLOW_THREADS
+ result = funcW(PyUnicode_AsUnicode(uni));
+ Py_END_ALLOW_THREADS
+ if (!result)
+ return win32_error_unicode(func, PyUnicode_AsUnicode(uni));
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ if (!PyArg_ParseTuple(args, format, &ansi))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ result = funcA(ansi);
+ Py_END_ALLOW_THREADS
+ if (!result)
+ return win32_error(func, ansi);
+ Py_INCREF(Py_None);
+ return Py_None;
}
static BOOL __stdcall
win32_chdir(LPCSTR path)
{
- char new_path[MAX_PATH+1];
- int result;
- char env[4] = "=x:";
-
- if(!SetCurrentDirectoryA(path))
- return FALSE;
- result = GetCurrentDirectoryA(MAX_PATH+1, new_path);
- if (!result)
- return FALSE;
- /* In the ANSI API, there should not be any paths longer
- than MAX_PATH. */
- assert(result <= MAX_PATH+1);
- if (strncmp(new_path, "\\\\", 2) == 0 ||
- strncmp(new_path, "//", 2) == 0)
- /* UNC path, nothing to do. */
- return TRUE;
- env[1] = new_path[0];
- return SetEnvironmentVariableA(env, new_path);
+ char new_path[MAX_PATH+1];
+ int result;
+ char env[4] = "=x:";
+
+ if(!SetCurrentDirectoryA(path))
+ return FALSE;
+ result = GetCurrentDirectoryA(MAX_PATH+1, new_path);
+ if (!result)
+ return FALSE;
+ /* In the ANSI API, there should not be any paths longer
+ than MAX_PATH. */
+ assert(result <= MAX_PATH+1);
+ if (strncmp(new_path, "\\\\", 2) == 0 ||
+ strncmp(new_path, "//", 2) == 0)
+ /* UNC path, nothing to do. */
+ return TRUE;
+ env[1] = new_path[0];
+ return SetEnvironmentVariableA(env, new_path);
}
/* The Unicode version differs from the ANSI version
static BOOL __stdcall
win32_wchdir(LPCWSTR path)
{
- wchar_t _new_path[MAX_PATH+1], *new_path = _new_path;
- int result;
- wchar_t env[4] = L"=x:";
-
- if(!SetCurrentDirectoryW(path))
- return FALSE;
- result = GetCurrentDirectoryW(MAX_PATH+1, new_path);
- if (!result)
- return FALSE;
- if (result > MAX_PATH+1) {
- new_path = malloc(result * sizeof(wchar_t));
- if (!new_path) {
- SetLastError(ERROR_OUTOFMEMORY);
- return FALSE;
- }
- result = GetCurrentDirectoryW(result, new_path);
- if (!result) {
- free(new_path);
- return FALSE;
- }
- }
- if (wcsncmp(new_path, L"\\\\", 2) == 0 ||
- wcsncmp(new_path, L"//", 2) == 0)
- /* UNC path, nothing to do. */
- return TRUE;
- env[1] = new_path[0];
- result = SetEnvironmentVariableW(env, new_path);
- if (new_path != _new_path)
- free(new_path);
- return result;
+ wchar_t _new_path[MAX_PATH+1], *new_path = _new_path;
+ int result;
+ wchar_t env[4] = L"=x:";
+
+ if(!SetCurrentDirectoryW(path))
+ return FALSE;
+ result = GetCurrentDirectoryW(MAX_PATH+1, new_path);
+ if (!result)
+ return FALSE;
+ if (result > MAX_PATH+1) {
+ new_path = malloc(result * sizeof(wchar_t));
+ if (!new_path) {
+ SetLastError(ERROR_OUTOFMEMORY);
+ return FALSE;
+ }
+ result = GetCurrentDirectoryW(result, new_path);
+ if (!result) {
+ free(new_path);
+ return FALSE;
+ }
+ }
+ if (wcsncmp(new_path, L"\\\\", 2) == 0 ||
+ wcsncmp(new_path, L"//", 2) == 0)
+ /* UNC path, nothing to do. */
+ return TRUE;
+ env[1] = new_path[0];
+ result = SetEnvironmentVariableW(env, new_path);
+ if (new_path != _new_path)
+ free(new_path);
+ return result;
}
#endif
UTC and local time
Therefore, we implement our own stat, based on the Win32 API directly.
*/
-#define HAVE_STAT_NSEC 1
+#define HAVE_STAT_NSEC 1
struct win32_stat{
int st_dev;
static void
FILE_TIME_to_time_t_nsec(FILETIME *in_ptr, int *time_out, int* nsec_out)
{
- /* XXX endianness. Shouldn't matter, as all Windows implementations are little-endian */
- /* Cannot simply cast and dereference in_ptr,
- since it might not be aligned properly */
- __int64 in;
- memcpy(&in, in_ptr, sizeof(in));
- *nsec_out = (int)(in % 10000000) * 100; /* FILETIME is in units of 100 nsec. */
- /* XXX Win32 supports time stamps past 2038; we currently don't */
- *time_out = Py_SAFE_DOWNCAST((in / 10000000) - secs_between_epochs, __int64, int);
+ /* XXX endianness. Shouldn't matter, as all Windows implementations are little-endian */
+ /* Cannot simply cast and dereference in_ptr,
+ since it might not be aligned properly */
+ __int64 in;
+ memcpy(&in, in_ptr, sizeof(in));
+ *nsec_out = (int)(in % 10000000) * 100; /* FILETIME is in units of 100 nsec. */
+ /* XXX Win32 supports time stamps past 2038; we currently don't */
+ *time_out = Py_SAFE_DOWNCAST((in / 10000000) - secs_between_epochs, __int64, int);
}
static void
time_t_to_FILE_TIME(int time_in, int nsec_in, FILETIME *out_ptr)
{
- /* XXX endianness */
- __int64 out;
- out = time_in + secs_between_epochs;
- out = out * 10000000 + nsec_in / 100;
- memcpy(out_ptr, &out, sizeof(out));
+ /* XXX endianness */
+ __int64 out;
+ out = time_in + secs_between_epochs;
+ out = out * 10000000 + nsec_in / 100;
+ memcpy(out_ptr, &out, sizeof(out));
}
/* Below, we *know* that ugo+r is 0444 */
static int
attributes_to_mode(DWORD attr)
{
- int m = 0;
- if (attr & FILE_ATTRIBUTE_DIRECTORY)
- m |= _S_IFDIR | 0111; /* IFEXEC for user,group,other */
- else
- m |= _S_IFREG;
- if (attr & FILE_ATTRIBUTE_READONLY)
- m |= 0444;
- else
- m |= 0666;
- return m;
+ int m = 0;
+ if (attr & FILE_ATTRIBUTE_DIRECTORY)
+ m |= _S_IFDIR | 0111; /* IFEXEC for user,group,other */
+ else
+ m |= _S_IFREG;
+ if (attr & FILE_ATTRIBUTE_READONLY)
+ m |= 0444;
+ else
+ m |= 0666;
+ return m;
}
static int
attribute_data_to_stat(WIN32_FILE_ATTRIBUTE_DATA *info, struct win32_stat *result)
{
- memset(result, 0, sizeof(*result));
- result->st_mode = attributes_to_mode(info->dwFileAttributes);
- result->st_size = (((__int64)info->nFileSizeHigh)<<32) + info->nFileSizeLow;
- FILE_TIME_to_time_t_nsec(&info->ftCreationTime, &result->st_ctime, &result->st_ctime_nsec);
- FILE_TIME_to_time_t_nsec(&info->ftLastWriteTime, &result->st_mtime, &result->st_mtime_nsec);
- FILE_TIME_to_time_t_nsec(&info->ftLastAccessTime, &result->st_atime, &result->st_atime_nsec);
+ memset(result, 0, sizeof(*result));
+ result->st_mode = attributes_to_mode(info->dwFileAttributes);
+ result->st_size = (((__int64)info->nFileSizeHigh)<<32) + info->nFileSizeLow;
+ FILE_TIME_to_time_t_nsec(&info->ftCreationTime, &result->st_ctime, &result->st_ctime_nsec);
+ FILE_TIME_to_time_t_nsec(&info->ftLastWriteTime, &result->st_mtime, &result->st_mtime_nsec);
+ FILE_TIME_to_time_t_nsec(&info->ftLastAccessTime, &result->st_atime, &result->st_atime_nsec);
- return 0;
+ return 0;
}
static BOOL
attributes_from_dir(LPCSTR pszFile, LPWIN32_FILE_ATTRIBUTE_DATA pfad)
{
- HANDLE hFindFile;
- WIN32_FIND_DATAA FileData;
- hFindFile = FindFirstFileA(pszFile, &FileData);
- if (hFindFile == INVALID_HANDLE_VALUE)
- return FALSE;
- FindClose(hFindFile);
- pfad->dwFileAttributes = FileData.dwFileAttributes;
- pfad->ftCreationTime = FileData.ftCreationTime;
- pfad->ftLastAccessTime = FileData.ftLastAccessTime;
- pfad->ftLastWriteTime = FileData.ftLastWriteTime;
- pfad->nFileSizeHigh = FileData.nFileSizeHigh;
- pfad->nFileSizeLow = FileData.nFileSizeLow;
- return TRUE;
+ HANDLE hFindFile;
+ WIN32_FIND_DATAA FileData;
+ hFindFile = FindFirstFileA(pszFile, &FileData);
+ if (hFindFile == INVALID_HANDLE_VALUE)
+ return FALSE;
+ FindClose(hFindFile);
+ pfad->dwFileAttributes = FileData.dwFileAttributes;
+ pfad->ftCreationTime = FileData.ftCreationTime;
+ pfad->ftLastAccessTime = FileData.ftLastAccessTime;
+ pfad->ftLastWriteTime = FileData.ftLastWriteTime;
+ pfad->nFileSizeHigh = FileData.nFileSizeHigh;
+ pfad->nFileSizeLow = FileData.nFileSizeLow;
+ return TRUE;
}
static BOOL
attributes_from_dir_w(LPCWSTR pszFile, LPWIN32_FILE_ATTRIBUTE_DATA pfad)
{
- HANDLE hFindFile;
- WIN32_FIND_DATAW FileData;
- hFindFile = FindFirstFileW(pszFile, &FileData);
- if (hFindFile == INVALID_HANDLE_VALUE)
- return FALSE;
- FindClose(hFindFile);
- pfad->dwFileAttributes = FileData.dwFileAttributes;
- pfad->ftCreationTime = FileData.ftCreationTime;
- pfad->ftLastAccessTime = FileData.ftLastAccessTime;
- pfad->ftLastWriteTime = FileData.ftLastWriteTime;
- pfad->nFileSizeHigh = FileData.nFileSizeHigh;
- pfad->nFileSizeLow = FileData.nFileSizeLow;
- return TRUE;
-}
-
-static int
+ HANDLE hFindFile;
+ WIN32_FIND_DATAW FileData;
+ hFindFile = FindFirstFileW(pszFile, &FileData);
+ if (hFindFile == INVALID_HANDLE_VALUE)
+ return FALSE;
+ FindClose(hFindFile);
+ pfad->dwFileAttributes = FileData.dwFileAttributes;
+ pfad->ftCreationTime = FileData.ftCreationTime;
+ pfad->ftLastAccessTime = FileData.ftLastAccessTime;
+ pfad->ftLastWriteTime = FileData.ftLastWriteTime;
+ pfad->nFileSizeHigh = FileData.nFileSizeHigh;
+ pfad->nFileSizeLow = FileData.nFileSizeLow;
+ return TRUE;
+}
+
+static int
win32_stat(const char* path, struct win32_stat *result)
{
- WIN32_FILE_ATTRIBUTE_DATA info;
- int code;
- char *dot;
- if (!GetFileAttributesExA(path, GetFileExInfoStandard, &info)) {
- if (GetLastError() != ERROR_SHARING_VIOLATION) {
- /* Protocol violation: we explicitly clear errno, instead of
- setting it to a POSIX error. Callers should use GetLastError. */
- errno = 0;
- return -1;
- } else {
- /* Could not get attributes on open file. Fall back to
- reading the directory. */
- if (!attributes_from_dir(path, &info)) {
- /* Very strange. This should not fail now */
- errno = 0;
- return -1;
- }
- }
- }
- code = attribute_data_to_stat(&info, result);
- if (code != 0)
- return code;
- /* Set S_IFEXEC if it is an .exe, .bat, ... */
- dot = strrchr(path, '.');
- if (dot) {
- if (stricmp(dot, ".bat") == 0 ||
- stricmp(dot, ".cmd") == 0 ||
- stricmp(dot, ".exe") == 0 ||
- stricmp(dot, ".com") == 0)
- result->st_mode |= 0111;
- }
- return code;
-}
-
-static int
+ WIN32_FILE_ATTRIBUTE_DATA info;
+ int code;
+ char *dot;
+ if (!GetFileAttributesExA(path, GetFileExInfoStandard, &info)) {
+ if (GetLastError() != ERROR_SHARING_VIOLATION) {
+ /* Protocol violation: we explicitly clear errno, instead of
+ setting it to a POSIX error. Callers should use GetLastError. */
+ errno = 0;
+ return -1;
+ } else {
+ /* Could not get attributes on open file. Fall back to
+ reading the directory. */
+ if (!attributes_from_dir(path, &info)) {
+ /* Very strange. This should not fail now */
+ errno = 0;
+ return -1;
+ }
+ }
+ }
+ code = attribute_data_to_stat(&info, result);
+ if (code != 0)
+ return code;
+ /* Set S_IFEXEC if it is an .exe, .bat, ... */
+ dot = strrchr(path, '.');
+ if (dot) {
+ if (stricmp(dot, ".bat") == 0 ||
+ stricmp(dot, ".cmd") == 0 ||
+ stricmp(dot, ".exe") == 0 ||
+ stricmp(dot, ".com") == 0)
+ result->st_mode |= 0111;
+ }
+ return code;
+}
+
+static int
win32_wstat(const wchar_t* path, struct win32_stat *result)
{
- int code;
- const wchar_t *dot;
- WIN32_FILE_ATTRIBUTE_DATA info;
- if (!GetFileAttributesExW(path, GetFileExInfoStandard, &info)) {
- if (GetLastError() != ERROR_SHARING_VIOLATION) {
- /* Protocol violation: we explicitly clear errno, instead of
- setting it to a POSIX error. Callers should use GetLastError. */
- errno = 0;
- return -1;
- } else {
- /* Could not get attributes on open file. Fall back to
- reading the directory. */
- if (!attributes_from_dir_w(path, &info)) {
- /* Very strange. This should not fail now */
- errno = 0;
- return -1;
- }
- }
- }
- code = attribute_data_to_stat(&info, result);
- if (code < 0)
- return code;
- /* Set IFEXEC if it is an .exe, .bat, ... */
- dot = wcsrchr(path, '.');
- if (dot) {
- if (_wcsicmp(dot, L".bat") == 0 ||
- _wcsicmp(dot, L".cmd") == 0 ||
- _wcsicmp(dot, L".exe") == 0 ||
- _wcsicmp(dot, L".com") == 0)
- result->st_mode |= 0111;
- }
- return code;
+ int code;
+ const wchar_t *dot;
+ WIN32_FILE_ATTRIBUTE_DATA info;
+ if (!GetFileAttributesExW(path, GetFileExInfoStandard, &info)) {
+ if (GetLastError() != ERROR_SHARING_VIOLATION) {
+ /* Protocol violation: we explicitly clear errno, instead of
+ setting it to a POSIX error. Callers should use GetLastError. */
+ errno = 0;
+ return -1;
+ } else {
+ /* Could not get attributes on open file. Fall back to
+ reading the directory. */
+ if (!attributes_from_dir_w(path, &info)) {
+ /* Very strange. This should not fail now */
+ errno = 0;
+ return -1;
+ }
+ }
+ }
+ code = attribute_data_to_stat(&info, result);
+ if (code < 0)
+ return code;
+ /* Set IFEXEC if it is an .exe, .bat, ... */
+ dot = wcsrchr(path, '.');
+ if (dot) {
+ if (_wcsicmp(dot, L".bat") == 0 ||
+ _wcsicmp(dot, L".cmd") == 0 ||
+ _wcsicmp(dot, L".exe") == 0 ||
+ _wcsicmp(dot, L".com") == 0)
+ result->st_mode |= 0111;
+ }
+ return code;
}
static int
win32_fstat(int file_number, struct win32_stat *result)
{
- BY_HANDLE_FILE_INFORMATION info;
- HANDLE h;
- int type;
-
- h = (HANDLE)_get_osfhandle(file_number);
-
- /* Protocol violation: we explicitly clear errno, instead of
- setting it to a POSIX error. Callers should use GetLastError. */
- errno = 0;
-
- if (h == INVALID_HANDLE_VALUE) {
- /* This is really a C library error (invalid file handle).
- We set the Win32 error to the closes one matching. */
- SetLastError(ERROR_INVALID_HANDLE);
- return -1;
- }
- memset(result, 0, sizeof(*result));
-
- type = GetFileType(h);
- if (type == FILE_TYPE_UNKNOWN) {
- DWORD error = GetLastError();
- if (error != 0) {
- return -1;
- }
- /* else: valid but unknown file */
- }
-
- if (type != FILE_TYPE_DISK) {
- if (type == FILE_TYPE_CHAR)
- result->st_mode = _S_IFCHR;
- else if (type == FILE_TYPE_PIPE)
- result->st_mode = _S_IFIFO;
- return 0;
- }
-
- if (!GetFileInformationByHandle(h, &info)) {
- return -1;
- }
-
- /* similar to stat() */
- result->st_mode = attributes_to_mode(info.dwFileAttributes);
- result->st_size = (((__int64)info.nFileSizeHigh)<<32) + info.nFileSizeLow;
- FILE_TIME_to_time_t_nsec(&info.ftCreationTime, &result->st_ctime, &result->st_ctime_nsec);
- FILE_TIME_to_time_t_nsec(&info.ftLastWriteTime, &result->st_mtime, &result->st_mtime_nsec);
- FILE_TIME_to_time_t_nsec(&info.ftLastAccessTime, &result->st_atime, &result->st_atime_nsec);
- /* specific to fstat() */
- result->st_nlink = info.nNumberOfLinks;
- result->st_ino = (((__int64)info.nFileIndexHigh)<<32) + info.nFileIndexLow;
- return 0;
+ BY_HANDLE_FILE_INFORMATION info;
+ HANDLE h;
+ int type;
+
+ h = (HANDLE)_get_osfhandle(file_number);
+
+ /* Protocol violation: we explicitly clear errno, instead of
+ setting it to a POSIX error. Callers should use GetLastError. */
+ errno = 0;
+
+ if (h == INVALID_HANDLE_VALUE) {
+ /* This is really a C library error (invalid file handle).
+ We set the Win32 error to the closes one matching. */
+ SetLastError(ERROR_INVALID_HANDLE);
+ return -1;
+ }
+ memset(result, 0, sizeof(*result));
+
+ type = GetFileType(h);
+ if (type == FILE_TYPE_UNKNOWN) {
+ DWORD error = GetLastError();
+ if (error != 0) {
+ return -1;
+ }
+ /* else: valid but unknown file */
+ }
+
+ if (type != FILE_TYPE_DISK) {
+ if (type == FILE_TYPE_CHAR)
+ result->st_mode = _S_IFCHR;
+ else if (type == FILE_TYPE_PIPE)
+ result->st_mode = _S_IFIFO;
+ return 0;
+ }
+
+ if (!GetFileInformationByHandle(h, &info)) {
+ return -1;
+ }
+
+ /* similar to stat() */
+ result->st_mode = attributes_to_mode(info.dwFileAttributes);
+ result->st_size = (((__int64)info.nFileSizeHigh)<<32) + info.nFileSizeLow;
+ FILE_TIME_to_time_t_nsec(&info.ftCreationTime, &result->st_ctime, &result->st_ctime_nsec);
+ FILE_TIME_to_time_t_nsec(&info.ftLastWriteTime, &result->st_mtime, &result->st_mtime_nsec);
+ FILE_TIME_to_time_t_nsec(&info.ftLastAccessTime, &result->st_atime, &result->st_atime_nsec);
+ /* specific to fstat() */
+ result->st_nlink = info.nNumberOfLinks;
+ result->st_ino = (((__int64)info.nFileIndexHigh)<<32) + info.nFileIndexLow;
+ return 0;
}
#endif /* MS_WINDOWS */
See os.stat for more information.");
static PyStructSequence_Field stat_result_fields[] = {
- {"st_mode", "protection bits"},
- {"st_ino", "inode"},
- {"st_dev", "device"},
- {"st_nlink", "number of hard links"},
- {"st_uid", "user ID of owner"},
- {"st_gid", "group ID of owner"},
- {"st_size", "total size, in bytes"},
- /* The NULL is replaced with PyStructSequence_UnnamedField later. */
- {NULL, "integer time of last access"},
- {NULL, "integer time of last modification"},
- {NULL, "integer time of last change"},
- {"st_atime", "time of last access"},
- {"st_mtime", "time of last modification"},
- {"st_ctime", "time of last change"},
+ {"st_mode", "protection bits"},
+ {"st_ino", "inode"},
+ {"st_dev", "device"},
+ {"st_nlink", "number of hard links"},
+ {"st_uid", "user ID of owner"},
+ {"st_gid", "group ID of owner"},
+ {"st_size", "total size, in bytes"},
+ /* The NULL is replaced with PyStructSequence_UnnamedField later. */
+ {NULL, "integer time of last access"},
+ {NULL, "integer time of last modification"},
+ {NULL, "integer time of last change"},
+ {"st_atime", "time of last access"},
+ {"st_mtime", "time of last modification"},
+ {"st_ctime", "time of last change"},
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
- {"st_blksize", "blocksize for filesystem I/O"},
+ {"st_blksize", "blocksize for filesystem I/O"},
#endif
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
- {"st_blocks", "number of blocks allocated"},
+ {"st_blocks", "number of blocks allocated"},
#endif
#ifdef HAVE_STRUCT_STAT_ST_RDEV
- {"st_rdev", "device type (if inode device)"},
+ {"st_rdev", "device type (if inode device)"},
#endif
#ifdef HAVE_STRUCT_STAT_ST_FLAGS
- {"st_flags", "user defined flags for file"},
+ {"st_flags", "user defined flags for file"},
#endif
#ifdef HAVE_STRUCT_STAT_ST_GEN
- {"st_gen", "generation number"},
+ {"st_gen", "generation number"},
#endif
#ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
- {"st_birthtime", "time of creation"},
+ {"st_birthtime", "time of creation"},
#endif
- {0}
+ {0}
};
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
#endif
static PyStructSequence_Desc stat_result_desc = {
- "stat_result", /* name */
- stat_result__doc__, /* doc */
- stat_result_fields,
- 10
+ "stat_result", /* name */
+ stat_result__doc__, /* doc */
+ stat_result_fields,
+ 10
};
PyDoc_STRVAR(statvfs_result__doc__,
See os.statvfs for more information.");
static PyStructSequence_Field statvfs_result_fields[] = {
- {"f_bsize", },
- {"f_frsize", },
- {"f_blocks", },
- {"f_bfree", },
- {"f_bavail", },
- {"f_files", },
- {"f_ffree", },
- {"f_favail", },
- {"f_flag", },
- {"f_namemax",},
- {0}
+ {"f_bsize", },
+ {"f_frsize", },
+ {"f_blocks", },
+ {"f_bfree", },
+ {"f_bavail", },
+ {"f_files", },
+ {"f_ffree", },
+ {"f_favail", },
+ {"f_flag", },
+ {"f_namemax",},
+ {0}
};
static PyStructSequence_Desc statvfs_result_desc = {
- "statvfs_result", /* name */
- statvfs_result__doc__, /* doc */
- statvfs_result_fields,
- 10
+ "statvfs_result", /* name */
+ statvfs_result__doc__, /* doc */
+ statvfs_result_fields,
+ 10
};
static int initialized;
static PyObject *
statresult_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- PyStructSequence *result;
- int i;
+ PyStructSequence *result;
+ int i;
- result = (PyStructSequence*)structseq_new(type, args, kwds);
- if (!result)
- return NULL;
- /* If we have been initialized from a tuple,
- st_?time might be set to None. Initialize it
- from the int slots. */
- for (i = 7; i <= 9; i++) {
- if (result->ob_item[i+3] == Py_None) {
- Py_DECREF(Py_None);
- Py_INCREF(result->ob_item[i]);
- result->ob_item[i+3] = result->ob_item[i];
- }
- }
- return (PyObject*)result;
+ result = (PyStructSequence*)structseq_new(type, args, kwds);
+ if (!result)
+ return NULL;
+ /* If we have been initialized from a tuple,
+ st_?time might be set to None. Initialize it
+ from the int slots. */
+ for (i = 7; i <= 9; i++) {
+ if (result->ob_item[i+3] == Py_None) {
+ Py_DECREF(Py_None);
+ Py_INCREF(result->ob_item[i]);
+ result->ob_item[i+3] = result->ob_item[i];
+ }
+ }
+ return (PyObject*)result;
}
static PyObject*
stat_float_times(PyObject* self, PyObject *args)
{
- int newval = -1;
- if (!PyArg_ParseTuple(args, "|i:stat_float_times", &newval))
- return NULL;
- if (newval == -1)
- /* Return old value */
- return PyBool_FromLong(_stat_float_times);
- _stat_float_times = newval;
- Py_INCREF(Py_None);
- return Py_None;
+ int newval = -1;
+ if (!PyArg_ParseTuple(args, "|i:stat_float_times", &newval))
+ return NULL;
+ if (newval == -1)
+ /* Return old value */
+ return PyBool_FromLong(_stat_float_times);
+ _stat_float_times = newval;
+ Py_INCREF(Py_None);
+ return Py_None;
}
static void
fill_time(PyObject *v, int index, time_t sec, unsigned long nsec)
{
- PyObject *fval,*ival;
+ PyObject *fval,*ival;
#if SIZEOF_TIME_T > SIZEOF_LONG
- ival = PyLong_FromLongLong((PY_LONG_LONG)sec);
+ ival = PyLong_FromLongLong((PY_LONG_LONG)sec);
#else
- ival = PyLong_FromLong((long)sec);
+ ival = PyLong_FromLong((long)sec);
#endif
- if (!ival)
- return;
- if (_stat_float_times) {
- fval = PyFloat_FromDouble(sec + 1e-9*nsec);
- } else {
- fval = ival;
- Py_INCREF(fval);
- }
- PyStructSequence_SET_ITEM(v, index, ival);
- PyStructSequence_SET_ITEM(v, index+3, fval);
+ if (!ival)
+ return;
+ if (_stat_float_times) {
+ fval = PyFloat_FromDouble(sec + 1e-9*nsec);
+ } else {
+ fval = ival;
+ Py_INCREF(fval);
+ }
+ PyStructSequence_SET_ITEM(v, index, ival);
+ PyStructSequence_SET_ITEM(v, index+3, fval);
}
/* pack a system stat C structure into the Python stat tuple
static PyObject*
_pystat_fromstructstat(STRUCT_STAT *st)
{
- unsigned long ansec, mnsec, cnsec;
- PyObject *v = PyStructSequence_New(&StatResultType);
- if (v == NULL)
- return NULL;
+ unsigned long ansec, mnsec, cnsec;
+ PyObject *v = PyStructSequence_New(&StatResultType);
+ if (v == NULL)
+ return NULL;
- PyStructSequence_SET_ITEM(v, 0, PyLong_FromLong((long)st->st_mode));
+ PyStructSequence_SET_ITEM(v, 0, PyLong_FromLong((long)st->st_mode));
#ifdef HAVE_LARGEFILE_SUPPORT
- PyStructSequence_SET_ITEM(v, 1,
- PyLong_FromLongLong((PY_LONG_LONG)st->st_ino));
+ PyStructSequence_SET_ITEM(v, 1,
+ PyLong_FromLongLong((PY_LONG_LONG)st->st_ino));
#else
- PyStructSequence_SET_ITEM(v, 1, PyLong_FromLong((long)st->st_ino));
+ PyStructSequence_SET_ITEM(v, 1, PyLong_FromLong((long)st->st_ino));
#endif
#if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS)
- PyStructSequence_SET_ITEM(v, 2,
- PyLong_FromLongLong((PY_LONG_LONG)st->st_dev));
+ PyStructSequence_SET_ITEM(v, 2,
+ PyLong_FromLongLong((PY_LONG_LONG)st->st_dev));
#else
- PyStructSequence_SET_ITEM(v, 2, PyLong_FromLong((long)st->st_dev));
+ PyStructSequence_SET_ITEM(v, 2, PyLong_FromLong((long)st->st_dev));
#endif
- PyStructSequence_SET_ITEM(v, 3, PyLong_FromLong((long)st->st_nlink));
- PyStructSequence_SET_ITEM(v, 4, PyLong_FromLong((long)st->st_uid));
- PyStructSequence_SET_ITEM(v, 5, PyLong_FromLong((long)st->st_gid));
+ PyStructSequence_SET_ITEM(v, 3, PyLong_FromLong((long)st->st_nlink));
+ PyStructSequence_SET_ITEM(v, 4, PyLong_FromLong((long)st->st_uid));
+ PyStructSequence_SET_ITEM(v, 5, PyLong_FromLong((long)st->st_gid));
#ifdef HAVE_LARGEFILE_SUPPORT
- PyStructSequence_SET_ITEM(v, 6,
- PyLong_FromLongLong((PY_LONG_LONG)st->st_size));
+ PyStructSequence_SET_ITEM(v, 6,
+ PyLong_FromLongLong((PY_LONG_LONG)st->st_size));
#else
- PyStructSequence_SET_ITEM(v, 6, PyLong_FromLong(st->st_size));
+ PyStructSequence_SET_ITEM(v, 6, PyLong_FromLong(st->st_size));
#endif
#if defined(HAVE_STAT_TV_NSEC)
- ansec = st->st_atim.tv_nsec;
- mnsec = st->st_mtim.tv_nsec;
- cnsec = st->st_ctim.tv_nsec;
+ ansec = st->st_atim.tv_nsec;
+ mnsec = st->st_mtim.tv_nsec;
+ cnsec = st->st_ctim.tv_nsec;
#elif defined(HAVE_STAT_TV_NSEC2)
- ansec = st->st_atimespec.tv_nsec;
- mnsec = st->st_mtimespec.tv_nsec;
- cnsec = st->st_ctimespec.tv_nsec;
+ ansec = st->st_atimespec.tv_nsec;
+ mnsec = st->st_mtimespec.tv_nsec;
+ cnsec = st->st_ctimespec.tv_nsec;
#elif defined(HAVE_STAT_NSEC)
- ansec = st->st_atime_nsec;
- mnsec = st->st_mtime_nsec;
- cnsec = st->st_ctime_nsec;
+ ansec = st->st_atime_nsec;
+ mnsec = st->st_mtime_nsec;
+ cnsec = st->st_ctime_nsec;
#else
- ansec = mnsec = cnsec = 0;
+ ansec = mnsec = cnsec = 0;
#endif
- fill_time(v, 7, st->st_atime, ansec);
- fill_time(v, 8, st->st_mtime, mnsec);
- fill_time(v, 9, st->st_ctime, cnsec);
+ fill_time(v, 7, st->st_atime, ansec);
+ fill_time(v, 8, st->st_mtime, mnsec);
+ fill_time(v, 9, st->st_ctime, cnsec);
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
- PyStructSequence_SET_ITEM(v, ST_BLKSIZE_IDX,
- PyLong_FromLong((long)st->st_blksize));
+ PyStructSequence_SET_ITEM(v, ST_BLKSIZE_IDX,
+ PyLong_FromLong((long)st->st_blksize));
#endif
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
- PyStructSequence_SET_ITEM(v, ST_BLOCKS_IDX,
- PyLong_FromLong((long)st->st_blocks));
+ PyStructSequence_SET_ITEM(v, ST_BLOCKS_IDX,
+ PyLong_FromLong((long)st->st_blocks));
#endif
#ifdef HAVE_STRUCT_STAT_ST_RDEV
- PyStructSequence_SET_ITEM(v, ST_RDEV_IDX,
- PyLong_FromLong((long)st->st_rdev));
+ PyStructSequence_SET_ITEM(v, ST_RDEV_IDX,
+ PyLong_FromLong((long)st->st_rdev));
#endif
#ifdef HAVE_STRUCT_STAT_ST_GEN
- PyStructSequence_SET_ITEM(v, ST_GEN_IDX,
- PyLong_FromLong((long)st->st_gen));
+ PyStructSequence_SET_ITEM(v, ST_GEN_IDX,
+ PyLong_FromLong((long)st->st_gen));
#endif
#ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
- {
- PyObject *val;
- unsigned long bsec,bnsec;
- bsec = (long)st->st_birthtime;
+ {
+ PyObject *val;
+ unsigned long bsec,bnsec;
+ bsec = (long)st->st_birthtime;
#ifdef HAVE_STAT_TV_NSEC2
- bnsec = st->st_birthtimespec.tv_nsec;
+ bnsec = st->st_birthtimespec.tv_nsec;
#else
- bnsec = 0;
-#endif
- if (_stat_float_times) {
- val = PyFloat_FromDouble(bsec + 1e-9*bnsec);
- } else {
- val = PyLong_FromLong((long)bsec);
- }
- PyStructSequence_SET_ITEM(v, ST_BIRTHTIME_IDX,
- val);
- }
+ bnsec = 0;
+#endif
+ if (_stat_float_times) {
+ val = PyFloat_FromDouble(bsec + 1e-9*bnsec);
+ } else {
+ val = PyLong_FromLong((long)bsec);
+ }
+ PyStructSequence_SET_ITEM(v, ST_BIRTHTIME_IDX,
+ val);
+ }
#endif
#ifdef HAVE_STRUCT_STAT_ST_FLAGS
- PyStructSequence_SET_ITEM(v, ST_FLAGS_IDX,
- PyLong_FromLong((long)st->st_flags));
+ PyStructSequence_SET_ITEM(v, ST_FLAGS_IDX,
+ PyLong_FromLong((long)st->st_flags));
#endif
- if (PyErr_Occurred()) {
- Py_DECREF(v);
- return NULL;
- }
+ if (PyErr_Occurred()) {
+ Py_DECREF(v);
+ return NULL;
+ }
- return v;
+ return v;
}
#ifdef MS_WINDOWS
static BOOL
IsUNCRootA(char *path, int pathlen)
{
- #define ISSLASH ISSLASHA
+ #define ISSLASH ISSLASHA
- int i, share;
+ int i, share;
- if (pathlen < 5 || !ISSLASH(path[0]) || !ISSLASH(path[1]))
- /* minimum UNCRoot is \\x\y */
- return FALSE;
- for (i = 2; i < pathlen ; i++)
- if (ISSLASH(path[i])) break;
- if (i == 2 || i == pathlen)
- /* do not allow \\\SHARE or \\SERVER */
- return FALSE;
- share = i+1;
- for (i = share; i < pathlen; i++)
- if (ISSLASH(path[i])) break;
- return (i != share && (i == pathlen || i == pathlen-1));
+ if (pathlen < 5 || !ISSLASH(path[0]) || !ISSLASH(path[1]))
+ /* minimum UNCRoot is \\x\y */
+ return FALSE;
+ for (i = 2; i < pathlen ; i++)
+ if (ISSLASH(path[i])) break;
+ if (i == 2 || i == pathlen)
+ /* do not allow \\\SHARE or \\SERVER */
+ return FALSE;
+ share = i+1;
+ for (i = share; i < pathlen; i++)
+ if (ISSLASH(path[i])) break;
+ return (i != share && (i == pathlen || i == pathlen-1));
- #undef ISSLASH
+ #undef ISSLASH
}
static BOOL
IsUNCRootW(Py_UNICODE *path, int pathlen)
{
- #define ISSLASH ISSLASHW
+ #define ISSLASH ISSLASHW
- int i, share;
+ int i, share;
- if (pathlen < 5 || !ISSLASH(path[0]) || !ISSLASH(path[1]))
- /* minimum UNCRoot is \\x\y */
- return FALSE;
- for (i = 2; i < pathlen ; i++)
- if (ISSLASH(path[i])) break;
- if (i == 2 || i == pathlen)
- /* do not allow \\\SHARE or \\SERVER */
- return FALSE;
- share = i+1;
- for (i = share; i < pathlen; i++)
- if (ISSLASH(path[i])) break;
- return (i != share && (i == pathlen || i == pathlen-1));
+ if (pathlen < 5 || !ISSLASH(path[0]) || !ISSLASH(path[1]))
+ /* minimum UNCRoot is \\x\y */
+ return FALSE;
+ for (i = 2; i < pathlen ; i++)
+ if (ISSLASH(path[i])) break;
+ if (i == 2 || i == pathlen)
+ /* do not allow \\\SHARE or \\SERVER */
+ return FALSE;
+ share = i+1;
+ for (i = share; i < pathlen; i++)
+ if (ISSLASH(path[i])) break;
+ return (i != share && (i == pathlen || i == pathlen-1));
- #undef ISSLASH
+ #undef ISSLASH
}
#endif /* MS_WINDOWS */
static PyObject *
posix_do_stat(PyObject *self, PyObject *args,
- char *format,
+ char *format,
#ifdef __VMS
- int (*statfunc)(const char *, STRUCT_STAT *, ...),
+ int (*statfunc)(const char *, STRUCT_STAT *, ...),
#else
- int (*statfunc)(const char *, STRUCT_STAT *),
+ int (*statfunc)(const char *, STRUCT_STAT *),
#endif
- char *wformat,
- int (*wstatfunc)(const Py_UNICODE *, STRUCT_STAT *))
+ char *wformat,
+ int (*wstatfunc)(const Py_UNICODE *, STRUCT_STAT *))
{
- STRUCT_STAT st;
- PyObject *opath;
- char *path;
- int res;
- PyObject *result;
+ STRUCT_STAT st;
+ PyObject *opath;
+ char *path;
+ int res;
+ PyObject *result;
#ifdef MS_WINDOWS
- PyUnicodeObject *po;
- if (PyArg_ParseTuple(args, wformat, &po)) {
- Py_UNICODE *wpath = PyUnicode_AS_UNICODE(po);
-
- Py_BEGIN_ALLOW_THREADS
- /* PyUnicode_AS_UNICODE result OK without
- thread lock as it is a simple dereference. */
- res = wstatfunc(wpath, &st);
- Py_END_ALLOW_THREADS
-
- if (res != 0)
- return win32_error_unicode("stat", wpath);
- return _pystat_fromstructstat(&st);
- }
- /* Drop the argument parsing error as narrow strings
- are also valid. */
- PyErr_Clear();
-#endif
-
- if (!PyArg_ParseTuple(args, format,
- PyUnicode_FSConverter, &opath))
- return NULL;
- path = PyBytes_AsString(opath);
- Py_BEGIN_ALLOW_THREADS
- res = (*statfunc)(path, &st);
- Py_END_ALLOW_THREADS
-
- if (res != 0) {
+ PyUnicodeObject *po;
+ if (PyArg_ParseTuple(args, wformat, &po)) {
+ Py_UNICODE *wpath = PyUnicode_AS_UNICODE(po);
+
+ Py_BEGIN_ALLOW_THREADS
+ /* PyUnicode_AS_UNICODE result OK without
+ thread lock as it is a simple dereference. */
+ res = wstatfunc(wpath, &st);
+ Py_END_ALLOW_THREADS
+
+ if (res != 0)
+ return win32_error_unicode("stat", wpath);
+ return _pystat_fromstructstat(&st);
+ }
+ /* Drop the argument parsing error as narrow strings
+ are also valid. */
+ PyErr_Clear();
+#endif
+
+ if (!PyArg_ParseTuple(args, format,
+ PyUnicode_FSConverter, &opath))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ Py_BEGIN_ALLOW_THREADS
+ res = (*statfunc)(path, &st);
+ Py_END_ALLOW_THREADS
+
+ if (res != 0) {
#ifdef MS_WINDOWS
- result = win32_error("stat", path);
+ result = win32_error("stat", path);
#else
- result = posix_error_with_filename(path);
+ result = posix_error_with_filename(path);
#endif
- }
- else
- result = _pystat_fromstructstat(&st);
+ }
+ else
+ result = _pystat_fromstructstat(&st);
- Py_DECREF(opath);
- return result;
+ Py_DECREF(opath);
+ return result;
}
/* POSIX methods */
static PyObject *
posix_access(PyObject *self, PyObject *args)
{
- PyObject *opath;
- char *path;
- int mode;
-
+ PyObject *opath;
+ char *path;
+ int mode;
+
#ifdef MS_WINDOWS
- DWORD attr;
- PyUnicodeObject *po;
- if (PyArg_ParseTuple(args, "Ui:access", &po, &mode)) {
- Py_BEGIN_ALLOW_THREADS
- /* PyUnicode_AS_UNICODE OK without thread lock as
- it is a simple dereference. */
- attr = GetFileAttributesW(PyUnicode_AS_UNICODE(po));
- Py_END_ALLOW_THREADS
- goto finish;
- }
- /* Drop the argument parsing error as narrow strings
- are also valid. */
- PyErr_Clear();
- if (!PyArg_ParseTuple(args, "O&i:access",
- PyUnicode_FSConverter, &opath, &mode))
- return NULL;
- path = PyBytes_AsString(opath);
- Py_BEGIN_ALLOW_THREADS
- attr = GetFileAttributesA(path);
- Py_END_ALLOW_THREADS
- Py_DECREF(opath);
+ DWORD attr;
+ PyUnicodeObject *po;
+ if (PyArg_ParseTuple(args, "Ui:access", &po, &mode)) {
+ Py_BEGIN_ALLOW_THREADS
+ /* PyUnicode_AS_UNICODE OK without thread lock as
+ it is a simple dereference. */
+ attr = GetFileAttributesW(PyUnicode_AS_UNICODE(po));
+ Py_END_ALLOW_THREADS
+ goto finish;
+ }
+ /* Drop the argument parsing error as narrow strings
+ are also valid. */
+ PyErr_Clear();
+ if (!PyArg_ParseTuple(args, "O&i:access",
+ PyUnicode_FSConverter, &opath, &mode))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ Py_BEGIN_ALLOW_THREADS
+ attr = GetFileAttributesA(path);
+ Py_END_ALLOW_THREADS
+ Py_DECREF(opath);
finish:
- if (attr == 0xFFFFFFFF)
- /* File does not exist, or cannot read attributes */
- return PyBool_FromLong(0);
- /* Access is possible if either write access wasn't requested, or
- the file isn't read-only, or if it's a directory, as there are
- no read-only directories on Windows. */
- return PyBool_FromLong(!(mode & 2)
- || !(attr & FILE_ATTRIBUTE_READONLY)
- || (attr & FILE_ATTRIBUTE_DIRECTORY));
+ if (attr == 0xFFFFFFFF)
+ /* File does not exist, or cannot read attributes */
+ return PyBool_FromLong(0);
+ /* Access is possible if either write access wasn't requested, or
+ the file isn't read-only, or if it's a directory, as there are
+ no read-only directories on Windows. */
+ return PyBool_FromLong(!(mode & 2)
+ || !(attr & FILE_ATTRIBUTE_READONLY)
+ || (attr & FILE_ATTRIBUTE_DIRECTORY));
#else
- int res;
- if (!PyArg_ParseTuple(args, "O&i:access",
- PyUnicode_FSConverter, &opath, &mode))
- return NULL;
- path = PyBytes_AsString(opath);
- Py_BEGIN_ALLOW_THREADS
- res = access(path, mode);
- Py_END_ALLOW_THREADS
- Py_DECREF(opath);
- return PyBool_FromLong(res == 0);
+ int res;
+ if (!PyArg_ParseTuple(args, "O&i:access",
+ PyUnicode_FSConverter, &opath, &mode))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ Py_BEGIN_ALLOW_THREADS
+ res = access(path, mode);
+ Py_END_ALLOW_THREADS
+ Py_DECREF(opath);
+ return PyBool_FromLong(res == 0);
#endif
}
static PyObject *
posix_ttyname(PyObject *self, PyObject *args)
{
- int id;
- char *ret;
+ int id;
+ char *ret;
- if (!PyArg_ParseTuple(args, "i:ttyname", &id))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:ttyname", &id))
+ return NULL;
#if defined(__VMS)
- /* file descriptor 0 only, the default input device (stdin) */
- if (id == 0) {
- ret = ttyname();
- }
- else {
- ret = NULL;
- }
+ /* file descriptor 0 only, the default input device (stdin) */
+ if (id == 0) {
+ ret = ttyname();
+ }
+ else {
+ ret = NULL;
+ }
#else
- ret = ttyname(id);
+ ret = ttyname(id);
#endif
- if (ret == NULL)
- return posix_error();
- return PyUnicode_FromString(ret);
+ if (ret == NULL)
+ return posix_error();
+ return PyUnicode_FromString(ret);
}
#endif
static PyObject *
posix_ctermid(PyObject *self, PyObject *noargs)
{
- char *ret;
- char buffer[L_ctermid];
+ char *ret;
+ char buffer[L_ctermid];
#ifdef USE_CTERMID_R
- ret = ctermid_r(buffer);
+ ret = ctermid_r(buffer);
#else
- ret = ctermid(buffer);
+ ret = ctermid(buffer);
#endif
- if (ret == NULL)
- return posix_error();
- return PyUnicode_FromString(buffer);
+ if (ret == NULL)
+ return posix_error();
+ return PyUnicode_FromString(buffer);
}
#endif
posix_chdir(PyObject *self, PyObject *args)
{
#ifdef MS_WINDOWS
- return win32_1str(args, "chdir", "y:chdir", win32_chdir, "U:chdir", win32_wchdir);
+ return win32_1str(args, "chdir", "y:chdir", win32_chdir, "U:chdir", win32_wchdir);
#elif defined(PYOS_OS2) && defined(PYCC_GCC)
- return posix_1str(args, "O&:chdir", _chdir2);
+ return posix_1str(args, "O&:chdir", _chdir2);
#elif defined(__VMS)
- return posix_1str(args, "O&:chdir", (int (*)(const char *))chdir);
+ return posix_1str(args, "O&:chdir", (int (*)(const char *))chdir);
#else
- return posix_1str(args, "O&:chdir", chdir);
+ return posix_1str(args, "O&:chdir", chdir);
#endif
}
static PyObject *
posix_fchdir(PyObject *self, PyObject *fdobj)
{
- return posix_fildes(fdobj, fchdir);
+ return posix_fildes(fdobj, fchdir);
}
#endif /* HAVE_FCHDIR */
static PyObject *
posix_chmod(PyObject *self, PyObject *args)
{
- PyObject *opath = NULL;
- char *path = NULL;
- int i;
- int res;
+ PyObject *opath = NULL;
+ char *path = NULL;
+ int i;
+ int res;
#ifdef MS_WINDOWS
- DWORD attr;
- PyUnicodeObject *po;
- if (PyArg_ParseTuple(args, "Ui|:chmod", &po, &i)) {
- Py_BEGIN_ALLOW_THREADS
- attr = GetFileAttributesW(PyUnicode_AS_UNICODE(po));
- if (attr != 0xFFFFFFFF) {
- if (i & _S_IWRITE)
- attr &= ~FILE_ATTRIBUTE_READONLY;
- else
- attr |= FILE_ATTRIBUTE_READONLY;
- res = SetFileAttributesW(PyUnicode_AS_UNICODE(po), attr);
- }
- else
- res = 0;
- Py_END_ALLOW_THREADS
- if (!res)
- return win32_error_unicode("chmod",
- PyUnicode_AS_UNICODE(po));
- Py_INCREF(Py_None);
- return Py_None;
- }
- /* Drop the argument parsing error as narrow strings
- are also valid. */
- PyErr_Clear();
-
- if (!PyArg_ParseTuple(args, "O&i:chmod", PyUnicode_FSConverter,
- &opath, &i))
- return NULL;
- path = PyBytes_AsString(opath);
- Py_BEGIN_ALLOW_THREADS
- attr = GetFileAttributesA(path);
- if (attr != 0xFFFFFFFF) {
- if (i & _S_IWRITE)
- attr &= ~FILE_ATTRIBUTE_READONLY;
- else
- attr |= FILE_ATTRIBUTE_READONLY;
- res = SetFileAttributesA(path, attr);
- }
- else
- res = 0;
- Py_END_ALLOW_THREADS
- if (!res) {
- win32_error("chmod", path);
- Py_DECREF(opath);
- return NULL;
- }
- Py_DECREF(opath);
- Py_INCREF(Py_None);
- return Py_None;
+ DWORD attr;
+ PyUnicodeObject *po;
+ if (PyArg_ParseTuple(args, "Ui|:chmod", &po, &i)) {
+ Py_BEGIN_ALLOW_THREADS
+ attr = GetFileAttributesW(PyUnicode_AS_UNICODE(po));
+ if (attr != 0xFFFFFFFF) {
+ if (i & _S_IWRITE)
+ attr &= ~FILE_ATTRIBUTE_READONLY;
+ else
+ attr |= FILE_ATTRIBUTE_READONLY;
+ res = SetFileAttributesW(PyUnicode_AS_UNICODE(po), attr);
+ }
+ else
+ res = 0;
+ Py_END_ALLOW_THREADS
+ if (!res)
+ return win32_error_unicode("chmod",
+ PyUnicode_AS_UNICODE(po));
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ /* Drop the argument parsing error as narrow strings
+ are also valid. */
+ PyErr_Clear();
+
+ if (!PyArg_ParseTuple(args, "O&i:chmod", PyUnicode_FSConverter,
+ &opath, &i))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ Py_BEGIN_ALLOW_THREADS
+ attr = GetFileAttributesA(path);
+ if (attr != 0xFFFFFFFF) {
+ if (i & _S_IWRITE)
+ attr &= ~FILE_ATTRIBUTE_READONLY;
+ else
+ attr |= FILE_ATTRIBUTE_READONLY;
+ res = SetFileAttributesA(path, attr);
+ }
+ else
+ res = 0;
+ Py_END_ALLOW_THREADS
+ if (!res) {
+ win32_error("chmod", path);
+ Py_DECREF(opath);
+ return NULL;
+ }
+ Py_DECREF(opath);
+ Py_INCREF(Py_None);
+ return Py_None;
#else /* MS_WINDOWS */
- if (!PyArg_ParseTuple(args, "O&i:chmod", PyUnicode_FSConverter,
- &opath, &i))
- return NULL;
- path = PyBytes_AsString(opath);
- Py_BEGIN_ALLOW_THREADS
- res = chmod(path, i);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error_with_allocated_filename(opath);
- Py_DECREF(opath);
- Py_INCREF(Py_None);
- return Py_None;
+ if (!PyArg_ParseTuple(args, "O&i:chmod", PyUnicode_FSConverter,
+ &opath, &i))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ Py_BEGIN_ALLOW_THREADS
+ res = chmod(path, i);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error_with_allocated_filename(opath);
+ Py_DECREF(opath);
+ Py_INCREF(Py_None);
+ return Py_None;
#endif
}
static PyObject *
posix_fchmod(PyObject *self, PyObject *args)
{
- int fd, mode, res;
- if (!PyArg_ParseTuple(args, "ii:fchmod", &fd, &mode))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- res = fchmod(fd, mode);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error();
- Py_RETURN_NONE;
+ int fd, mode, res;
+ if (!PyArg_ParseTuple(args, "ii:fchmod", &fd, &mode))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ res = fchmod(fd, mode);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error();
+ Py_RETURN_NONE;
}
#endif /* HAVE_FCHMOD */
static PyObject *
posix_lchmod(PyObject *self, PyObject *args)
{
- PyObject *opath;
- char *path;
- int i;
- int res;
- if (!PyArg_ParseTuple(args, "O&i:lchmod", PyUnicode_FSConverter,
- &opath, &i))
- return NULL;
- path = PyBytes_AsString(opath);
- Py_BEGIN_ALLOW_THREADS
- res = lchmod(path, i);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error_with_allocated_filename(opath);
- Py_DECREF(opath);
- Py_RETURN_NONE;
+ PyObject *opath;
+ char *path;
+ int i;
+ int res;
+ if (!PyArg_ParseTuple(args, "O&i:lchmod", PyUnicode_FSConverter,
+ &opath, &i))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ Py_BEGIN_ALLOW_THREADS
+ res = lchmod(path, i);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error_with_allocated_filename(opath);
+ Py_DECREF(opath);
+ Py_RETURN_NONE;
}
#endif /* HAVE_LCHMOD */
static PyObject *
posix_chflags(PyObject *self, PyObject *args)
{
- PyObject *opath;
- char *path;
- unsigned long flags;
- int res;
- if (!PyArg_ParseTuple(args, "O&k:chflags",
- PyUnicode_FSConverter, &opath, &flags))
- return NULL;
- path = PyBytes_AsString(opath);
- Py_BEGIN_ALLOW_THREADS
- res = chflags(path, flags);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error_with_allocated_filename(opath);
- Py_DECREF(opath);
- Py_INCREF(Py_None);
- return Py_None;
+ PyObject *opath;
+ char *path;
+ unsigned long flags;
+ int res;
+ if (!PyArg_ParseTuple(args, "O&k:chflags",
+ PyUnicode_FSConverter, &opath, &flags))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ Py_BEGIN_ALLOW_THREADS
+ res = chflags(path, flags);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error_with_allocated_filename(opath);
+ Py_DECREF(opath);
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* HAVE_CHFLAGS */
static PyObject *
posix_lchflags(PyObject *self, PyObject *args)
{
- PyObject *opath;
- char *path;
- unsigned long flags;
- int res;
- if (!PyArg_ParseTuple(args, "O&k:lchflags",
- PyUnicode_FSConverter, &opath, &flags))
- return NULL;
- path = PyBytes_AsString(opath);
- Py_BEGIN_ALLOW_THREADS
- res = lchflags(path, flags);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error_with_allocated_filename(opath);
- Py_DECREF(opath);
- Py_INCREF(Py_None);
- return Py_None;
+ PyObject *opath;
+ char *path;
+ unsigned long flags;
+ int res;
+ if (!PyArg_ParseTuple(args, "O&k:lchflags",
+ PyUnicode_FSConverter, &opath, &flags))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ Py_BEGIN_ALLOW_THREADS
+ res = lchflags(path, flags);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error_with_allocated_filename(opath);
+ Py_DECREF(opath);
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* HAVE_LCHFLAGS */
static PyObject *
posix_chroot(PyObject *self, PyObject *args)
{
- return posix_1str(args, "O&:chroot", chroot);
+ return posix_1str(args, "O&:chroot", chroot);
}
#endif
static PyObject *
posix_chown(PyObject *self, PyObject *args)
{
- PyObject *opath;
- char *path;
- long uid, gid;
- int res;
- if (!PyArg_ParseTuple(args, "O&ll:chown",
- PyUnicode_FSConverter, &opath,
- &uid, &gid))
- return NULL;
- path = PyBytes_AsString(opath);
- Py_BEGIN_ALLOW_THREADS
- res = chown(path, (uid_t) uid, (gid_t) gid);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error_with_allocated_filename(opath);
- Py_DECREF(opath);
- Py_INCREF(Py_None);
- return Py_None;
+ PyObject *opath;
+ char *path;
+ long uid, gid;
+ int res;
+ if (!PyArg_ParseTuple(args, "O&ll:chown",
+ PyUnicode_FSConverter, &opath,
+ &uid, &gid))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ Py_BEGIN_ALLOW_THREADS
+ res = chown(path, (uid_t) uid, (gid_t) gid);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error_with_allocated_filename(opath);
+ Py_DECREF(opath);
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* HAVE_CHOWN */
static PyObject *
posix_fchown(PyObject *self, PyObject *args)
{
- int fd;
- long uid, gid;
- int res;
- if (!PyArg_ParseTuple(args, "ill:chown", &fd, &uid, &gid))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- res = fchown(fd, (uid_t) uid, (gid_t) gid);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error();
- Py_RETURN_NONE;
+ int fd;
+ long uid, gid;
+ int res;
+ if (!PyArg_ParseTuple(args, "ill:chown", &fd, &uid, &gid))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ res = fchown(fd, (uid_t) uid, (gid_t) gid);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error();
+ Py_RETURN_NONE;
}
#endif /* HAVE_FCHOWN */
static PyObject *
posix_lchown(PyObject *self, PyObject *args)
{
- PyObject *opath;
- char *path;
- long uid, gid;
- int res;
- if (!PyArg_ParseTuple(args, "O&ll:lchown",
- PyUnicode_FSConverter, &opath,
- &uid, &gid))
- return NULL;
- path = PyBytes_AsString(opath);
- Py_BEGIN_ALLOW_THREADS
- res = lchown(path, (uid_t) uid, (gid_t) gid);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error_with_allocated_filename(opath);
- Py_DECREF(opath);
- Py_INCREF(Py_None);
- return Py_None;
+ PyObject *opath;
+ char *path;
+ long uid, gid;
+ int res;
+ if (!PyArg_ParseTuple(args, "O&ll:lchown",
+ PyUnicode_FSConverter, &opath,
+ &uid, &gid))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ Py_BEGIN_ALLOW_THREADS
+ res = lchown(path, (uid_t) uid, (gid_t) gid);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error_with_allocated_filename(opath);
+ Py_DECREF(opath);
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* HAVE_LCHOWN */
static PyObject *
posix_getcwd(int use_bytes)
{
- char buf[1026];
- char *res;
+ char buf[1026];
+ char *res;
#ifdef MS_WINDOWS
- if (!use_bytes) {
- wchar_t wbuf[1026];
- wchar_t *wbuf2 = wbuf;
- PyObject *resobj;
- DWORD len;
- Py_BEGIN_ALLOW_THREADS
- len = GetCurrentDirectoryW(sizeof wbuf/ sizeof wbuf[0], wbuf);
- /* If the buffer is large enough, len does not include the
- terminating \0. If the buffer is too small, len includes
- the space needed for the terminator. */
- if (len >= sizeof wbuf/ sizeof wbuf[0]) {
- wbuf2 = malloc(len * sizeof(wchar_t));
- if (wbuf2)
- len = GetCurrentDirectoryW(len, wbuf2);
- }
- Py_END_ALLOW_THREADS
- if (!wbuf2) {
- PyErr_NoMemory();
- return NULL;
- }
- if (!len) {
- if (wbuf2 != wbuf) free(wbuf2);
- return win32_error("getcwdu", NULL);
- }
- resobj = PyUnicode_FromWideChar(wbuf2, len);
- if (wbuf2 != wbuf) free(wbuf2);
- return resobj;
- }
-#endif
-
- Py_BEGIN_ALLOW_THREADS
+ if (!use_bytes) {
+ wchar_t wbuf[1026];
+ wchar_t *wbuf2 = wbuf;
+ PyObject *resobj;
+ DWORD len;
+ Py_BEGIN_ALLOW_THREADS
+ len = GetCurrentDirectoryW(sizeof wbuf/ sizeof wbuf[0], wbuf);
+ /* If the buffer is large enough, len does not include the
+ terminating \0. If the buffer is too small, len includes
+ the space needed for the terminator. */
+ if (len >= sizeof wbuf/ sizeof wbuf[0]) {
+ wbuf2 = malloc(len * sizeof(wchar_t));
+ if (wbuf2)
+ len = GetCurrentDirectoryW(len, wbuf2);
+ }
+ Py_END_ALLOW_THREADS
+ if (!wbuf2) {
+ PyErr_NoMemory();
+ return NULL;
+ }
+ if (!len) {
+ if (wbuf2 != wbuf) free(wbuf2);
+ return win32_error("getcwdu", NULL);
+ }
+ resobj = PyUnicode_FromWideChar(wbuf2, len);
+ if (wbuf2 != wbuf) free(wbuf2);
+ return resobj;
+ }
+#endif
+
+ Py_BEGIN_ALLOW_THREADS
#if defined(PYOS_OS2) && defined(PYCC_GCC)
- res = _getcwd2(buf, sizeof buf);
+ res = _getcwd2(buf, sizeof buf);
#else
- res = getcwd(buf, sizeof buf);
+ res = getcwd(buf, sizeof buf);
#endif
- Py_END_ALLOW_THREADS
- if (res == NULL)
- return posix_error();
- if (use_bytes)
- return PyBytes_FromStringAndSize(buf, strlen(buf));
- return PyUnicode_Decode(buf, strlen(buf), Py_FileSystemDefaultEncoding,"surrogateescape");
+ Py_END_ALLOW_THREADS
+ if (res == NULL)
+ return posix_error();
+ if (use_bytes)
+ return PyBytes_FromStringAndSize(buf, strlen(buf));
+ return PyUnicode_Decode(buf, strlen(buf), Py_FileSystemDefaultEncoding,"surrogateescape");
}
PyDoc_STRVAR(posix_getcwd__doc__,
static PyObject *
posix_link(PyObject *self, PyObject *args)
{
- return posix_2str(args, "O&O&:link", link);
+ return posix_2str(args, "O&O&:link", link);
}
#endif /* HAVE_LINK */
"listdir(path) -> list_of_strings\n\n\
Return a list containing the names of the entries in the directory.\n\
\n\
- path: path of directory to list\n\
+ path: path of directory to list\n\
\n\
The list is in arbitrary order. It does not include the special\n\
entries '.' and '..' even if they are present in the directory.");
static PyObject *
posix_listdir(PyObject *self, PyObject *args)
{
- /* XXX Should redo this putting the (now four) versions of opendir
- in separate files instead of having them all here... */
+ /* XXX Should redo this putting the (now four) versions of opendir
+ in separate files instead of having them all here... */
#if defined(MS_WINDOWS) && !defined(HAVE_OPENDIR)
- PyObject *d, *v;
- HANDLE hFindFile;
- BOOL result;
- WIN32_FIND_DATA FileData;
- PyObject *opath;
- char namebuf[MAX_PATH+5]; /* Overallocate for \\*.*\0 */
- char *bufptr = namebuf;
- Py_ssize_t len = sizeof(namebuf)-5; /* only claim to have space for MAX_PATH */
-
- PyObject *po;
- if (PyArg_ParseTuple(args, "U:listdir", &po)) {
- WIN32_FIND_DATAW wFileData;
- Py_UNICODE *wnamebuf;
- /* Overallocate for \\*.*\0 */
- len = PyUnicode_GET_SIZE(po);
- wnamebuf = malloc((len + 5) * sizeof(wchar_t));
- if (!wnamebuf) {
- PyErr_NoMemory();
- return NULL;
- }
- wcscpy(wnamebuf, PyUnicode_AS_UNICODE(po));
- if (len > 0) {
- Py_UNICODE wch = wnamebuf[len-1];
- if (wch != L'/' && wch != L'\\' && wch != L':')
- wnamebuf[len++] = L'\\';
- wcscpy(wnamebuf + len, L"*.*");
- }
- if ((d = PyList_New(0)) == NULL) {
- free(wnamebuf);
- return NULL;
- }
- hFindFile = FindFirstFileW(wnamebuf, &wFileData);
- if (hFindFile == INVALID_HANDLE_VALUE) {
- int error = GetLastError();
- if (error == ERROR_FILE_NOT_FOUND) {
- free(wnamebuf);
- return d;
- }
- Py_DECREF(d);
- win32_error_unicode("FindFirstFileW", wnamebuf);
- free(wnamebuf);
- return NULL;
- }
- do {
- /* Skip over . and .. */
- if (wcscmp(wFileData.cFileName, L".") != 0 &&
- wcscmp(wFileData.cFileName, L"..") != 0) {
- v = PyUnicode_FromUnicode(wFileData.cFileName, wcslen(wFileData.cFileName));
- if (v == NULL) {
- Py_DECREF(d);
- d = NULL;
- break;
- }
- if (PyList_Append(d, v) != 0) {
- Py_DECREF(v);
- Py_DECREF(d);
- d = NULL;
- break;
- }
- Py_DECREF(v);
- }
- Py_BEGIN_ALLOW_THREADS
- result = FindNextFileW(hFindFile, &wFileData);
- Py_END_ALLOW_THREADS
- /* FindNextFile sets error to ERROR_NO_MORE_FILES if
- it got to the end of the directory. */
- if (!result && GetLastError() != ERROR_NO_MORE_FILES) {
- Py_DECREF(d);
- win32_error_unicode("FindNextFileW", wnamebuf);
- FindClose(hFindFile);
- free(wnamebuf);
- return NULL;
- }
- } while (result == TRUE);
-
- if (FindClose(hFindFile) == FALSE) {
- Py_DECREF(d);
- win32_error_unicode("FindClose", wnamebuf);
- free(wnamebuf);
- return NULL;
- }
- free(wnamebuf);
- return d;
- }
- /* Drop the argument parsing error as narrow strings
- are also valid. */
- PyErr_Clear();
-
- if (!PyArg_ParseTuple(args, "O&:listdir",
- PyUnicode_FSConverter, &opath))
- return NULL;
- if (PyBytes_GET_SIZE(opath)+1 > MAX_PATH) {
- PyErr_SetString(PyExc_ValueError, "path too long");
- Py_DECREF(opath);
- return NULL;
- }
- strcpy(namebuf, PyBytes_AsString(opath));
- len = PyObject_Size(opath);
- if (len > 0) {
- char ch = namebuf[len-1];
- if (ch != SEP && ch != ALTSEP && ch != ':')
- namebuf[len++] = '/';
- strcpy(namebuf + len, "*.*");
- }
-
- if ((d = PyList_New(0)) == NULL)
- return NULL;
-
- hFindFile = FindFirstFile(namebuf, &FileData);
- if (hFindFile == INVALID_HANDLE_VALUE) {
- int error = GetLastError();
- if (error == ERROR_FILE_NOT_FOUND)
- return d;
- Py_DECREF(d);
- return win32_error("FindFirstFile", namebuf);
- }
- do {
- /* Skip over . and .. */
- if (strcmp(FileData.cFileName, ".") != 0 &&
- strcmp(FileData.cFileName, "..") != 0) {
- v = PyBytes_FromString(FileData.cFileName);
- if (v == NULL) {
- Py_DECREF(d);
- d = NULL;
- break;
- }
- if (PyList_Append(d, v) != 0) {
- Py_DECREF(v);
- Py_DECREF(d);
- d = NULL;
- break;
- }
- Py_DECREF(v);
- }
- Py_BEGIN_ALLOW_THREADS
- result = FindNextFile(hFindFile, &FileData);
- Py_END_ALLOW_THREADS
- /* FindNextFile sets error to ERROR_NO_MORE_FILES if
- it got to the end of the directory. */
- if (!result && GetLastError() != ERROR_NO_MORE_FILES) {
- Py_DECREF(d);
- win32_error("FindNextFile", namebuf);
- FindClose(hFindFile);
- return NULL;
- }
- } while (result == TRUE);
-
- if (FindClose(hFindFile) == FALSE) {
- Py_DECREF(d);
- return win32_error("FindClose", namebuf);
- }
-
- return d;
+ PyObject *d, *v;
+ HANDLE hFindFile;
+ BOOL result;
+ WIN32_FIND_DATA FileData;
+ PyObject *opath;
+ char namebuf[MAX_PATH+5]; /* Overallocate for \\*.*\0 */
+ char *bufptr = namebuf;
+ Py_ssize_t len = sizeof(namebuf)-5; /* only claim to have space for MAX_PATH */
+
+ PyObject *po;
+ if (PyArg_ParseTuple(args, "U:listdir", &po)) {
+ WIN32_FIND_DATAW wFileData;
+ Py_UNICODE *wnamebuf;
+ /* Overallocate for \\*.*\0 */
+ len = PyUnicode_GET_SIZE(po);
+ wnamebuf = malloc((len + 5) * sizeof(wchar_t));
+ if (!wnamebuf) {
+ PyErr_NoMemory();
+ return NULL;
+ }
+ wcscpy(wnamebuf, PyUnicode_AS_UNICODE(po));
+ if (len > 0) {
+ Py_UNICODE wch = wnamebuf[len-1];
+ if (wch != L'/' && wch != L'\\' && wch != L':')
+ wnamebuf[len++] = L'\\';
+ wcscpy(wnamebuf + len, L"*.*");
+ }
+ if ((d = PyList_New(0)) == NULL) {
+ free(wnamebuf);
+ return NULL;
+ }
+ hFindFile = FindFirstFileW(wnamebuf, &wFileData);
+ if (hFindFile == INVALID_HANDLE_VALUE) {
+ int error = GetLastError();
+ if (error == ERROR_FILE_NOT_FOUND) {
+ free(wnamebuf);
+ return d;
+ }
+ Py_DECREF(d);
+ win32_error_unicode("FindFirstFileW", wnamebuf);
+ free(wnamebuf);
+ return NULL;
+ }
+ do {
+ /* Skip over . and .. */
+ if (wcscmp(wFileData.cFileName, L".") != 0 &&
+ wcscmp(wFileData.cFileName, L"..") != 0) {
+ v = PyUnicode_FromUnicode(wFileData.cFileName, wcslen(wFileData.cFileName));
+ if (v == NULL) {
+ Py_DECREF(d);
+ d = NULL;
+ break;
+ }
+ if (PyList_Append(d, v) != 0) {
+ Py_DECREF(v);
+ Py_DECREF(d);
+ d = NULL;
+ break;
+ }
+ Py_DECREF(v);
+ }
+ Py_BEGIN_ALLOW_THREADS
+ result = FindNextFileW(hFindFile, &wFileData);
+ Py_END_ALLOW_THREADS
+ /* FindNextFile sets error to ERROR_NO_MORE_FILES if
+ it got to the end of the directory. */
+ if (!result && GetLastError() != ERROR_NO_MORE_FILES) {
+ Py_DECREF(d);
+ win32_error_unicode("FindNextFileW", wnamebuf);
+ FindClose(hFindFile);
+ free(wnamebuf);
+ return NULL;
+ }
+ } while (result == TRUE);
+
+ if (FindClose(hFindFile) == FALSE) {
+ Py_DECREF(d);
+ win32_error_unicode("FindClose", wnamebuf);
+ free(wnamebuf);
+ return NULL;
+ }
+ free(wnamebuf);
+ return d;
+ }
+ /* Drop the argument parsing error as narrow strings
+ are also valid. */
+ PyErr_Clear();
+
+ if (!PyArg_ParseTuple(args, "O&:listdir",
+ PyUnicode_FSConverter, &opath))
+ return NULL;
+ if (PyBytes_GET_SIZE(opath)+1 > MAX_PATH) {
+ PyErr_SetString(PyExc_ValueError, "path too long");
+ Py_DECREF(opath);
+ return NULL;
+ }
+ strcpy(namebuf, PyBytes_AsString(opath));
+ len = PyObject_Size(opath);
+ if (len > 0) {
+ char ch = namebuf[len-1];
+ if (ch != SEP && ch != ALTSEP && ch != ':')
+ namebuf[len++] = '/';
+ strcpy(namebuf + len, "*.*");
+ }
+
+ if ((d = PyList_New(0)) == NULL)
+ return NULL;
+
+ hFindFile = FindFirstFile(namebuf, &FileData);
+ if (hFindFile == INVALID_HANDLE_VALUE) {
+ int error = GetLastError();
+ if (error == ERROR_FILE_NOT_FOUND)
+ return d;
+ Py_DECREF(d);
+ return win32_error("FindFirstFile", namebuf);
+ }
+ do {
+ /* Skip over . and .. */
+ if (strcmp(FileData.cFileName, ".") != 0 &&
+ strcmp(FileData.cFileName, "..") != 0) {
+ v = PyBytes_FromString(FileData.cFileName);
+ if (v == NULL) {
+ Py_DECREF(d);
+ d = NULL;
+ break;
+ }
+ if (PyList_Append(d, v) != 0) {
+ Py_DECREF(v);
+ Py_DECREF(d);
+ d = NULL;
+ break;
+ }
+ Py_DECREF(v);
+ }
+ Py_BEGIN_ALLOW_THREADS
+ result = FindNextFile(hFindFile, &FileData);
+ Py_END_ALLOW_THREADS
+ /* FindNextFile sets error to ERROR_NO_MORE_FILES if
+ it got to the end of the directory. */
+ if (!result && GetLastError() != ERROR_NO_MORE_FILES) {
+ Py_DECREF(d);
+ win32_error("FindNextFile", namebuf);
+ FindClose(hFindFile);
+ return NULL;
+ }
+ } while (result == TRUE);
+
+ if (FindClose(hFindFile) == FALSE) {
+ Py_DECREF(d);
+ return win32_error("FindClose", namebuf);
+ }
+
+ return d;
#elif defined(PYOS_OS2)
FILEFINDBUF3 ep;
APIRET rc;
- if (!PyArg_ParseTuple(args, "O&:listdir",
+ if (!PyArg_ParseTuple(args, "O&:listdir",
PyUnicode_FSConverter, &oname))
return NULL;
name = PyBytes_AsString(oname);
Py_DECREF(oname);
return d;
#else
- PyObject *oname;
- char *name;
- PyObject *d, *v;
- DIR *dirp;
- struct dirent *ep;
- int arg_is_unicode = 1;
-
- errno = 0;
- if (!PyArg_ParseTuple(args, "U:listdir", &v)) {
- arg_is_unicode = 0;
- PyErr_Clear();
- }
- if (!PyArg_ParseTuple(args, "O&:listdir", PyUnicode_FSConverter, &oname))
- return NULL;
- name = PyBytes_AsString(oname);
- if ((dirp = opendir(name)) == NULL) {
- return posix_error_with_allocated_filename(oname);
- }
- if ((d = PyList_New(0)) == NULL) {
- closedir(dirp);
- Py_DECREF(oname);
- return NULL;
- }
- for (;;) {
- errno = 0;
- Py_BEGIN_ALLOW_THREADS
- ep = readdir(dirp);
- Py_END_ALLOW_THREADS
- if (ep == NULL) {
- if (errno == 0) {
- break;
- } else {
- closedir(dirp);
- Py_DECREF(d);
- return posix_error_with_allocated_filename(oname);
- }
- }
- if (ep->d_name[0] == '.' &&
- (NAMLEN(ep) == 1 ||
- (ep->d_name[1] == '.' && NAMLEN(ep) == 2)))
- continue;
- v = PyBytes_FromStringAndSize(ep->d_name, NAMLEN(ep));
- if (v == NULL) {
- Py_DECREF(d);
- d = NULL;
- break;
- }
- if (arg_is_unicode) {
- PyObject *w;
-
- w = PyUnicode_FromEncodedObject(v,
- Py_FileSystemDefaultEncoding,
- "surrogateescape");
- Py_DECREF(v);
- if (w != NULL)
- v = w;
- else {
- /* Encoding failed to decode ASCII bytes.
- Raise exception. */
- Py_DECREF(d);
- d = NULL;
- break;
- }
- }
- if (PyList_Append(d, v) != 0) {
- Py_DECREF(v);
- Py_DECREF(d);
- d = NULL;
- break;
- }
- Py_DECREF(v);
- }
- closedir(dirp);
- Py_DECREF(oname);
-
- return d;
+ PyObject *oname;
+ char *name;
+ PyObject *d, *v;
+ DIR *dirp;
+ struct dirent *ep;
+ int arg_is_unicode = 1;
+
+ errno = 0;
+ if (!PyArg_ParseTuple(args, "U:listdir", &v)) {
+ arg_is_unicode = 0;
+ PyErr_Clear();
+ }
+ if (!PyArg_ParseTuple(args, "O&:listdir", PyUnicode_FSConverter, &oname))
+ return NULL;
+ name = PyBytes_AsString(oname);
+ if ((dirp = opendir(name)) == NULL) {
+ return posix_error_with_allocated_filename(oname);
+ }
+ if ((d = PyList_New(0)) == NULL) {
+ closedir(dirp);
+ Py_DECREF(oname);
+ return NULL;
+ }
+ for (;;) {
+ errno = 0;
+ Py_BEGIN_ALLOW_THREADS
+ ep = readdir(dirp);
+ Py_END_ALLOW_THREADS
+ if (ep == NULL) {
+ if (errno == 0) {
+ break;
+ } else {
+ closedir(dirp);
+ Py_DECREF(d);
+ return posix_error_with_allocated_filename(oname);
+ }
+ }
+ if (ep->d_name[0] == '.' &&
+ (NAMLEN(ep) == 1 ||
+ (ep->d_name[1] == '.' && NAMLEN(ep) == 2)))
+ continue;
+ v = PyBytes_FromStringAndSize(ep->d_name, NAMLEN(ep));
+ if (v == NULL) {
+ Py_DECREF(d);
+ d = NULL;
+ break;
+ }
+ if (arg_is_unicode) {
+ PyObject *w;
+
+ w = PyUnicode_FromEncodedObject(v,
+ Py_FileSystemDefaultEncoding,
+ "surrogateescape");
+ Py_DECREF(v);
+ if (w != NULL)
+ v = w;
+ else {
+ /* Encoding failed to decode ASCII bytes.
+ Raise exception. */
+ Py_DECREF(d);
+ d = NULL;
+ break;
+ }
+ }
+ if (PyList_Append(d, v) != 0) {
+ Py_DECREF(v);
+ Py_DECREF(d);
+ d = NULL;
+ break;
+ }
+ Py_DECREF(v);
+ }
+ closedir(dirp);
+ Py_DECREF(oname);
+
+ return d;
#endif /* which OS */
} /* end of posix_listdir */
static PyObject *
posix__getfullpathname(PyObject *self, PyObject *args)
{
- PyObject *opath;
- char *path;
- char outbuf[MAX_PATH*2];
- char *temp;
+ PyObject *opath;
+ char *path;
+ char outbuf[MAX_PATH*2];
+ char *temp;
#ifdef MS_WINDOWS
- PyUnicodeObject *po;
- if (PyArg_ParseTuple(args, "U|:_getfullpathname", &po)) {
- Py_UNICODE *wpath = PyUnicode_AS_UNICODE(po);
- Py_UNICODE woutbuf[MAX_PATH*2], *woutbufp = woutbuf;
- Py_UNICODE *wtemp;
- DWORD result;
- PyObject *v;
- result = GetFullPathNameW(wpath,
- sizeof(woutbuf)/sizeof(woutbuf[0]),
- woutbuf, &wtemp);
- if (result > sizeof(woutbuf)/sizeof(woutbuf[0])) {
- woutbufp = malloc(result * sizeof(Py_UNICODE));
- if (!woutbufp)
- return PyErr_NoMemory();
- result = GetFullPathNameW(wpath, result, woutbufp, &wtemp);
- }
- if (result)
- v = PyUnicode_FromUnicode(woutbufp, wcslen(woutbufp));
- else
- v = win32_error_unicode("GetFullPathNameW", wpath);
- if (woutbufp != woutbuf)
- free(woutbufp);
- return v;
- }
- /* Drop the argument parsing error as narrow strings
- are also valid. */
- PyErr_Clear();
-
-#endif
- if (!PyArg_ParseTuple (args, "O&:_getfullpathname",
- PyUnicode_FSConverter, &opath))
- return NULL;
- path = PyBytes_AsString(opath);
- if (!GetFullPathName(path, sizeof(outbuf)/sizeof(outbuf[0]),
- outbuf, &temp)) {
- win32_error("GetFullPathName", path);
- Py_DECREF(opath);
- return NULL;
- }
- Py_DECREF(opath);
- if (PyUnicode_Check(PyTuple_GetItem(args, 0))) {
- return PyUnicode_Decode(outbuf, strlen(outbuf),
- Py_FileSystemDefaultEncoding, NULL);
- }
- return PyBytes_FromString(outbuf);
+ PyUnicodeObject *po;
+ if (PyArg_ParseTuple(args, "U|:_getfullpathname", &po)) {
+ Py_UNICODE *wpath = PyUnicode_AS_UNICODE(po);
+ Py_UNICODE woutbuf[MAX_PATH*2], *woutbufp = woutbuf;
+ Py_UNICODE *wtemp;
+ DWORD result;
+ PyObject *v;
+ result = GetFullPathNameW(wpath,
+ sizeof(woutbuf)/sizeof(woutbuf[0]),
+ woutbuf, &wtemp);
+ if (result > sizeof(woutbuf)/sizeof(woutbuf[0])) {
+ woutbufp = malloc(result * sizeof(Py_UNICODE));
+ if (!woutbufp)
+ return PyErr_NoMemory();
+ result = GetFullPathNameW(wpath, result, woutbufp, &wtemp);
+ }
+ if (result)
+ v = PyUnicode_FromUnicode(woutbufp, wcslen(woutbufp));
+ else
+ v = win32_error_unicode("GetFullPathNameW", wpath);
+ if (woutbufp != woutbuf)
+ free(woutbufp);
+ return v;
+ }
+ /* Drop the argument parsing error as narrow strings
+ are also valid. */
+ PyErr_Clear();
+
+#endif
+ if (!PyArg_ParseTuple (args, "O&:_getfullpathname",
+ PyUnicode_FSConverter, &opath))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ if (!GetFullPathName(path, sizeof(outbuf)/sizeof(outbuf[0]),
+ outbuf, &temp)) {
+ win32_error("GetFullPathName", path);
+ Py_DECREF(opath);
+ return NULL;
+ }
+ Py_DECREF(opath);
+ if (PyUnicode_Check(PyTuple_GetItem(args, 0))) {
+ return PyUnicode_Decode(outbuf, strlen(outbuf),
+ Py_FileSystemDefaultEncoding, NULL);
+ }
+ return PyBytes_FromString(outbuf);
} /* end of posix__getfullpathname */
#endif /* MS_WINDOWS */
static PyObject *
posix_mkdir(PyObject *self, PyObject *args)
{
- int res;
- PyObject *opath;
- char *path;
- int mode = 0777;
+ int res;
+ PyObject *opath;
+ char *path;
+ int mode = 0777;
#ifdef MS_WINDOWS
- PyUnicodeObject *po;
- if (PyArg_ParseTuple(args, "U|i:mkdir", &po, &mode)) {
- Py_BEGIN_ALLOW_THREADS
- /* PyUnicode_AS_UNICODE OK without thread lock as
- it is a simple dereference. */
- res = CreateDirectoryW(PyUnicode_AS_UNICODE(po), NULL);
- Py_END_ALLOW_THREADS
- if (!res)
- return win32_error_unicode("mkdir", PyUnicode_AS_UNICODE(po));
- Py_INCREF(Py_None);
- return Py_None;
- }
- /* Drop the argument parsing error as narrow strings
- are also valid. */
- PyErr_Clear();
- if (!PyArg_ParseTuple(args, "O&|i:mkdir",
- PyUnicode_FSConverter, &opath, &mode))
- return NULL;
- path = PyBytes_AsString(opath);
- Py_BEGIN_ALLOW_THREADS
- /* PyUnicode_AS_UNICODE OK without thread lock as
- it is a simple dereference. */
- res = CreateDirectoryA(path, NULL);
- Py_END_ALLOW_THREADS
- if (!res) {
- win32_error("mkdir", path);
- Py_DECREF(opath);
- return NULL;
- }
- Py_DECREF(opath);
- Py_INCREF(Py_None);
- return Py_None;
+ PyUnicodeObject *po;
+ if (PyArg_ParseTuple(args, "U|i:mkdir", &po, &mode)) {
+ Py_BEGIN_ALLOW_THREADS
+ /* PyUnicode_AS_UNICODE OK without thread lock as
+ it is a simple dereference. */
+ res = CreateDirectoryW(PyUnicode_AS_UNICODE(po), NULL);
+ Py_END_ALLOW_THREADS
+ if (!res)
+ return win32_error_unicode("mkdir", PyUnicode_AS_UNICODE(po));
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ /* Drop the argument parsing error as narrow strings
+ are also valid. */
+ PyErr_Clear();
+ if (!PyArg_ParseTuple(args, "O&|i:mkdir",
+ PyUnicode_FSConverter, &opath, &mode))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ Py_BEGIN_ALLOW_THREADS
+ /* PyUnicode_AS_UNICODE OK without thread lock as
+ it is a simple dereference. */
+ res = CreateDirectoryA(path, NULL);
+ Py_END_ALLOW_THREADS
+ if (!res) {
+ win32_error("mkdir", path);
+ Py_DECREF(opath);
+ return NULL;
+ }
+ Py_DECREF(opath);
+ Py_INCREF(Py_None);
+ return Py_None;
#else
- if (!PyArg_ParseTuple(args, "O&|i:mkdir",
- PyUnicode_FSConverter, &opath, &mode))
- return NULL;
- path = PyBytes_AsString(opath);
- Py_BEGIN_ALLOW_THREADS
+ if (!PyArg_ParseTuple(args, "O&|i:mkdir",
+ PyUnicode_FSConverter, &opath, &mode))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ Py_BEGIN_ALLOW_THREADS
#if ( defined(__WATCOMC__) || defined(PYCC_VACPP) ) && !defined(__QNX__)
- res = mkdir(path);
+ res = mkdir(path);
#else
- res = mkdir(path, mode);
+ res = mkdir(path, mode);
#endif
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error_with_allocated_filename(opath);
- Py_DECREF(opath);
- Py_INCREF(Py_None);
- return Py_None;
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error_with_allocated_filename(opath);
+ Py_DECREF(opath);
+ Py_INCREF(Py_None);
+ return Py_None;
#endif
}
static PyObject *
posix_nice(PyObject *self, PyObject *args)
{
- int increment, value;
+ int increment, value;
- if (!PyArg_ParseTuple(args, "i:nice", &increment))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:nice", &increment))
+ return NULL;
- /* There are two flavours of 'nice': one that returns the new
- priority (as required by almost all standards out there) and the
- Linux/FreeBSD/BSDI one, which returns '0' on success and advices
- the use of getpriority() to get the new priority.
+ /* There are two flavours of 'nice': one that returns the new
+ priority (as required by almost all standards out there) and the
+ Linux/FreeBSD/BSDI one, which returns '0' on success and advices
+ the use of getpriority() to get the new priority.
- If we are of the nice family that returns the new priority, we
- need to clear errno before the call, and check if errno is filled
- before calling posix_error() on a returnvalue of -1, because the
- -1 may be the actual new priority! */
+ If we are of the nice family that returns the new priority, we
+ need to clear errno before the call, and check if errno is filled
+ before calling posix_error() on a returnvalue of -1, because the
+ -1 may be the actual new priority! */
- errno = 0;
- value = nice(increment);
+ errno = 0;
+ value = nice(increment);
#if defined(HAVE_BROKEN_NICE) && defined(HAVE_GETPRIORITY)
- if (value == 0)
- value = getpriority(PRIO_PROCESS, 0);
+ if (value == 0)
+ value = getpriority(PRIO_PROCESS, 0);
#endif
- if (value == -1 && errno != 0)
- /* either nice() or getpriority() returned an error */
- return posix_error();
- return PyLong_FromLong((long) value);
+ if (value == -1 && errno != 0)
+ /* either nice() or getpriority() returned an error */
+ return posix_error();
+ return PyLong_FromLong((long) value);
}
#endif /* HAVE_NICE */
posix_rename(PyObject *self, PyObject *args)
{
#ifdef MS_WINDOWS
- PyObject *o1, *o2;
- char *p1, *p2;
- BOOL result;
- if (!PyArg_ParseTuple(args, "OO:rename", &o1, &o2))
- goto error;
- if (!convert_to_unicode(&o1))
- goto error;
- if (!convert_to_unicode(&o2)) {
- Py_DECREF(o1);
- goto error;
- }
- Py_BEGIN_ALLOW_THREADS
- result = MoveFileW(PyUnicode_AsUnicode(o1),
- PyUnicode_AsUnicode(o2));
- Py_END_ALLOW_THREADS
- Py_DECREF(o1);
- Py_DECREF(o2);
- if (!result)
- return win32_error("rename", NULL);
- Py_INCREF(Py_None);
- return Py_None;
+ PyObject *o1, *o2;
+ char *p1, *p2;
+ BOOL result;
+ if (!PyArg_ParseTuple(args, "OO:rename", &o1, &o2))
+ goto error;
+ if (!convert_to_unicode(&o1))
+ goto error;
+ if (!convert_to_unicode(&o2)) {
+ Py_DECREF(o1);
+ goto error;
+ }
+ Py_BEGIN_ALLOW_THREADS
+ result = MoveFileW(PyUnicode_AsUnicode(o1),
+ PyUnicode_AsUnicode(o2));
+ Py_END_ALLOW_THREADS
+ Py_DECREF(o1);
+ Py_DECREF(o2);
+ if (!result)
+ return win32_error("rename", NULL);
+ Py_INCREF(Py_None);
+ return Py_None;
error:
- PyErr_Clear();
- if (!PyArg_ParseTuple(args, "ss:rename", &p1, &p2))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- result = MoveFileA(p1, p2);
- Py_END_ALLOW_THREADS
- if (!result)
- return win32_error("rename", NULL);
- Py_INCREF(Py_None);
- return Py_None;
+ PyErr_Clear();
+ if (!PyArg_ParseTuple(args, "ss:rename", &p1, &p2))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ result = MoveFileA(p1, p2);
+ Py_END_ALLOW_THREADS
+ if (!result)
+ return win32_error("rename", NULL);
+ Py_INCREF(Py_None);
+ return Py_None;
#else
- return posix_2str(args, "O&O&:rename", rename);
+ return posix_2str(args, "O&O&:rename", rename);
#endif
}
posix_rmdir(PyObject *self, PyObject *args)
{
#ifdef MS_WINDOWS
- return win32_1str(args, "rmdir", "y:rmdir", RemoveDirectoryA, "U:rmdir", RemoveDirectoryW);
+ return win32_1str(args, "rmdir", "y:rmdir", RemoveDirectoryA, "U:rmdir", RemoveDirectoryW);
#else
- return posix_1str(args, "O&:rmdir", rmdir);
+ return posix_1str(args, "O&:rmdir", rmdir);
#endif
}
posix_stat(PyObject *self, PyObject *args)
{
#ifdef MS_WINDOWS
- return posix_do_stat(self, args, "O&:stat", STAT, "U:stat", win32_wstat);
+ return posix_do_stat(self, args, "O&:stat", STAT, "U:stat", win32_wstat);
#else
- return posix_do_stat(self, args, "O&:stat", STAT, NULL, NULL);
+ return posix_do_stat(self, args, "O&:stat", STAT, NULL, NULL);
#endif
}
static PyObject *
posix_system(PyObject *self, PyObject *args)
{
- long sts;
+ long sts;
#ifdef MS_WINDOWS
- wchar_t *command;
- if (!PyArg_ParseTuple(args, "u:system", &command))
- return NULL;
+ wchar_t *command;
+ if (!PyArg_ParseTuple(args, "u:system", &command))
+ return NULL;
- Py_BEGIN_ALLOW_THREADS
- sts = _wsystem(command);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ sts = _wsystem(command);
+ Py_END_ALLOW_THREADS
#else
- PyObject *command_obj;
- char *command;
- if (!PyArg_ParseTuple(args, "O&:system",
- PyUnicode_FSConverter, &command_obj))
- return NULL;
+ PyObject *command_obj;
+ char *command;
+ if (!PyArg_ParseTuple(args, "O&:system",
+ PyUnicode_FSConverter, &command_obj))
+ return NULL;
- command = PyBytes_AsString(command_obj);
- Py_BEGIN_ALLOW_THREADS
- sts = system(command);
- Py_END_ALLOW_THREADS
- Py_DECREF(command_obj);
+ command = PyBytes_AsString(command_obj);
+ Py_BEGIN_ALLOW_THREADS
+ sts = system(command);
+ Py_END_ALLOW_THREADS
+ Py_DECREF(command_obj);
#endif
- return PyLong_FromLong(sts);
+ return PyLong_FromLong(sts);
}
#endif
static PyObject *
posix_umask(PyObject *self, PyObject *args)
{
- int i;
- if (!PyArg_ParseTuple(args, "i:umask", &i))
- return NULL;
- i = (int)umask(i);
- if (i < 0)
- return posix_error();
- return PyLong_FromLong((long)i);
+ int i;
+ if (!PyArg_ParseTuple(args, "i:umask", &i))
+ return NULL;
+ i = (int)umask(i);
+ if (i < 0)
+ return posix_error();
+ return PyLong_FromLong((long)i);
}
posix_unlink(PyObject *self, PyObject *args)
{
#ifdef MS_WINDOWS
- return win32_1str(args, "remove", "y:remove", DeleteFileA, "U:remove", DeleteFileW);
+ return win32_1str(args, "remove", "y:remove", DeleteFileA, "U:remove", DeleteFileW);
#else
- return posix_1str(args, "O&:remove", unlink);
+ return posix_1str(args, "O&:remove", unlink);
#endif
}
static PyObject *
posix_uname(PyObject *self, PyObject *noargs)
{
- struct utsname u;
- int res;
-
- Py_BEGIN_ALLOW_THREADS
- res = uname(&u);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error();
- return Py_BuildValue("(sssss)",
- u.sysname,
- u.nodename,
- u.release,
- u.version,
- u.machine);
+ struct utsname u;
+ int res;
+
+ Py_BEGIN_ALLOW_THREADS
+ res = uname(&u);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error();
+ return Py_BuildValue("(sssss)",
+ u.sysname,
+ u.nodename,
+ u.release,
+ u.version,
+ u.machine);
}
#endif /* HAVE_UNAME */
static int
extract_time(PyObject *t, long* sec, long* usec)
{
- long intval;
- if (PyFloat_Check(t)) {
- double tval = PyFloat_AsDouble(t);
- PyObject *intobj = Py_TYPE(t)->tp_as_number->nb_int(t);
- if (!intobj)
- return -1;
- intval = PyLong_AsLong(intobj);
- Py_DECREF(intobj);
- if (intval == -1 && PyErr_Occurred())
- return -1;
- *sec = intval;
- *usec = (long)((tval - intval) * 1e6); /* can't exceed 1000000 */
- if (*usec < 0)
- /* If rounding gave us a negative number,
- truncate. */
- *usec = 0;
- return 0;
- }
- intval = PyLong_AsLong(t);
- if (intval == -1 && PyErr_Occurred())
- return -1;
- *sec = intval;
- *usec = 0;
+ long intval;
+ if (PyFloat_Check(t)) {
+ double tval = PyFloat_AsDouble(t);
+ PyObject *intobj = Py_TYPE(t)->tp_as_number->nb_int(t);
+ if (!intobj)
+ return -1;
+ intval = PyLong_AsLong(intobj);
+ Py_DECREF(intobj);
+ if (intval == -1 && PyErr_Occurred())
+ return -1;
+ *sec = intval;
+ *usec = (long)((tval - intval) * 1e6); /* can't exceed 1000000 */
+ if (*usec < 0)
+ /* If rounding gave us a negative number,
+ truncate. */
+ *usec = 0;
return 0;
+ }
+ intval = PyLong_AsLong(t);
+ if (intval == -1 && PyErr_Occurred())
+ return -1;
+ *sec = intval;
+ *usec = 0;
+ return 0;
}
PyDoc_STRVAR(posix_utime__doc__,
posix_utime(PyObject *self, PyObject *args)
{
#ifdef MS_WINDOWS
- PyObject *arg;
- PyUnicodeObject *obwpath;
- wchar_t *wpath = NULL;
- PyObject *oapath;
- char *apath;
- HANDLE hFile;
- long atimesec, mtimesec, ausec, musec;
- FILETIME atime, mtime;
- PyObject *result = NULL;
-
- if (PyArg_ParseTuple(args, "UO|:utime", &obwpath, &arg)) {
- wpath = PyUnicode_AS_UNICODE(obwpath);
- Py_BEGIN_ALLOW_THREADS
- hFile = CreateFileW(wpath, FILE_WRITE_ATTRIBUTES, 0,
- NULL, OPEN_EXISTING,
- FILE_FLAG_BACKUP_SEMANTICS, NULL);
- Py_END_ALLOW_THREADS
- if (hFile == INVALID_HANDLE_VALUE)
- return win32_error_unicode("utime", wpath);
- } else
- /* Drop the argument parsing error as narrow strings
- are also valid. */
- PyErr_Clear();
-
- if (!wpath) {
- if (!PyArg_ParseTuple(args, "O&O:utime",
- PyUnicode_FSConverter, &oapath, &arg))
- return NULL;
- apath = PyBytes_AsString(oapath);
- Py_BEGIN_ALLOW_THREADS
- hFile = CreateFileA(apath, FILE_WRITE_ATTRIBUTES, 0,
- NULL, OPEN_EXISTING,
- FILE_FLAG_BACKUP_SEMANTICS, NULL);
- Py_END_ALLOW_THREADS
- if (hFile == INVALID_HANDLE_VALUE) {
- win32_error("utime", apath);
- Py_DECREF(oapath);
- return NULL;
- }
- Py_DECREF(oapath);
- }
-
- if (arg == Py_None) {
- SYSTEMTIME now;
- GetSystemTime(&now);
- if (!SystemTimeToFileTime(&now, &mtime) ||
- !SystemTimeToFileTime(&now, &atime)) {
- win32_error("utime", NULL);
- goto done;
- }
- }
- else if (!PyTuple_Check(arg) || PyTuple_Size(arg) != 2) {
- PyErr_SetString(PyExc_TypeError,
- "utime() arg 2 must be a tuple (atime, mtime)");
- goto done;
- }
- else {
- if (extract_time(PyTuple_GET_ITEM(arg, 0),
- &atimesec, &ausec) == -1)
- goto done;
- time_t_to_FILE_TIME(atimesec, 1000*ausec, &atime);
- if (extract_time(PyTuple_GET_ITEM(arg, 1),
- &mtimesec, &musec) == -1)
- goto done;
- time_t_to_FILE_TIME(mtimesec, 1000*musec, &mtime);
- }
- if (!SetFileTime(hFile, NULL, &atime, &mtime)) {
- /* Avoid putting the file name into the error here,
- as that may confuse the user into believing that
- something is wrong with the file, when it also
- could be the time stamp that gives a problem. */
- win32_error("utime", NULL);
- }
- Py_INCREF(Py_None);
- result = Py_None;
+ PyObject *arg;
+ PyUnicodeObject *obwpath;
+ wchar_t *wpath = NULL;
+ PyObject *oapath;
+ char *apath;
+ HANDLE hFile;
+ long atimesec, mtimesec, ausec, musec;
+ FILETIME atime, mtime;
+ PyObject *result = NULL;
+
+ if (PyArg_ParseTuple(args, "UO|:utime", &obwpath, &arg)) {
+ wpath = PyUnicode_AS_UNICODE(obwpath);
+ Py_BEGIN_ALLOW_THREADS
+ hFile = CreateFileW(wpath, FILE_WRITE_ATTRIBUTES, 0,
+ NULL, OPEN_EXISTING,
+ FILE_FLAG_BACKUP_SEMANTICS, NULL);
+ Py_END_ALLOW_THREADS
+ if (hFile == INVALID_HANDLE_VALUE)
+ return win32_error_unicode("utime", wpath);
+ } else
+ /* Drop the argument parsing error as narrow strings
+ are also valid. */
+ PyErr_Clear();
+
+ if (!wpath) {
+ if (!PyArg_ParseTuple(args, "O&O:utime",
+ PyUnicode_FSConverter, &oapath, &arg))
+ return NULL;
+ apath = PyBytes_AsString(oapath);
+ Py_BEGIN_ALLOW_THREADS
+ hFile = CreateFileA(apath, FILE_WRITE_ATTRIBUTES, 0,
+ NULL, OPEN_EXISTING,
+ FILE_FLAG_BACKUP_SEMANTICS, NULL);
+ Py_END_ALLOW_THREADS
+ if (hFile == INVALID_HANDLE_VALUE) {
+ win32_error("utime", apath);
+ Py_DECREF(oapath);
+ return NULL;
+ }
+ Py_DECREF(oapath);
+ }
+
+ if (arg == Py_None) {
+ SYSTEMTIME now;
+ GetSystemTime(&now);
+ if (!SystemTimeToFileTime(&now, &mtime) ||
+ !SystemTimeToFileTime(&now, &atime)) {
+ win32_error("utime", NULL);
+ goto done;
+ }
+ }
+ else if (!PyTuple_Check(arg) || PyTuple_Size(arg) != 2) {
+ PyErr_SetString(PyExc_TypeError,
+ "utime() arg 2 must be a tuple (atime, mtime)");
+ goto done;
+ }
+ else {
+ if (extract_time(PyTuple_GET_ITEM(arg, 0),
+ &atimesec, &ausec) == -1)
+ goto done;
+ time_t_to_FILE_TIME(atimesec, 1000*ausec, &atime);
+ if (extract_time(PyTuple_GET_ITEM(arg, 1),
+ &mtimesec, &musec) == -1)
+ goto done;
+ time_t_to_FILE_TIME(mtimesec, 1000*musec, &mtime);
+ }
+ if (!SetFileTime(hFile, NULL, &atime, &mtime)) {
+ /* Avoid putting the file name into the error here,
+ as that may confuse the user into believing that
+ something is wrong with the file, when it also
+ could be the time stamp that gives a problem. */
+ win32_error("utime", NULL);
+ }
+ Py_INCREF(Py_None);
+ result = Py_None;
done:
- CloseHandle(hFile);
- return result;
+ CloseHandle(hFile);
+ return result;
#else /* MS_WINDOWS */
- PyObject *opath;
- char *path;
- long atime, mtime, ausec, musec;
- int res;
- PyObject* arg;
+ PyObject *opath;
+ char *path;
+ long atime, mtime, ausec, musec;
+ int res;
+ PyObject* arg;
#if defined(HAVE_UTIMES)
- struct timeval buf[2];
+ struct timeval buf[2];
#define ATIME buf[0].tv_sec
#define MTIME buf[1].tv_sec
#elif defined(HAVE_UTIME_H)
/* XXX should define struct utimbuf instead, above */
- struct utimbuf buf;
+ struct utimbuf buf;
#define ATIME buf.actime
#define MTIME buf.modtime
#define UTIME_ARG &buf
#else /* HAVE_UTIMES */
- time_t buf[2];
+ time_t buf[2];
#define ATIME buf[0]
#define MTIME buf[1]
#define UTIME_ARG buf
#endif /* HAVE_UTIMES */
- if (!PyArg_ParseTuple(args, "O&O:utime",
- PyUnicode_FSConverter, &opath, &arg))
- return NULL;
- path = PyBytes_AsString(opath);
- if (arg == Py_None) {
- /* optional time values not given */
- Py_BEGIN_ALLOW_THREADS
- res = utime(path, NULL);
- Py_END_ALLOW_THREADS
- }
- else if (!PyTuple_Check(arg) || PyTuple_Size(arg) != 2) {
- PyErr_SetString(PyExc_TypeError,
- "utime() arg 2 must be a tuple (atime, mtime)");
- Py_DECREF(opath);
- return NULL;
- }
- else {
- if (extract_time(PyTuple_GET_ITEM(arg, 0),
- &atime, &ausec) == -1) {
- Py_DECREF(opath);
- return NULL;
- }
- if (extract_time(PyTuple_GET_ITEM(arg, 1),
- &mtime, &musec) == -1) {
- Py_DECREF(opath);
- return NULL;
- }
- ATIME = atime;
- MTIME = mtime;
+ if (!PyArg_ParseTuple(args, "O&O:utime",
+ PyUnicode_FSConverter, &opath, &arg))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ if (arg == Py_None) {
+ /* optional time values not given */
+ Py_BEGIN_ALLOW_THREADS
+ res = utime(path, NULL);
+ Py_END_ALLOW_THREADS
+ }
+ else if (!PyTuple_Check(arg) || PyTuple_Size(arg) != 2) {
+ PyErr_SetString(PyExc_TypeError,
+ "utime() arg 2 must be a tuple (atime, mtime)");
+ Py_DECREF(opath);
+ return NULL;
+ }
+ else {
+ if (extract_time(PyTuple_GET_ITEM(arg, 0),
+ &atime, &ausec) == -1) {
+ Py_DECREF(opath);
+ return NULL;
+ }
+ if (extract_time(PyTuple_GET_ITEM(arg, 1),
+ &mtime, &musec) == -1) {
+ Py_DECREF(opath);
+ return NULL;
+ }
+ ATIME = atime;
+ MTIME = mtime;
#ifdef HAVE_UTIMES
- buf[0].tv_usec = ausec;
- buf[1].tv_usec = musec;
- Py_BEGIN_ALLOW_THREADS
- res = utimes(path, buf);
- Py_END_ALLOW_THREADS
+ buf[0].tv_usec = ausec;
+ buf[1].tv_usec = musec;
+ Py_BEGIN_ALLOW_THREADS
+ res = utimes(path, buf);
+ Py_END_ALLOW_THREADS
#else
- Py_BEGIN_ALLOW_THREADS
- res = utime(path, UTIME_ARG);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ res = utime(path, UTIME_ARG);
+ Py_END_ALLOW_THREADS
#endif /* HAVE_UTIMES */
- }
- if (res < 0) {
- return posix_error_with_allocated_filename(opath);
- }
- Py_DECREF(opath);
- Py_INCREF(Py_None);
- return Py_None;
+ }
+ if (res < 0) {
+ return posix_error_with_allocated_filename(opath);
+ }
+ Py_DECREF(opath);
+ Py_INCREF(Py_None);
+ return Py_None;
#undef UTIME_ARG
#undef ATIME
#undef MTIME
static PyObject *
posix__exit(PyObject *self, PyObject *args)
{
- int sts;
- if (!PyArg_ParseTuple(args, "i:_exit", &sts))
- return NULL;
- _exit(sts);
- return NULL; /* Make gcc -Wall happy */
+ int sts;
+ if (!PyArg_ParseTuple(args, "i:_exit", &sts))
+ return NULL;
+ _exit(sts);
+ return NULL; /* Make gcc -Wall happy */
}
#if defined(HAVE_EXECV) || defined(HAVE_SPAWNV)
static void
free_string_array(char **array, Py_ssize_t count)
{
- Py_ssize_t i;
- for (i = 0; i < count; i++)
- PyMem_Free(array[i]);
- PyMem_DEL(array);
+ Py_ssize_t i;
+ for (i = 0; i < count; i++)
+ PyMem_Free(array[i]);
+ PyMem_DEL(array);
}
static
int fsconvert_strdup(PyObject *o, char**out)
{
- PyObject *bytes;
- Py_ssize_t size;
- if (!PyUnicode_FSConverter(o, &bytes))
- return 0;
- size = PyBytes_GET_SIZE(bytes);
- *out = PyMem_Malloc(size+1);
- if (!*out)
- return 0;
- memcpy(*out, PyBytes_AsString(bytes), size+1);
- Py_DECREF(bytes);
- return 1;
+ PyObject *bytes;
+ Py_ssize_t size;
+ if (!PyUnicode_FSConverter(o, &bytes))
+ return 0;
+ size = PyBytes_GET_SIZE(bytes);
+ *out = PyMem_Malloc(size+1);
+ if (!*out)
+ return 0;
+ memcpy(*out, PyBytes_AsString(bytes), size+1);
+ Py_DECREF(bytes);
+ return 1;
}
#endif
"execv(path, args)\n\n\
Execute an executable path with arguments, replacing current process.\n\
\n\
- path: path of executable file\n\
- args: tuple or list of strings");
+ path: path of executable file\n\
+ args: tuple or list of strings");
static PyObject *
posix_execv(PyObject *self, PyObject *args)
{
- PyObject *opath;
- char *path;
- PyObject *argv;
- char **argvlist;
- Py_ssize_t i, argc;
- PyObject *(*getitem)(PyObject *, Py_ssize_t);
-
- /* execv has two arguments: (path, argv), where
- argv is a list or tuple of strings. */
-
- if (!PyArg_ParseTuple(args, "O&O:execv",
- PyUnicode_FSConverter,
- &opath, &argv))
- return NULL;
- path = PyBytes_AsString(opath);
- if (PyList_Check(argv)) {
- argc = PyList_Size(argv);
- getitem = PyList_GetItem;
- }
- else if (PyTuple_Check(argv)) {
- argc = PyTuple_Size(argv);
- getitem = PyTuple_GetItem;
- }
- else {
- PyErr_SetString(PyExc_TypeError, "execv() arg 2 must be a tuple or list");
- Py_DECREF(opath);
- return NULL;
- }
- if (argc < 1) {
- PyErr_SetString(PyExc_ValueError, "execv() arg 2 must not be empty");
- Py_DECREF(opath);
- return NULL;
- }
-
- argvlist = PyMem_NEW(char *, argc+1);
- if (argvlist == NULL) {
- Py_DECREF(opath);
- return PyErr_NoMemory();
- }
- for (i = 0; i < argc; i++) {
- if (!fsconvert_strdup((*getitem)(argv, i),
- &argvlist[i])) {
- free_string_array(argvlist, i);
- PyErr_SetString(PyExc_TypeError,
- "execv() arg 2 must contain only strings");
- Py_DECREF(opath);
- return NULL;
-
- }
- }
- argvlist[argc] = NULL;
-
- execv(path, argvlist);
-
- /* If we get here it's definitely an error */
-
- free_string_array(argvlist, argc);
- Py_DECREF(opath);
- return posix_error();
+ PyObject *opath;
+ char *path;
+ PyObject *argv;
+ char **argvlist;
+ Py_ssize_t i, argc;
+ PyObject *(*getitem)(PyObject *, Py_ssize_t);
+
+ /* execv has two arguments: (path, argv), where
+ argv is a list or tuple of strings. */
+
+ if (!PyArg_ParseTuple(args, "O&O:execv",
+ PyUnicode_FSConverter,
+ &opath, &argv))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ if (PyList_Check(argv)) {
+ argc = PyList_Size(argv);
+ getitem = PyList_GetItem;
+ }
+ else if (PyTuple_Check(argv)) {
+ argc = PyTuple_Size(argv);
+ getitem = PyTuple_GetItem;
+ }
+ else {
+ PyErr_SetString(PyExc_TypeError, "execv() arg 2 must be a tuple or list");
+ Py_DECREF(opath);
+ return NULL;
+ }
+ if (argc < 1) {
+ PyErr_SetString(PyExc_ValueError, "execv() arg 2 must not be empty");
+ Py_DECREF(opath);
+ return NULL;
+ }
+
+ argvlist = PyMem_NEW(char *, argc+1);
+ if (argvlist == NULL) {
+ Py_DECREF(opath);
+ return PyErr_NoMemory();
+ }
+ for (i = 0; i < argc; i++) {
+ if (!fsconvert_strdup((*getitem)(argv, i),
+ &argvlist[i])) {
+ free_string_array(argvlist, i);
+ PyErr_SetString(PyExc_TypeError,
+ "execv() arg 2 must contain only strings");
+ Py_DECREF(opath);
+ return NULL;
+
+ }
+ }
+ argvlist[argc] = NULL;
+
+ execv(path, argvlist);
+
+ /* If we get here it's definitely an error */
+
+ free_string_array(argvlist, argc);
+ Py_DECREF(opath);
+ return posix_error();
}
static char**
parse_envlist(PyObject* env, Py_ssize_t *envc_ptr)
{
- char **envlist;
- Py_ssize_t i, pos, envc;
- PyObject *keys=NULL, *vals=NULL;
- PyObject *key, *val, *key2, *val2;
- char *p, *k, *v;
- size_t len;
-
- i = PyMapping_Size(env);
- if (i < 0)
- return NULL;
- envlist = PyMem_NEW(char *, i + 1);
- if (envlist == NULL) {
- PyErr_NoMemory();
- return NULL;
- }
- envc = 0;
- keys = PyMapping_Keys(env);
- vals = PyMapping_Values(env);
- if (!keys || !vals)
- goto error;
- if (!PyList_Check(keys) || !PyList_Check(vals)) {
- PyErr_Format(PyExc_TypeError,
- "env.keys() or env.values() is not a list");
- goto error;
- }
-
- for (pos = 0; pos < i; pos++) {
- key = PyList_GetItem(keys, pos);
- val = PyList_GetItem(vals, pos);
- if (!key || !val)
- goto error;
-
- if (PyUnicode_FSConverter(key, &key2) == 0)
- goto error;
- if (PyUnicode_FSConverter(val, &val2) == 0) {
- Py_DECREF(key2);
- goto error;
- }
+ char **envlist;
+ Py_ssize_t i, pos, envc;
+ PyObject *keys=NULL, *vals=NULL;
+ PyObject *key, *val, *key2, *val2;
+ char *p, *k, *v;
+ size_t len;
+
+ i = PyMapping_Size(env);
+ if (i < 0)
+ return NULL;
+ envlist = PyMem_NEW(char *, i + 1);
+ if (envlist == NULL) {
+ PyErr_NoMemory();
+ return NULL;
+ }
+ envc = 0;
+ keys = PyMapping_Keys(env);
+ vals = PyMapping_Values(env);
+ if (!keys || !vals)
+ goto error;
+ if (!PyList_Check(keys) || !PyList_Check(vals)) {
+ PyErr_Format(PyExc_TypeError,
+ "env.keys() or env.values() is not a list");
+ goto error;
+ }
+
+ for (pos = 0; pos < i; pos++) {
+ key = PyList_GetItem(keys, pos);
+ val = PyList_GetItem(vals, pos);
+ if (!key || !val)
+ goto error;
+
+ if (PyUnicode_FSConverter(key, &key2) == 0)
+ goto error;
+ if (PyUnicode_FSConverter(val, &val2) == 0) {
+ Py_DECREF(key2);
+ goto error;
+ }
#if defined(PYOS_OS2)
- /* Omit Pseudo-Env Vars that Would Confuse Programs if Passed On */
- if (stricmp(k, "BEGINLIBPATH") != 0 && stricmp(k, "ENDLIBPATH") != 0) {
-#endif
- k = PyBytes_AsString(key2);
- v = PyBytes_AsString(val2);
- len = PyBytes_GET_SIZE(key2) + PyBytes_GET_SIZE(val2) + 2;
-
- p = PyMem_NEW(char, len);
- if (p == NULL) {
- PyErr_NoMemory();
- Py_DECREF(key2);
- Py_DECREF(val2);
- goto error;
- }
- PyOS_snprintf(p, len, "%s=%s", k, v);
- envlist[envc++] = p;
- Py_DECREF(key2);
- Py_DECREF(val2);
+ /* Omit Pseudo-Env Vars that Would Confuse Programs if Passed On */
+ if (stricmp(k, "BEGINLIBPATH") != 0 && stricmp(k, "ENDLIBPATH") != 0) {
+#endif
+ k = PyBytes_AsString(key2);
+ v = PyBytes_AsString(val2);
+ len = PyBytes_GET_SIZE(key2) + PyBytes_GET_SIZE(val2) + 2;
+
+ p = PyMem_NEW(char, len);
+ if (p == NULL) {
+ PyErr_NoMemory();
+ Py_DECREF(key2);
+ Py_DECREF(val2);
+ goto error;
+ }
+ PyOS_snprintf(p, len, "%s=%s", k, v);
+ envlist[envc++] = p;
+ Py_DECREF(key2);
+ Py_DECREF(val2);
#if defined(PYOS_OS2)
- }
+ }
#endif
- }
- Py_DECREF(vals);
- Py_DECREF(keys);
+ }
+ Py_DECREF(vals);
+ Py_DECREF(keys);
- envlist[envc] = 0;
- *envc_ptr = envc;
- return envlist;
+ envlist[envc] = 0;
+ *envc_ptr = envc;
+ return envlist;
error:
- Py_XDECREF(keys);
- Py_XDECREF(vals);
- while (--envc >= 0)
- PyMem_DEL(envlist[envc]);
- PyMem_DEL(envlist);
- return NULL;
+ Py_XDECREF(keys);
+ Py_XDECREF(vals);
+ while (--envc >= 0)
+ PyMem_DEL(envlist[envc]);
+ PyMem_DEL(envlist);
+ return NULL;
}
PyDoc_STRVAR(posix_execve__doc__,
"execve(path, args, env)\n\n\
Execute a path with arguments and environment, replacing current process.\n\
\n\
- path: path of executable file\n\
- args: tuple or list of arguments\n\
- env: dictionary of strings mapping to strings");
+ path: path of executable file\n\
+ args: tuple or list of arguments\n\
+ env: dictionary of strings mapping to strings");
static PyObject *
posix_execve(PyObject *self, PyObject *args)
{
- PyObject *opath;
- char *path;
- PyObject *argv, *env;
- char **argvlist;
- char **envlist;
- Py_ssize_t i, argc, envc;
- PyObject *(*getitem)(PyObject *, Py_ssize_t);
- Py_ssize_t lastarg = 0;
-
- /* execve has three arguments: (path, argv, env), where
- argv is a list or tuple of strings and env is a dictionary
- like posix.environ. */
-
- if (!PyArg_ParseTuple(args, "O&OO:execve",
- PyUnicode_FSConverter,
- &opath, &argv, &env))
- return NULL;
- path = PyBytes_AsString(opath);
- if (PyList_Check(argv)) {
- argc = PyList_Size(argv);
- getitem = PyList_GetItem;
- }
- else if (PyTuple_Check(argv)) {
- argc = PyTuple_Size(argv);
- getitem = PyTuple_GetItem;
- }
- else {
- PyErr_SetString(PyExc_TypeError,
- "execve() arg 2 must be a tuple or list");
- goto fail_0;
- }
- if (!PyMapping_Check(env)) {
- PyErr_SetString(PyExc_TypeError,
- "execve() arg 3 must be a mapping object");
- goto fail_0;
- }
-
- argvlist = PyMem_NEW(char *, argc+1);
- if (argvlist == NULL) {
- PyErr_NoMemory();
- goto fail_0;
- }
- for (i = 0; i < argc; i++) {
- if (!fsconvert_strdup((*getitem)(argv, i),
- &argvlist[i]))
- {
- lastarg = i;
- goto fail_1;
- }
- }
- lastarg = argc;
- argvlist[argc] = NULL;
-
- envlist = parse_envlist(env, &envc);
- if (envlist == NULL)
- goto fail_1;
-
- execve(path, argvlist, envlist);
-
- /* If we get here it's definitely an error */
-
- (void) posix_error();
-
- while (--envc >= 0)
- PyMem_DEL(envlist[envc]);
- PyMem_DEL(envlist);
+ PyObject *opath;
+ char *path;
+ PyObject *argv, *env;
+ char **argvlist;
+ char **envlist;
+ Py_ssize_t i, argc, envc;
+ PyObject *(*getitem)(PyObject *, Py_ssize_t);
+ Py_ssize_t lastarg = 0;
+
+ /* execve has three arguments: (path, argv, env), where
+ argv is a list or tuple of strings and env is a dictionary
+ like posix.environ. */
+
+ if (!PyArg_ParseTuple(args, "O&OO:execve",
+ PyUnicode_FSConverter,
+ &opath, &argv, &env))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ if (PyList_Check(argv)) {
+ argc = PyList_Size(argv);
+ getitem = PyList_GetItem;
+ }
+ else if (PyTuple_Check(argv)) {
+ argc = PyTuple_Size(argv);
+ getitem = PyTuple_GetItem;
+ }
+ else {
+ PyErr_SetString(PyExc_TypeError,
+ "execve() arg 2 must be a tuple or list");
+ goto fail_0;
+ }
+ if (!PyMapping_Check(env)) {
+ PyErr_SetString(PyExc_TypeError,
+ "execve() arg 3 must be a mapping object");
+ goto fail_0;
+ }
+
+ argvlist = PyMem_NEW(char *, argc+1);
+ if (argvlist == NULL) {
+ PyErr_NoMemory();
+ goto fail_0;
+ }
+ for (i = 0; i < argc; i++) {
+ if (!fsconvert_strdup((*getitem)(argv, i),
+ &argvlist[i]))
+ {
+ lastarg = i;
+ goto fail_1;
+ }
+ }
+ lastarg = argc;
+ argvlist[argc] = NULL;
+
+ envlist = parse_envlist(env, &envc);
+ if (envlist == NULL)
+ goto fail_1;
+
+ execve(path, argvlist, envlist);
+
+ /* If we get here it's definitely an error */
+
+ (void) posix_error();
+
+ while (--envc >= 0)
+ PyMem_DEL(envlist[envc]);
+ PyMem_DEL(envlist);
fail_1:
- free_string_array(argvlist, lastarg);
+ free_string_array(argvlist, lastarg);
fail_0:
- Py_DECREF(opath);
- return NULL;
+ Py_DECREF(opath);
+ return NULL;
}
#endif /* HAVE_EXECV */
"spawnv(mode, path, args)\n\n\
Execute the program 'path' in a new process.\n\
\n\
- mode: mode of process creation\n\
- path: path of executable file\n\
- args: tuple or list of strings");
+ mode: mode of process creation\n\
+ path: path of executable file\n\
+ args: tuple or list of strings");
static PyObject *
posix_spawnv(PyObject *self, PyObject *args)
{
- PyObject *opath;
- char *path;
- PyObject *argv;
- char **argvlist;
- int mode, i;
- Py_ssize_t argc;
- Py_intptr_t spawnval;
- PyObject *(*getitem)(PyObject *, Py_ssize_t);
-
- /* spawnv has three arguments: (mode, path, argv), where
- argv is a list or tuple of strings. */
-
- if (!PyArg_ParseTuple(args, "iO&O:spawnv", &mode,
- PyUnicode_FSConverter,
- &opath, &argv))
- return NULL;
- path = PyBytes_AsString(opath);
- if (PyList_Check(argv)) {
- argc = PyList_Size(argv);
- getitem = PyList_GetItem;
- }
- else if (PyTuple_Check(argv)) {
- argc = PyTuple_Size(argv);
- getitem = PyTuple_GetItem;
- }
- else {
- PyErr_SetString(PyExc_TypeError,
- "spawnv() arg 2 must be a tuple or list");
- Py_DECREF(opath);
- return NULL;
- }
-
- argvlist = PyMem_NEW(char *, argc+1);
- if (argvlist == NULL) {
- Py_DECREF(opath);
- return PyErr_NoMemory();
- }
- for (i = 0; i < argc; i++) {
- if (!fsconvert_strdup((*getitem)(argv, i),
- &argvlist[i])) {
- free_string_array(argvlist, i);
- PyErr_SetString(
- PyExc_TypeError,
- "spawnv() arg 2 must contain only strings");
- Py_DECREF(opath);
- return NULL;
- }
- }
- argvlist[argc] = NULL;
+ PyObject *opath;
+ char *path;
+ PyObject *argv;
+ char **argvlist;
+ int mode, i;
+ Py_ssize_t argc;
+ Py_intptr_t spawnval;
+ PyObject *(*getitem)(PyObject *, Py_ssize_t);
+
+ /* spawnv has three arguments: (mode, path, argv), where
+ argv is a list or tuple of strings. */
+
+ if (!PyArg_ParseTuple(args, "iO&O:spawnv", &mode,
+ PyUnicode_FSConverter,
+ &opath, &argv))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ if (PyList_Check(argv)) {
+ argc = PyList_Size(argv);
+ getitem = PyList_GetItem;
+ }
+ else if (PyTuple_Check(argv)) {
+ argc = PyTuple_Size(argv);
+ getitem = PyTuple_GetItem;
+ }
+ else {
+ PyErr_SetString(PyExc_TypeError,
+ "spawnv() arg 2 must be a tuple or list");
+ Py_DECREF(opath);
+ return NULL;
+ }
+
+ argvlist = PyMem_NEW(char *, argc+1);
+ if (argvlist == NULL) {
+ Py_DECREF(opath);
+ return PyErr_NoMemory();
+ }
+ for (i = 0; i < argc; i++) {
+ if (!fsconvert_strdup((*getitem)(argv, i),
+ &argvlist[i])) {
+ free_string_array(argvlist, i);
+ PyErr_SetString(
+ PyExc_TypeError,
+ "spawnv() arg 2 must contain only strings");
+ Py_DECREF(opath);
+ return NULL;
+ }
+ }
+ argvlist[argc] = NULL;
#if defined(PYOS_OS2) && defined(PYCC_GCC)
- Py_BEGIN_ALLOW_THREADS
- spawnval = spawnv(mode, path, argvlist);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ spawnval = spawnv(mode, path, argvlist);
+ Py_END_ALLOW_THREADS
#else
- if (mode == _OLD_P_OVERLAY)
- mode = _P_OVERLAY;
+ if (mode == _OLD_P_OVERLAY)
+ mode = _P_OVERLAY;
- Py_BEGIN_ALLOW_THREADS
- spawnval = _spawnv(mode, path, argvlist);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ spawnval = _spawnv(mode, path, argvlist);
+ Py_END_ALLOW_THREADS
#endif
- free_string_array(argvlist, argc);
- Py_DECREF(opath);
+ free_string_array(argvlist, argc);
+ Py_DECREF(opath);
- if (spawnval == -1)
- return posix_error();
- else
+ if (spawnval == -1)
+ return posix_error();
+ else
#if SIZEOF_LONG == SIZEOF_VOID_P
- return Py_BuildValue("l", (long) spawnval);
+ return Py_BuildValue("l", (long) spawnval);
#else
- return Py_BuildValue("L", (PY_LONG_LONG) spawnval);
+ return Py_BuildValue("L", (PY_LONG_LONG) spawnval);
#endif
}
"spawnve(mode, path, args, env)\n\n\
Execute the program 'path' in a new process.\n\
\n\
- mode: mode of process creation\n\
- path: path of executable file\n\
- args: tuple or list of arguments\n\
- env: dictionary of strings mapping to strings");
+ mode: mode of process creation\n\
+ path: path of executable file\n\
+ args: tuple or list of arguments\n\
+ env: dictionary of strings mapping to strings");
static PyObject *
posix_spawnve(PyObject *self, PyObject *args)
{
- PyObject *opath;
- char *path;
- PyObject *argv, *env;
- char **argvlist;
- char **envlist;
- PyObject *res = NULL;
- int mode, envc;
- Py_ssize_t argc, i;
- Py_intptr_t spawnval;
- PyObject *(*getitem)(PyObject *, Py_ssize_t);
- Py_ssize_t lastarg = 0;
-
- /* spawnve has four arguments: (mode, path, argv, env), where
- argv is a list or tuple of strings and env is a dictionary
- like posix.environ. */
-
- if (!PyArg_ParseTuple(args, "iO&OO:spawnve", &mode,
- PyUnicode_FSConverter,
- &opath, &argv, &env))
- return NULL;
- path = PyBytes_AsString(opath);
- if (PyList_Check(argv)) {
- argc = PyList_Size(argv);
- getitem = PyList_GetItem;
- }
- else if (PyTuple_Check(argv)) {
- argc = PyTuple_Size(argv);
- getitem = PyTuple_GetItem;
- }
- else {
- PyErr_SetString(PyExc_TypeError,
- "spawnve() arg 2 must be a tuple or list");
- goto fail_0;
- }
- if (!PyMapping_Check(env)) {
- PyErr_SetString(PyExc_TypeError,
- "spawnve() arg 3 must be a mapping object");
- goto fail_0;
- }
-
- argvlist = PyMem_NEW(char *, argc+1);
- if (argvlist == NULL) {
- PyErr_NoMemory();
- goto fail_0;
- }
- for (i = 0; i < argc; i++) {
- if (!fsconvert_strdup((*getitem)(argv, i),
- &argvlist[i]))
- {
- lastarg = i;
- goto fail_1;
- }
- }
- lastarg = argc;
- argvlist[argc] = NULL;
-
- envlist = parse_envlist(env, &envc);
- if (envlist == NULL)
- goto fail_1;
+ PyObject *opath;
+ char *path;
+ PyObject *argv, *env;
+ char **argvlist;
+ char **envlist;
+ PyObject *res = NULL;
+ int mode, envc;
+ Py_ssize_t argc, i;
+ Py_intptr_t spawnval;
+ PyObject *(*getitem)(PyObject *, Py_ssize_t);
+ Py_ssize_t lastarg = 0;
+
+ /* spawnve has four arguments: (mode, path, argv, env), where
+ argv is a list or tuple of strings and env is a dictionary
+ like posix.environ. */
+
+ if (!PyArg_ParseTuple(args, "iO&OO:spawnve", &mode,
+ PyUnicode_FSConverter,
+ &opath, &argv, &env))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ if (PyList_Check(argv)) {
+ argc = PyList_Size(argv);
+ getitem = PyList_GetItem;
+ }
+ else if (PyTuple_Check(argv)) {
+ argc = PyTuple_Size(argv);
+ getitem = PyTuple_GetItem;
+ }
+ else {
+ PyErr_SetString(PyExc_TypeError,
+ "spawnve() arg 2 must be a tuple or list");
+ goto fail_0;
+ }
+ if (!PyMapping_Check(env)) {
+ PyErr_SetString(PyExc_TypeError,
+ "spawnve() arg 3 must be a mapping object");
+ goto fail_0;
+ }
+
+ argvlist = PyMem_NEW(char *, argc+1);
+ if (argvlist == NULL) {
+ PyErr_NoMemory();
+ goto fail_0;
+ }
+ for (i = 0; i < argc; i++) {
+ if (!fsconvert_strdup((*getitem)(argv, i),
+ &argvlist[i]))
+ {
+ lastarg = i;
+ goto fail_1;
+ }
+ }
+ lastarg = argc;
+ argvlist[argc] = NULL;
+
+ envlist = parse_envlist(env, &envc);
+ if (envlist == NULL)
+ goto fail_1;
#if defined(PYOS_OS2) && defined(PYCC_GCC)
- Py_BEGIN_ALLOW_THREADS
- spawnval = spawnve(mode, path, argvlist, envlist);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ spawnval = spawnve(mode, path, argvlist, envlist);
+ Py_END_ALLOW_THREADS
#else
- if (mode == _OLD_P_OVERLAY)
- mode = _P_OVERLAY;
+ if (mode == _OLD_P_OVERLAY)
+ mode = _P_OVERLAY;
- Py_BEGIN_ALLOW_THREADS
- spawnval = _spawnve(mode, path, argvlist, envlist);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ spawnval = _spawnve(mode, path, argvlist, envlist);
+ Py_END_ALLOW_THREADS
#endif
- if (spawnval == -1)
- (void) posix_error();
- else
+ if (spawnval == -1)
+ (void) posix_error();
+ else
#if SIZEOF_LONG == SIZEOF_VOID_P
- res = Py_BuildValue("l", (long) spawnval);
+ res = Py_BuildValue("l", (long) spawnval);
#else
- res = Py_BuildValue("L", (PY_LONG_LONG) spawnval);
+ res = Py_BuildValue("L", (PY_LONG_LONG) spawnval);
#endif
- while (--envc >= 0)
- PyMem_DEL(envlist[envc]);
- PyMem_DEL(envlist);
+ while (--envc >= 0)
+ PyMem_DEL(envlist[envc]);
+ PyMem_DEL(envlist);
fail_1:
- free_string_array(argvlist, lastarg);
+ free_string_array(argvlist, lastarg);
fail_0:
- Py_DECREF(opath);
- return res;
+ Py_DECREF(opath);
+ return res;
}
/* OS/2 supports spawnvp & spawnvpe natively */
Execute the program 'file' in a new process, using the environment\n\
search path to find the file.\n\
\n\
- mode: mode of process creation\n\
- file: executable file name\n\
- args: tuple or list of strings");
+ mode: mode of process creation\n\
+ file: executable file name\n\
+ args: tuple or list of strings");
static PyObject *
posix_spawnvp(PyObject *self, PyObject *args)
{
- PyObject *opath;
- char *path;
- PyObject *argv;
- char **argvlist;
- int mode, i, argc;
- Py_intptr_t spawnval;
- PyObject *(*getitem)(PyObject *, Py_ssize_t);
-
- /* spawnvp has three arguments: (mode, path, argv), where
- argv is a list or tuple of strings. */
-
- if (!PyArg_ParseTuple(args, "iO&O:spawnvp", &mode,
- PyUnicode_FSConverter,
- &opath, &argv))
- return NULL;
- path = PyBytes_AsString(opath);
- if (PyList_Check(argv)) {
- argc = PyList_Size(argv);
- getitem = PyList_GetItem;
- }
- else if (PyTuple_Check(argv)) {
- argc = PyTuple_Size(argv);
- getitem = PyTuple_GetItem;
- }
- else {
- PyErr_SetString(PyExc_TypeError,
- "spawnvp() arg 2 must be a tuple or list");
- Py_DECREF(opath);
- return NULL;
- }
-
- argvlist = PyMem_NEW(char *, argc+1);
- if (argvlist == NULL) {
- Py_DECREF(opath);
- return PyErr_NoMemory();
- }
- for (i = 0; i < argc; i++) {
- if (!fsconvert_strdup((*getitem)(argv, i),
- &argvlist[i])) {
- free_string_array(argvlist, i);
- PyErr_SetString(
- PyExc_TypeError,
- "spawnvp() arg 2 must contain only strings");
- Py_DECREF(opath);
- return NULL;
- }
- }
- argvlist[argc] = NULL;
-
- Py_BEGIN_ALLOW_THREADS
+ PyObject *opath;
+ char *path;
+ PyObject *argv;
+ char **argvlist;
+ int mode, i, argc;
+ Py_intptr_t spawnval;
+ PyObject *(*getitem)(PyObject *, Py_ssize_t);
+
+ /* spawnvp has three arguments: (mode, path, argv), where
+ argv is a list or tuple of strings. */
+
+ if (!PyArg_ParseTuple(args, "iO&O:spawnvp", &mode,
+ PyUnicode_FSConverter,
+ &opath, &argv))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ if (PyList_Check(argv)) {
+ argc = PyList_Size(argv);
+ getitem = PyList_GetItem;
+ }
+ else if (PyTuple_Check(argv)) {
+ argc = PyTuple_Size(argv);
+ getitem = PyTuple_GetItem;
+ }
+ else {
+ PyErr_SetString(PyExc_TypeError,
+ "spawnvp() arg 2 must be a tuple or list");
+ Py_DECREF(opath);
+ return NULL;
+ }
+
+ argvlist = PyMem_NEW(char *, argc+1);
+ if (argvlist == NULL) {
+ Py_DECREF(opath);
+ return PyErr_NoMemory();
+ }
+ for (i = 0; i < argc; i++) {
+ if (!fsconvert_strdup((*getitem)(argv, i),
+ &argvlist[i])) {
+ free_string_array(argvlist, i);
+ PyErr_SetString(
+ PyExc_TypeError,
+ "spawnvp() arg 2 must contain only strings");
+ Py_DECREF(opath);
+ return NULL;
+ }
+ }
+ argvlist[argc] = NULL;
+
+ Py_BEGIN_ALLOW_THREADS
#if defined(PYCC_GCC)
- spawnval = spawnvp(mode, path, argvlist);
+ spawnval = spawnvp(mode, path, argvlist);
#else
- spawnval = _spawnvp(mode, path, argvlist);
+ spawnval = _spawnvp(mode, path, argvlist);
#endif
- Py_END_ALLOW_THREADS
+ Py_END_ALLOW_THREADS
- free_string_array(argvlist, argc);
- Py_DECREF(opath);
+ free_string_array(argvlist, argc);
+ Py_DECREF(opath);
- if (spawnval == -1)
- return posix_error();
- else
- return Py_BuildValue("l", (long) spawnval);
+ if (spawnval == -1)
+ return posix_error();
+ else
+ return Py_BuildValue("l", (long) spawnval);
}
Execute the program 'file' in a new process, using the environment\n\
search path to find the file.\n\
\n\
- mode: mode of process creation\n\
- file: executable file name\n\
- args: tuple or list of arguments\n\
- env: dictionary of strings mapping to strings");
+ mode: mode of process creation\n\
+ file: executable file name\n\
+ args: tuple or list of arguments\n\
+ env: dictionary of strings mapping to strings");
static PyObject *
posix_spawnvpe(PyObject *self, PyObject *args)
{
- PyObject *opath
- char *path;
- PyObject *argv, *env;
- char **argvlist;
- char **envlist;
- PyObject *res=NULL;
- int mode, i, argc, envc;
- Py_intptr_t spawnval;
- PyObject *(*getitem)(PyObject *, Py_ssize_t);
- int lastarg = 0;
-
- /* spawnvpe has four arguments: (mode, path, argv, env), where
- argv is a list or tuple of strings and env is a dictionary
- like posix.environ. */
-
- if (!PyArg_ParseTuple(args, "ietOO:spawnvpe", &mode,
- PyUnicode_FSConverter,
- &opath, &argv, &env))
- return NULL;
- path = PyBytes_AsString(opath);
- if (PyList_Check(argv)) {
- argc = PyList_Size(argv);
- getitem = PyList_GetItem;
- }
- else if (PyTuple_Check(argv)) {
- argc = PyTuple_Size(argv);
- getitem = PyTuple_GetItem;
- }
- else {
- PyErr_SetString(PyExc_TypeError,
- "spawnvpe() arg 2 must be a tuple or list");
- goto fail_0;
- }
- if (!PyMapping_Check(env)) {
- PyErr_SetString(PyExc_TypeError,
- "spawnvpe() arg 3 must be a mapping object");
- goto fail_0;
- }
-
- argvlist = PyMem_NEW(char *, argc+1);
- if (argvlist == NULL) {
- PyErr_NoMemory();
- goto fail_0;
- }
- for (i = 0; i < argc; i++) {
- if (!fsconvert_strdup((*getitem)(argv, i),
- &argvlist[i]))
- {
- lastarg = i;
- goto fail_1;
- }
- }
- lastarg = argc;
- argvlist[argc] = NULL;
-
- envlist = parse_envlist(env, &envc);
- if (envlist == NULL)
- goto fail_1;
-
- Py_BEGIN_ALLOW_THREADS
+ PyObject *opath
+ char *path;
+ PyObject *argv, *env;
+ char **argvlist;
+ char **envlist;
+ PyObject *res=NULL;
+ int mode, i, argc, envc;
+ Py_intptr_t spawnval;
+ PyObject *(*getitem)(PyObject *, Py_ssize_t);
+ int lastarg = 0;
+
+ /* spawnvpe has four arguments: (mode, path, argv, env), where
+ argv is a list or tuple of strings and env is a dictionary
+ like posix.environ. */
+
+ if (!PyArg_ParseTuple(args, "ietOO:spawnvpe", &mode,
+ PyUnicode_FSConverter,
+ &opath, &argv, &env))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ if (PyList_Check(argv)) {
+ argc = PyList_Size(argv);
+ getitem = PyList_GetItem;
+ }
+ else if (PyTuple_Check(argv)) {
+ argc = PyTuple_Size(argv);
+ getitem = PyTuple_GetItem;
+ }
+ else {
+ PyErr_SetString(PyExc_TypeError,
+ "spawnvpe() arg 2 must be a tuple or list");
+ goto fail_0;
+ }
+ if (!PyMapping_Check(env)) {
+ PyErr_SetString(PyExc_TypeError,
+ "spawnvpe() arg 3 must be a mapping object");
+ goto fail_0;
+ }
+
+ argvlist = PyMem_NEW(char *, argc+1);
+ if (argvlist == NULL) {
+ PyErr_NoMemory();
+ goto fail_0;
+ }
+ for (i = 0; i < argc; i++) {
+ if (!fsconvert_strdup((*getitem)(argv, i),
+ &argvlist[i]))
+ {
+ lastarg = i;
+ goto fail_1;
+ }
+ }
+ lastarg = argc;
+ argvlist[argc] = NULL;
+
+ envlist = parse_envlist(env, &envc);
+ if (envlist == NULL)
+ goto fail_1;
+
+ Py_BEGIN_ALLOW_THREADS
#if defined(PYCC_GCC)
- spawnval = spawnvpe(mode, path, argvlist, envlist);
+ spawnval = spawnvpe(mode, path, argvlist, envlist);
#else
- spawnval = _spawnvpe(mode, path, argvlist, envlist);
+ spawnval = _spawnvpe(mode, path, argvlist, envlist);
#endif
- Py_END_ALLOW_THREADS
+ Py_END_ALLOW_THREADS
- if (spawnval == -1)
- (void) posix_error();
- else
- res = Py_BuildValue("l", (long) spawnval);
+ if (spawnval == -1)
+ (void) posix_error();
+ else
+ res = Py_BuildValue("l", (long) spawnval);
- while (--envc >= 0)
- PyMem_DEL(envlist[envc]);
- PyMem_DEL(envlist);
+ while (--envc >= 0)
+ PyMem_DEL(envlist[envc]);
+ PyMem_DEL(envlist);
fail_1:
- free_string_array(argvlist, lastarg);
+ free_string_array(argvlist, lastarg);
fail_0:
- Py_DECREF(opath);
- return res;
+ Py_DECREF(opath);
+ return res;
}
#endif /* PYOS_OS2 */
#endif /* HAVE_SPAWNV */
static PyObject *
posix_fork1(PyObject *self, PyObject *noargs)
{
- pid_t pid;
- int result = 0;
- _PyImport_AcquireLock();
- pid = fork1();
- if (pid == 0) {
- /* child: this clobbers and resets the import lock. */
- PyOS_AfterFork();
- } else {
- /* parent: release the import lock. */
- result = _PyImport_ReleaseLock();
- }
- if (pid == -1)
- return posix_error();
- if (result < 0) {
- /* Don't clobber the OSError if the fork failed. */
- PyErr_SetString(PyExc_RuntimeError,
- "not holding the import lock");
- return NULL;
- }
- return PyLong_FromPid(pid);
+ pid_t pid;
+ int result = 0;
+ _PyImport_AcquireLock();
+ pid = fork1();
+ if (pid == 0) {
+ /* child: this clobbers and resets the import lock. */
+ PyOS_AfterFork();
+ } else {
+ /* parent: release the import lock. */
+ result = _PyImport_ReleaseLock();
+ }
+ if (pid == -1)
+ return posix_error();
+ if (result < 0) {
+ /* Don't clobber the OSError if the fork failed. */
+ PyErr_SetString(PyExc_RuntimeError,
+ "not holding the import lock");
+ return NULL;
+ }
+ return PyLong_FromPid(pid);
}
#endif
static PyObject *
posix_fork(PyObject *self, PyObject *noargs)
{
- pid_t pid;
- int result = 0;
- _PyImport_AcquireLock();
- pid = fork();
- if (pid == 0) {
- /* child: this clobbers and resets the import lock. */
- PyOS_AfterFork();
- } else {
- /* parent: release the import lock. */
- result = _PyImport_ReleaseLock();
- }
- if (pid == -1)
- return posix_error();
- if (result < 0) {
- /* Don't clobber the OSError if the fork failed. */
- PyErr_SetString(PyExc_RuntimeError,
- "not holding the import lock");
- return NULL;
- }
- return PyLong_FromPid(pid);
+ pid_t pid;
+ int result = 0;
+ _PyImport_AcquireLock();
+ pid = fork();
+ if (pid == 0) {
+ /* child: this clobbers and resets the import lock. */
+ PyOS_AfterFork();
+ } else {
+ /* parent: release the import lock. */
+ result = _PyImport_ReleaseLock();
+ }
+ if (pid == -1)
+ return posix_error();
+ if (result < 0) {
+ /* Don't clobber the OSError if the fork failed. */
+ PyErr_SetString(PyExc_RuntimeError,
+ "not holding the import lock");
+ return NULL;
+ }
+ return PyLong_FromPid(pid);
}
#endif
static PyObject *
posix_openpty(PyObject *self, PyObject *noargs)
{
- int master_fd, slave_fd;
+ int master_fd, slave_fd;
#ifndef HAVE_OPENPTY
- char * slave_name;
+ char * slave_name;
#endif
#if defined(HAVE_DEV_PTMX) && !defined(HAVE_OPENPTY) && !defined(HAVE__GETPTY)
- PyOS_sighandler_t sig_saved;
+ PyOS_sighandler_t sig_saved;
#ifdef sun
- extern char *ptsname(int fildes);
+ extern char *ptsname(int fildes);
#endif
#endif
#ifdef HAVE_OPENPTY
- if (openpty(&master_fd, &slave_fd, NULL, NULL, NULL) != 0)
- return posix_error();
+ if (openpty(&master_fd, &slave_fd, NULL, NULL, NULL) != 0)
+ return posix_error();
#elif defined(HAVE__GETPTY)
- slave_name = _getpty(&master_fd, O_RDWR, 0666, 0);
- if (slave_name == NULL)
- return posix_error();
+ slave_name = _getpty(&master_fd, O_RDWR, 0666, 0);
+ if (slave_name == NULL)
+ return posix_error();
- slave_fd = open(slave_name, O_RDWR);
- if (slave_fd < 0)
- return posix_error();
+ slave_fd = open(slave_name, O_RDWR);
+ if (slave_fd < 0)
+ return posix_error();
#else
- master_fd = open(DEV_PTY_FILE, O_RDWR | O_NOCTTY); /* open master */
- if (master_fd < 0)
- return posix_error();
- sig_saved = PyOS_setsig(SIGCHLD, SIG_DFL);
- /* change permission of slave */
- if (grantpt(master_fd) < 0) {
- PyOS_setsig(SIGCHLD, sig_saved);
- return posix_error();
- }
- /* unlock slave */
- if (unlockpt(master_fd) < 0) {
- PyOS_setsig(SIGCHLD, sig_saved);
- return posix_error();
- }
- PyOS_setsig(SIGCHLD, sig_saved);
- slave_name = ptsname(master_fd); /* get name of slave */
- if (slave_name == NULL)
- return posix_error();
- slave_fd = open(slave_name, O_RDWR | O_NOCTTY); /* open slave */
- if (slave_fd < 0)
- return posix_error();
+ master_fd = open(DEV_PTY_FILE, O_RDWR | O_NOCTTY); /* open master */
+ if (master_fd < 0)
+ return posix_error();
+ sig_saved = PyOS_setsig(SIGCHLD, SIG_DFL);
+ /* change permission of slave */
+ if (grantpt(master_fd) < 0) {
+ PyOS_setsig(SIGCHLD, sig_saved);
+ return posix_error();
+ }
+ /* unlock slave */
+ if (unlockpt(master_fd) < 0) {
+ PyOS_setsig(SIGCHLD, sig_saved);
+ return posix_error();
+ }
+ PyOS_setsig(SIGCHLD, sig_saved);
+ slave_name = ptsname(master_fd); /* get name of slave */
+ if (slave_name == NULL)
+ return posix_error();
+ slave_fd = open(slave_name, O_RDWR | O_NOCTTY); /* open slave */
+ if (slave_fd < 0)
+ return posix_error();
#if !defined(__CYGWIN__) && !defined(HAVE_DEV_PTC)
- ioctl(slave_fd, I_PUSH, "ptem"); /* push ptem */
- ioctl(slave_fd, I_PUSH, "ldterm"); /* push ldterm */
+ ioctl(slave_fd, I_PUSH, "ptem"); /* push ptem */
+ ioctl(slave_fd, I_PUSH, "ldterm"); /* push ldterm */
#ifndef __hpux
- ioctl(slave_fd, I_PUSH, "ttcompat"); /* push ttcompat */
+ ioctl(slave_fd, I_PUSH, "ttcompat"); /* push ttcompat */
#endif /* __hpux */
#endif /* HAVE_CYGWIN */
#endif /* HAVE_OPENPTY */
- return Py_BuildValue("(ii)", master_fd, slave_fd);
+ return Py_BuildValue("(ii)", master_fd, slave_fd);
}
#endif /* defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX) */
static PyObject *
posix_forkpty(PyObject *self, PyObject *noargs)
{
- int master_fd = -1, result = 0;
- pid_t pid;
-
- _PyImport_AcquireLock();
- pid = forkpty(&master_fd, NULL, NULL, NULL);
- if (pid == 0) {
- /* child: this clobbers and resets the import lock. */
- PyOS_AfterFork();
- } else {
- /* parent: release the import lock. */
- result = _PyImport_ReleaseLock();
- }
- if (pid == -1)
- return posix_error();
- if (result < 0) {
- /* Don't clobber the OSError if the fork failed. */
- PyErr_SetString(PyExc_RuntimeError,
- "not holding the import lock");
- return NULL;
- }
- return Py_BuildValue("(Ni)", PyLong_FromPid(pid), master_fd);
+ int master_fd = -1, result = 0;
+ pid_t pid;
+
+ _PyImport_AcquireLock();
+ pid = forkpty(&master_fd, NULL, NULL, NULL);
+ if (pid == 0) {
+ /* child: this clobbers and resets the import lock. */
+ PyOS_AfterFork();
+ } else {
+ /* parent: release the import lock. */
+ result = _PyImport_ReleaseLock();
+ }
+ if (pid == -1)
+ return posix_error();
+ if (result < 0) {
+ /* Don't clobber the OSError if the fork failed. */
+ PyErr_SetString(PyExc_RuntimeError,
+ "not holding the import lock");
+ return NULL;
+ }
+ return Py_BuildValue("(Ni)", PyLong_FromPid(pid), master_fd);
}
#endif
static PyObject *
posix_getegid(PyObject *self, PyObject *noargs)
{
- return PyLong_FromLong((long)getegid());
+ return PyLong_FromLong((long)getegid());
}
#endif
static PyObject *
posix_geteuid(PyObject *self, PyObject *noargs)
{
- return PyLong_FromLong((long)geteuid());
+ return PyLong_FromLong((long)geteuid());
}
#endif
static PyObject *
posix_getgid(PyObject *self, PyObject *noargs)
{
- return PyLong_FromLong((long)getgid());
+ return PyLong_FromLong((long)getgid());
}
#endif
static PyObject *
posix_getpid(PyObject *self, PyObject *noargs)
{
- return PyLong_FromPid(getpid());
+ return PyLong_FromPid(getpid());
}
#ifdef NGROUPS_MAX
#define MAX_GROUPS NGROUPS_MAX
#else
- /* defined to be 16 on Solaris7, so this should be a small number */
+ /* defined to be 16 on Solaris7, so this should be a small number */
#define MAX_GROUPS 64
#endif
- gid_t grouplist[MAX_GROUPS];
- int n;
+ gid_t grouplist[MAX_GROUPS];
+ int n;
- n = getgroups(MAX_GROUPS, grouplist);
- if (n < 0)
- posix_error();
- else {
- result = PyList_New(n);
- if (result != NULL) {
- int i;
- for (i = 0; i < n; ++i) {
- PyObject *o = PyLong_FromLong((long)grouplist[i]);
- if (o == NULL) {
- Py_DECREF(result);
- result = NULL;
- break;
- }
- PyList_SET_ITEM(result, i, o);
- }
+ n = getgroups(MAX_GROUPS, grouplist);
+ if (n < 0)
+ posix_error();
+ else {
+ result = PyList_New(n);
+ if (result != NULL) {
+ int i;
+ for (i = 0; i < n; ++i) {
+ PyObject *o = PyLong_FromLong((long)grouplist[i]);
+ if (o == NULL) {
+ Py_DECREF(result);
+ result = NULL;
+ break;
}
+ PyList_SET_ITEM(result, i, o);
}
+ }
+ }
return result;
}
static PyObject *
posix_initgroups(PyObject *self, PyObject *args)
{
- char *username;
- long gid;
+ char *username;
+ long gid;
- if (!PyArg_ParseTuple(args, "sl:initgroups", &username, &gid))
- return NULL;
+ if (!PyArg_ParseTuple(args, "sl:initgroups", &username, &gid))
+ return NULL;
- if (initgroups(username, (gid_t) gid) == -1)
- return PyErr_SetFromErrno(PyExc_OSError);
+ if (initgroups(username, (gid_t) gid) == -1)
+ return PyErr_SetFromErrno(PyExc_OSError);
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif
static PyObject *
posix_getpgid(PyObject *self, PyObject *args)
{
- pid_t pid, pgid;
- if (!PyArg_ParseTuple(args, _Py_PARSE_PID ":getpgid", &pid))
- return NULL;
- pgid = getpgid(pid);
- if (pgid < 0)
- return posix_error();
- return PyLong_FromPid(pgid);
+ pid_t pid, pgid;
+ if (!PyArg_ParseTuple(args, _Py_PARSE_PID ":getpgid", &pid))
+ return NULL;
+ pgid = getpgid(pid);
+ if (pgid < 0)
+ return posix_error();
+ return PyLong_FromPid(pgid);
}
#endif /* HAVE_GETPGID */
posix_getpgrp(PyObject *self, PyObject *noargs)
{
#ifdef GETPGRP_HAVE_ARG
- return PyLong_FromPid(getpgrp(0));
+ return PyLong_FromPid(getpgrp(0));
#else /* GETPGRP_HAVE_ARG */
- return PyLong_FromPid(getpgrp());
+ return PyLong_FromPid(getpgrp());
#endif /* GETPGRP_HAVE_ARG */
}
#endif /* HAVE_GETPGRP */
posix_setpgrp(PyObject *self, PyObject *noargs)
{
#ifdef SETPGRP_HAVE_ARG
- if (setpgrp(0, 0) < 0)
+ if (setpgrp(0, 0) < 0)
#else /* SETPGRP_HAVE_ARG */
- if (setpgrp() < 0)
+ if (setpgrp() < 0)
#endif /* SETPGRP_HAVE_ARG */
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* HAVE_SETPGRP */
static PyObject *
posix_getppid(PyObject *self, PyObject *noargs)
{
- return PyLong_FromPid(getppid());
+ return PyLong_FromPid(getppid());
}
#endif
static PyObject *
posix_getlogin(PyObject *self, PyObject *noargs)
{
- PyObject *result = NULL;
- char *name;
- int old_errno = errno;
+ PyObject *result = NULL;
+ char *name;
+ int old_errno = errno;
- errno = 0;
- name = getlogin();
- if (name == NULL) {
- if (errno)
- posix_error();
- else
- PyErr_SetString(PyExc_OSError,
- "unable to determine login name");
- }
+ errno = 0;
+ name = getlogin();
+ if (name == NULL) {
+ if (errno)
+ posix_error();
else
- result = PyUnicode_FromString(name);
- errno = old_errno;
+ PyErr_SetString(PyExc_OSError,
+ "unable to determine login name");
+ }
+ else
+ result = PyUnicode_FromString(name);
+ errno = old_errno;
return result;
}
static PyObject *
posix_getuid(PyObject *self, PyObject *noargs)
{
- return PyLong_FromLong((long)getuid());
+ return PyLong_FromLong((long)getuid());
}
#endif
static PyObject *
posix_kill(PyObject *self, PyObject *args)
{
- pid_t pid;
- int sig;
- if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:kill", &pid, &sig))
- return NULL;
+ pid_t pid;
+ int sig;
+ if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:kill", &pid, &sig))
+ return NULL;
#if defined(PYOS_OS2) && !defined(PYCC_GCC)
if (sig == XCPT_SIGNAL_INTR || sig == XCPT_SIGNAL_BREAK) {
APIRET rc;
} else
return NULL; /* Unrecognized Signal Requested */
#else
- if (kill(pid, sig) == -1)
- return posix_error();
+ if (kill(pid, sig) == -1)
+ return posix_error();
#endif
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif
static PyObject *
posix_killpg(PyObject *self, PyObject *args)
{
- int sig;
- pid_t pgid;
- /* XXX some man pages make the `pgid` parameter an int, others
- a pid_t. Since getpgrp() returns a pid_t, we assume killpg should
- take the same type. Moreover, pid_t is always at least as wide as
- int (else compilation of this module fails), which is safe. */
- if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:killpg", &pgid, &sig))
- return NULL;
- if (killpg(pgid, sig) == -1)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ int sig;
+ pid_t pgid;
+ /* XXX some man pages make the `pgid` parameter an int, others
+ a pid_t. Since getpgrp() returns a pid_t, we assume killpg should
+ take the same type. Moreover, pid_t is always at least as wide as
+ int (else compilation of this module fails), which is safe. */
+ if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:killpg", &pgid, &sig))
+ return NULL;
+ if (killpg(pgid, sig) == -1)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif
static PyObject *
win32_kill(PyObject *self, PyObject *args)
{
- PyObject *result, handle_obj;
- DWORD pid, sig, err;
- HANDLE handle;
-
- if (!PyArg_ParseTuple(args, "kk:kill", &pid, &sig))
- return NULL;
-
- /* Console processes which share a common console can be sent CTRL+C or
- CTRL+BREAK events, provided they handle said events. */
- if (sig == CTRL_C_EVENT || sig == CTRL_BREAK_EVENT) {
- if (GenerateConsoleCtrlEvent(sig, pid) == 0) {
- err = GetLastError();
- PyErr_SetFromWindowsErr(err);
- }
- else
- Py_RETURN_NONE;
- }
-
- /* If the signal is outside of what GenerateConsoleCtrlEvent can use,
- attempt to open and terminate the process. */
- handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
- if (handle == NULL) {
- err = GetLastError();
- return PyErr_SetFromWindowsErr(err);
- }
-
- if (TerminateProcess(handle, sig) == 0) {
- err = GetLastError();
- result = PyErr_SetFromWindowsErr(err);
- } else {
- Py_INCREF(Py_None);
- result = Py_None;
- }
-
- CloseHandle(handle);
- return result;
+ PyObject *result, handle_obj;
+ DWORD pid, sig, err;
+ HANDLE handle;
+
+ if (!PyArg_ParseTuple(args, "kk:kill", &pid, &sig))
+ return NULL;
+
+ /* Console processes which share a common console can be sent CTRL+C or
+ CTRL+BREAK events, provided they handle said events. */
+ if (sig == CTRL_C_EVENT || sig == CTRL_BREAK_EVENT) {
+ if (GenerateConsoleCtrlEvent(sig, pid) == 0) {
+ err = GetLastError();
+ PyErr_SetFromWindowsErr(err);
+ }
+ else
+ Py_RETURN_NONE;
+ }
+
+ /* If the signal is outside of what GenerateConsoleCtrlEvent can use,
+ attempt to open and terminate the process. */
+ handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
+ if (handle == NULL) {
+ err = GetLastError();
+ return PyErr_SetFromWindowsErr(err);
+ }
+
+ if (TerminateProcess(handle, sig) == 0) {
+ err = GetLastError();
+ result = PyErr_SetFromWindowsErr(err);
+ } else {
+ Py_INCREF(Py_None);
+ result = Py_None;
+ }
+
+ CloseHandle(handle);
+ return result;
}
#endif /* MS_WINDOWS */
static PyObject *
posix_plock(PyObject *self, PyObject *args)
{
- int op;
- if (!PyArg_ParseTuple(args, "i:plock", &op))
- return NULL;
- if (plock(op) == -1)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ int op;
+ if (!PyArg_ParseTuple(args, "i:plock", &op))
+ return NULL;
+ if (plock(op) == -1)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif
static PyObject *
posix_setuid(PyObject *self, PyObject *args)
{
- long uid_arg;
- uid_t uid;
- if (!PyArg_ParseTuple(args, "l:setuid", &uid_arg))
- return NULL;
- uid = uid_arg;
- if (uid != uid_arg) {
- PyErr_SetString(PyExc_OverflowError, "user id too big");
- return NULL;
- }
- if (setuid(uid) < 0)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ long uid_arg;
+ uid_t uid;
+ if (!PyArg_ParseTuple(args, "l:setuid", &uid_arg))
+ return NULL;
+ uid = uid_arg;
+ if (uid != uid_arg) {
+ PyErr_SetString(PyExc_OverflowError, "user id too big");
+ return NULL;
+ }
+ if (setuid(uid) < 0)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* HAVE_SETUID */
static PyObject *
posix_seteuid (PyObject *self, PyObject *args)
{
- long euid_arg;
- uid_t euid;
- if (!PyArg_ParseTuple(args, "l", &euid_arg))
- return NULL;
- euid = euid_arg;
- if (euid != euid_arg) {
- PyErr_SetString(PyExc_OverflowError, "user id too big");
- return NULL;
- }
- if (seteuid(euid) < 0) {
- return posix_error();
- } else {
- Py_INCREF(Py_None);
- return Py_None;
- }
+ long euid_arg;
+ uid_t euid;
+ if (!PyArg_ParseTuple(args, "l", &euid_arg))
+ return NULL;
+ euid = euid_arg;
+ if (euid != euid_arg) {
+ PyErr_SetString(PyExc_OverflowError, "user id too big");
+ return NULL;
+ }
+ if (seteuid(euid) < 0) {
+ return posix_error();
+ } else {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
}
#endif /* HAVE_SETEUID */
static PyObject *
posix_setegid (PyObject *self, PyObject *args)
{
- long egid_arg;
- gid_t egid;
- if (!PyArg_ParseTuple(args, "l", &egid_arg))
- return NULL;
- egid = egid_arg;
- if (egid != egid_arg) {
- PyErr_SetString(PyExc_OverflowError, "group id too big");
- return NULL;
- }
- if (setegid(egid) < 0) {
- return posix_error();
- } else {
- Py_INCREF(Py_None);
- return Py_None;
- }
+ long egid_arg;
+ gid_t egid;
+ if (!PyArg_ParseTuple(args, "l", &egid_arg))
+ return NULL;
+ egid = egid_arg;
+ if (egid != egid_arg) {
+ PyErr_SetString(PyExc_OverflowError, "group id too big");
+ return NULL;
+ }
+ if (setegid(egid) < 0) {
+ return posix_error();
+ } else {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
}
#endif /* HAVE_SETEGID */
static PyObject *
posix_setreuid (PyObject *self, PyObject *args)
{
- long ruid_arg, euid_arg;
- uid_t ruid, euid;
- if (!PyArg_ParseTuple(args, "ll", &ruid_arg, &euid_arg))
- return NULL;
- if (ruid_arg == -1)
- ruid = (uid_t)-1; /* let the compiler choose how -1 fits */
- else
- ruid = ruid_arg; /* otherwise, assign from our long */
- if (euid_arg == -1)
- euid = (uid_t)-1;
- else
- euid = euid_arg;
- if ((euid_arg != -1 && euid != euid_arg) ||
- (ruid_arg != -1 && ruid != ruid_arg)) {
- PyErr_SetString(PyExc_OverflowError, "user id too big");
- return NULL;
- }
- if (setreuid(ruid, euid) < 0) {
- return posix_error();
- } else {
- Py_INCREF(Py_None);
- return Py_None;
- }
+ long ruid_arg, euid_arg;
+ uid_t ruid, euid;
+ if (!PyArg_ParseTuple(args, "ll", &ruid_arg, &euid_arg))
+ return NULL;
+ if (ruid_arg == -1)
+ ruid = (uid_t)-1; /* let the compiler choose how -1 fits */
+ else
+ ruid = ruid_arg; /* otherwise, assign from our long */
+ if (euid_arg == -1)
+ euid = (uid_t)-1;
+ else
+ euid = euid_arg;
+ if ((euid_arg != -1 && euid != euid_arg) ||
+ (ruid_arg != -1 && ruid != ruid_arg)) {
+ PyErr_SetString(PyExc_OverflowError, "user id too big");
+ return NULL;
+ }
+ if (setreuid(ruid, euid) < 0) {
+ return posix_error();
+ } else {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
}
#endif /* HAVE_SETREUID */
static PyObject *
posix_setregid (PyObject *self, PyObject *args)
{
- long rgid_arg, egid_arg;
- gid_t rgid, egid;
- if (!PyArg_ParseTuple(args, "ll", &rgid_arg, &egid_arg))
- return NULL;
- if (rgid_arg == -1)
- rgid = (gid_t)-1; /* let the compiler choose how -1 fits */
- else
- rgid = rgid_arg; /* otherwise, assign from our long */
- if (egid_arg == -1)
- egid = (gid_t)-1;
- else
- egid = egid_arg;
- if ((egid_arg != -1 && egid != egid_arg) ||
- (rgid_arg != -1 && rgid != rgid_arg)) {
- PyErr_SetString(PyExc_OverflowError, "group id too big");
- return NULL;
- }
- if (setregid(rgid, egid) < 0) {
- return posix_error();
- } else {
- Py_INCREF(Py_None);
- return Py_None;
- }
+ long rgid_arg, egid_arg;
+ gid_t rgid, egid;
+ if (!PyArg_ParseTuple(args, "ll", &rgid_arg, &egid_arg))
+ return NULL;
+ if (rgid_arg == -1)
+ rgid = (gid_t)-1; /* let the compiler choose how -1 fits */
+ else
+ rgid = rgid_arg; /* otherwise, assign from our long */
+ if (egid_arg == -1)
+ egid = (gid_t)-1;
+ else
+ egid = egid_arg;
+ if ((egid_arg != -1 && egid != egid_arg) ||
+ (rgid_arg != -1 && rgid != rgid_arg)) {
+ PyErr_SetString(PyExc_OverflowError, "group id too big");
+ return NULL;
+ }
+ if (setregid(rgid, egid) < 0) {
+ return posix_error();
+ } else {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
}
#endif /* HAVE_SETREGID */
static PyObject *
posix_setgid(PyObject *self, PyObject *args)
{
- long gid_arg;
- gid_t gid;
- if (!PyArg_ParseTuple(args, "l:setgid", &gid_arg))
- return NULL;
- gid = gid_arg;
- if (gid != gid_arg) {
- PyErr_SetString(PyExc_OverflowError, "group id too big");
- return NULL;
- }
- if (setgid(gid) < 0)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ long gid_arg;
+ gid_t gid;
+ if (!PyArg_ParseTuple(args, "l:setgid", &gid_arg))
+ return NULL;
+ gid = gid_arg;
+ if (gid != gid_arg) {
+ PyErr_SetString(PyExc_OverflowError, "group id too big");
+ return NULL;
+ }
+ if (setgid(gid) < 0)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* HAVE_SETGID */
static PyObject *
posix_setgroups(PyObject *self, PyObject *groups)
{
- int i, len;
- gid_t grouplist[MAX_GROUPS];
-
- if (!PySequence_Check(groups)) {
- PyErr_SetString(PyExc_TypeError, "setgroups argument must be a sequence");
- return NULL;
- }
- len = PySequence_Size(groups);
- if (len > MAX_GROUPS) {
- PyErr_SetString(PyExc_ValueError, "too many groups");
- return NULL;
- }
- for(i = 0; i < len; i++) {
- PyObject *elem;
- elem = PySequence_GetItem(groups, i);
- if (!elem)
- return NULL;
- if (!PyLong_Check(elem)) {
- PyErr_SetString(PyExc_TypeError,
- "groups must be integers");
- Py_DECREF(elem);
- return NULL;
- } else {
- unsigned long x = PyLong_AsUnsignedLong(elem);
- if (PyErr_Occurred()) {
- PyErr_SetString(PyExc_TypeError,
- "group id too big");
- Py_DECREF(elem);
- return NULL;
- }
- grouplist[i] = x;
- /* read back the value to see if it fitted in gid_t */
- if (grouplist[i] != x) {
- PyErr_SetString(PyExc_TypeError,
- "group id too big");
- Py_DECREF(elem);
- return NULL;
- }
- }
- Py_DECREF(elem);
- }
-
- if (setgroups(len, grouplist) < 0)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ int i, len;
+ gid_t grouplist[MAX_GROUPS];
+
+ if (!PySequence_Check(groups)) {
+ PyErr_SetString(PyExc_TypeError, "setgroups argument must be a sequence");
+ return NULL;
+ }
+ len = PySequence_Size(groups);
+ if (len > MAX_GROUPS) {
+ PyErr_SetString(PyExc_ValueError, "too many groups");
+ return NULL;
+ }
+ for(i = 0; i < len; i++) {
+ PyObject *elem;
+ elem = PySequence_GetItem(groups, i);
+ if (!elem)
+ return NULL;
+ if (!PyLong_Check(elem)) {
+ PyErr_SetString(PyExc_TypeError,
+ "groups must be integers");
+ Py_DECREF(elem);
+ return NULL;
+ } else {
+ unsigned long x = PyLong_AsUnsignedLong(elem);
+ if (PyErr_Occurred()) {
+ PyErr_SetString(PyExc_TypeError,
+ "group id too big");
+ Py_DECREF(elem);
+ return NULL;
+ }
+ grouplist[i] = x;
+ /* read back the value to see if it fitted in gid_t */
+ if (grouplist[i] != x) {
+ PyErr_SetString(PyExc_TypeError,
+ "group id too big");
+ Py_DECREF(elem);
+ return NULL;
+ }
+ }
+ Py_DECREF(elem);
+ }
+
+ if (setgroups(len, grouplist) < 0)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* HAVE_SETGROUPS */
static PyObject *
wait_helper(pid_t pid, int status, struct rusage *ru)
{
- PyObject *result;
- static PyObject *struct_rusage;
+ PyObject *result;
+ static PyObject *struct_rusage;
- if (pid == -1)
- return posix_error();
+ if (pid == -1)
+ return posix_error();
- if (struct_rusage == NULL) {
- PyObject *m = PyImport_ImportModuleNoBlock("resource");
- if (m == NULL)
- return NULL;
- struct_rusage = PyObject_GetAttrString(m, "struct_rusage");
- Py_DECREF(m);
- if (struct_rusage == NULL)
- return NULL;
- }
+ if (struct_rusage == NULL) {
+ PyObject *m = PyImport_ImportModuleNoBlock("resource");
+ if (m == NULL)
+ return NULL;
+ struct_rusage = PyObject_GetAttrString(m, "struct_rusage");
+ Py_DECREF(m);
+ if (struct_rusage == NULL)
+ return NULL;
+ }
- /* XXX(nnorwitz): Copied (w/mods) from resource.c, there should be only one. */
- result = PyStructSequence_New((PyTypeObject*) struct_rusage);
- if (!result)
- return NULL;
+ /* XXX(nnorwitz): Copied (w/mods) from resource.c, there should be only one. */
+ result = PyStructSequence_New((PyTypeObject*) struct_rusage);
+ if (!result)
+ return NULL;
#ifndef doubletime
#define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001)
#endif
- PyStructSequence_SET_ITEM(result, 0,
- PyFloat_FromDouble(doubletime(ru->ru_utime)));
- PyStructSequence_SET_ITEM(result, 1,
- PyFloat_FromDouble(doubletime(ru->ru_stime)));
+ PyStructSequence_SET_ITEM(result, 0,
+ PyFloat_FromDouble(doubletime(ru->ru_utime)));
+ PyStructSequence_SET_ITEM(result, 1,
+ PyFloat_FromDouble(doubletime(ru->ru_stime)));
#define SET_INT(result, index, value)\
- PyStructSequence_SET_ITEM(result, index, PyLong_FromLong(value))
- SET_INT(result, 2, ru->ru_maxrss);
- SET_INT(result, 3, ru->ru_ixrss);
- SET_INT(result, 4, ru->ru_idrss);
- SET_INT(result, 5, ru->ru_isrss);
- SET_INT(result, 6, ru->ru_minflt);
- SET_INT(result, 7, ru->ru_majflt);
- SET_INT(result, 8, ru->ru_nswap);
- SET_INT(result, 9, ru->ru_inblock);
- SET_INT(result, 10, ru->ru_oublock);
- SET_INT(result, 11, ru->ru_msgsnd);
- SET_INT(result, 12, ru->ru_msgrcv);
- SET_INT(result, 13, ru->ru_nsignals);
- SET_INT(result, 14, ru->ru_nvcsw);
- SET_INT(result, 15, ru->ru_nivcsw);
+ PyStructSequence_SET_ITEM(result, index, PyLong_FromLong(value))
+ SET_INT(result, 2, ru->ru_maxrss);
+ SET_INT(result, 3, ru->ru_ixrss);
+ SET_INT(result, 4, ru->ru_idrss);
+ SET_INT(result, 5, ru->ru_isrss);
+ SET_INT(result, 6, ru->ru_minflt);
+ SET_INT(result, 7, ru->ru_majflt);
+ SET_INT(result, 8, ru->ru_nswap);
+ SET_INT(result, 9, ru->ru_inblock);
+ SET_INT(result, 10, ru->ru_oublock);
+ SET_INT(result, 11, ru->ru_msgsnd);
+ SET_INT(result, 12, ru->ru_msgrcv);
+ SET_INT(result, 13, ru->ru_nsignals);
+ SET_INT(result, 14, ru->ru_nvcsw);
+ SET_INT(result, 15, ru->ru_nivcsw);
#undef SET_INT
- if (PyErr_Occurred()) {
- Py_DECREF(result);
- return NULL;
- }
+ if (PyErr_Occurred()) {
+ Py_DECREF(result);
+ return NULL;
+ }
- return Py_BuildValue("NiN", PyLong_FromPid(pid), status, result);
+ return Py_BuildValue("NiN", PyLong_FromPid(pid), status, result);
}
#endif /* HAVE_WAIT3 || HAVE_WAIT4 */
static PyObject *
posix_wait3(PyObject *self, PyObject *args)
{
- pid_t pid;
- int options;
- struct rusage ru;
- WAIT_TYPE status;
- WAIT_STATUS_INT(status) = 0;
+ pid_t pid;
+ int options;
+ struct rusage ru;
+ WAIT_TYPE status;
+ WAIT_STATUS_INT(status) = 0;
- if (!PyArg_ParseTuple(args, "i:wait3", &options))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:wait3", &options))
+ return NULL;
- Py_BEGIN_ALLOW_THREADS
- pid = wait3(&status, options, &ru);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ pid = wait3(&status, options, &ru);
+ Py_END_ALLOW_THREADS
- return wait_helper(pid, WAIT_STATUS_INT(status), &ru);
+ return wait_helper(pid, WAIT_STATUS_INT(status), &ru);
}
#endif /* HAVE_WAIT3 */
static PyObject *
posix_wait4(PyObject *self, PyObject *args)
{
- pid_t pid;
- int options;
- struct rusage ru;
- WAIT_TYPE status;
- WAIT_STATUS_INT(status) = 0;
+ pid_t pid;
+ int options;
+ struct rusage ru;
+ WAIT_TYPE status;
+ WAIT_STATUS_INT(status) = 0;
- if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:wait4", &pid, &options))
- return NULL;
+ if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:wait4", &pid, &options))
+ return NULL;
- Py_BEGIN_ALLOW_THREADS
- pid = wait4(pid, &status, options, &ru);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ pid = wait4(pid, &status, options, &ru);
+ Py_END_ALLOW_THREADS
- return wait_helper(pid, WAIT_STATUS_INT(status), &ru);
+ return wait_helper(pid, WAIT_STATUS_INT(status), &ru);
}
#endif /* HAVE_WAIT4 */
static PyObject *
posix_waitpid(PyObject *self, PyObject *args)
{
- pid_t pid;
- int options;
- WAIT_TYPE status;
- WAIT_STATUS_INT(status) = 0;
+ pid_t pid;
+ int options;
+ WAIT_TYPE status;
+ WAIT_STATUS_INT(status) = 0;
- if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:waitpid", &pid, &options))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- pid = waitpid(pid, &status, options);
- Py_END_ALLOW_THREADS
- if (pid == -1)
- return posix_error();
+ if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:waitpid", &pid, &options))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ pid = waitpid(pid, &status, options);
+ Py_END_ALLOW_THREADS
+ if (pid == -1)
+ return posix_error();
- return Py_BuildValue("Ni", PyLong_FromPid(pid), WAIT_STATUS_INT(status));
+ return Py_BuildValue("Ni", PyLong_FromPid(pid), WAIT_STATUS_INT(status));
}
#elif defined(HAVE_CWAIT)
static PyObject *
posix_waitpid(PyObject *self, PyObject *args)
{
- Py_intptr_t pid;
- int status, options;
+ Py_intptr_t pid;
+ int status, options;
- if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:waitpid", &pid, &options))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- pid = _cwait(&status, pid, options);
- Py_END_ALLOW_THREADS
- if (pid == -1)
- return posix_error();
+ if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:waitpid", &pid, &options))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ pid = _cwait(&status, pid, options);
+ Py_END_ALLOW_THREADS
+ if (pid == -1)
+ return posix_error();
- /* shift the status left a byte so this is more like the POSIX waitpid */
- return Py_BuildValue("Ni", PyLong_FromPid(pid), status << 8);
+ /* shift the status left a byte so this is more like the POSIX waitpid */
+ return Py_BuildValue("Ni", PyLong_FromPid(pid), status << 8);
}
#endif /* HAVE_WAITPID || HAVE_CWAIT */
static PyObject *
posix_wait(PyObject *self, PyObject *noargs)
{
- pid_t pid;
- WAIT_TYPE status;
- WAIT_STATUS_INT(status) = 0;
+ pid_t pid;
+ WAIT_TYPE status;
+ WAIT_STATUS_INT(status) = 0;
- Py_BEGIN_ALLOW_THREADS
- pid = wait(&status);
- Py_END_ALLOW_THREADS
- if (pid == -1)
- return posix_error();
+ Py_BEGIN_ALLOW_THREADS
+ pid = wait(&status);
+ Py_END_ALLOW_THREADS
+ if (pid == -1)
+ return posix_error();
- return Py_BuildValue("Ni", PyLong_FromPid(pid), WAIT_STATUS_INT(status));
+ return Py_BuildValue("Ni", PyLong_FromPid(pid), WAIT_STATUS_INT(status));
}
#endif
posix_lstat(PyObject *self, PyObject *args)
{
#ifdef HAVE_LSTAT
- return posix_do_stat(self, args, "O&:lstat", lstat, NULL, NULL);
+ return posix_do_stat(self, args, "O&:lstat", lstat, NULL, NULL);
#else /* !HAVE_LSTAT */
#ifdef MS_WINDOWS
- return posix_do_stat(self, args, "O&:lstat", STAT, "U:lstat", win32_wstat);
+ return posix_do_stat(self, args, "O&:lstat", STAT, "U:lstat", win32_wstat);
#else
- return posix_do_stat(self, args, "O&:lstat", STAT, NULL, NULL);
+ return posix_do_stat(self, args, "O&:lstat", STAT, NULL, NULL);
#endif
#endif /* !HAVE_LSTAT */
}
static PyObject *
posix_readlink(PyObject *self, PyObject *args)
{
- PyObject* v;
- char buf[MAXPATHLEN];
- PyObject *opath;
- char *path;
- int n;
- int arg_is_unicode = 0;
-
- if (!PyArg_ParseTuple(args, "O&:readlink",
- PyUnicode_FSConverter, &opath))
- return NULL;
- path = PyBytes_AsString(opath);
- v = PySequence_GetItem(args, 0);
- if (v == NULL) {
- Py_DECREF(opath);
- return NULL;
- }
-
- if (PyUnicode_Check(v)) {
- arg_is_unicode = 1;
- }
- Py_DECREF(v);
-
- Py_BEGIN_ALLOW_THREADS
- n = readlink(path, buf, (int) sizeof buf);
- Py_END_ALLOW_THREADS
- if (n < 0)
- return posix_error_with_allocated_filename(opath);
-
- Py_DECREF(opath);
- v = PyBytes_FromStringAndSize(buf, n);
- if (arg_is_unicode) {
- PyObject *w;
-
- w = PyUnicode_FromEncodedObject(v,
- Py_FileSystemDefaultEncoding,
- "surrogateescape");
- if (w != NULL) {
- Py_DECREF(v);
- v = w;
- }
- else {
- v = NULL;
- }
- }
- return v;
+ PyObject* v;
+ char buf[MAXPATHLEN];
+ PyObject *opath;
+ char *path;
+ int n;
+ int arg_is_unicode = 0;
+
+ if (!PyArg_ParseTuple(args, "O&:readlink",
+ PyUnicode_FSConverter, &opath))
+ return NULL;
+ path = PyBytes_AsString(opath);
+ v = PySequence_GetItem(args, 0);
+ if (v == NULL) {
+ Py_DECREF(opath);
+ return NULL;
+ }
+
+ if (PyUnicode_Check(v)) {
+ arg_is_unicode = 1;
+ }
+ Py_DECREF(v);
+
+ Py_BEGIN_ALLOW_THREADS
+ n = readlink(path, buf, (int) sizeof buf);
+ Py_END_ALLOW_THREADS
+ if (n < 0)
+ return posix_error_with_allocated_filename(opath);
+
+ Py_DECREF(opath);
+ v = PyBytes_FromStringAndSize(buf, n);
+ if (arg_is_unicode) {
+ PyObject *w;
+
+ w = PyUnicode_FromEncodedObject(v,
+ Py_FileSystemDefaultEncoding,
+ "surrogateescape");
+ if (w != NULL) {
+ Py_DECREF(v);
+ v = w;
+ }
+ else {
+ v = NULL;
+ }
+ }
+ return v;
}
#endif /* HAVE_READLINK */
static PyObject *
posix_symlink(PyObject *self, PyObject *args)
{
- return posix_2str(args, "O&O&:symlink", symlink);
+ return posix_2str(args, "O&O&:symlink", symlink);
}
#endif /* HAVE_SYMLINK */
posix_times(PyObject *self, PyObject *noargs)
{
/* Currently Only Uptime is Provided -- Others Later */
- return Py_BuildValue("ddddd",
- (double)0 /* t.tms_utime / HZ */,
- (double)0 /* t.tms_stime / HZ */,
- (double)0 /* t.tms_cutime / HZ */,
- (double)0 /* t.tms_cstime / HZ */,
- (double)system_uptime() / 1000);
+ return Py_BuildValue("ddddd",
+ (double)0 /* t.tms_utime / HZ */,
+ (double)0 /* t.tms_stime / HZ */,
+ (double)0 /* t.tms_cutime / HZ */,
+ (double)0 /* t.tms_cstime / HZ */,
+ (double)system_uptime() / 1000);
}
#else /* not OS2 */
#define NEED_TICKS_PER_SECOND
static PyObject *
posix_times(PyObject *self, PyObject *noargs)
{
- struct tms t;
- clock_t c;
- errno = 0;
- c = times(&t);
- if (c == (clock_t) -1)
- return posix_error();
- return Py_BuildValue("ddddd",
- (double)t.tms_utime / ticks_per_second,
- (double)t.tms_stime / ticks_per_second,
- (double)t.tms_cutime / ticks_per_second,
- (double)t.tms_cstime / ticks_per_second,
- (double)c / ticks_per_second);
+ struct tms t;
+ clock_t c;
+ errno = 0;
+ c = times(&t);
+ if (c == (clock_t) -1)
+ return posix_error();
+ return Py_BuildValue("ddddd",
+ (double)t.tms_utime / ticks_per_second,
+ (double)t.tms_stime / ticks_per_second,
+ (double)t.tms_cutime / ticks_per_second,
+ (double)t.tms_cstime / ticks_per_second,
+ (double)c / ticks_per_second);
}
#endif /* not OS2 */
#endif /* HAVE_TIMES */
#ifdef MS_WINDOWS
-#define HAVE_TIMES /* so the method table will pick it up */
+#define HAVE_TIMES /* so the method table will pick it up */
static PyObject *
posix_times(PyObject *self, PyObject *noargs)
{
- FILETIME create, exit, kernel, user;
- HANDLE hProc;
- hProc = GetCurrentProcess();
- GetProcessTimes(hProc, &create, &exit, &kernel, &user);
- /* The fields of a FILETIME structure are the hi and lo part
- of a 64-bit value expressed in 100 nanosecond units.
- 1e7 is one second in such units; 1e-7 the inverse.
- 429.4967296 is 2**32 / 1e7 or 2**32 * 1e-7.
- */
- return Py_BuildValue(
- "ddddd",
- (double)(user.dwHighDateTime*429.4967296 +
- user.dwLowDateTime*1e-7),
- (double)(kernel.dwHighDateTime*429.4967296 +
- kernel.dwLowDateTime*1e-7),
- (double)0,
- (double)0,
- (double)0);
+ FILETIME create, exit, kernel, user;
+ HANDLE hProc;
+ hProc = GetCurrentProcess();
+ GetProcessTimes(hProc, &create, &exit, &kernel, &user);
+ /* The fields of a FILETIME structure are the hi and lo part
+ of a 64-bit value expressed in 100 nanosecond units.
+ 1e7 is one second in such units; 1e-7 the inverse.
+ 429.4967296 is 2**32 / 1e7 or 2**32 * 1e-7.
+ */
+ return Py_BuildValue(
+ "ddddd",
+ (double)(user.dwHighDateTime*429.4967296 +
+ user.dwLowDateTime*1e-7),
+ (double)(kernel.dwHighDateTime*429.4967296 +
+ kernel.dwLowDateTime*1e-7),
+ (double)0,
+ (double)0,
+ (double)0);
}
#endif /* MS_WINDOWS */
static PyObject *
posix_getsid(PyObject *self, PyObject *args)
{
- pid_t pid;
- int sid;
- if (!PyArg_ParseTuple(args, _Py_PARSE_PID ":getsid", &pid))
- return NULL;
- sid = getsid(pid);
- if (sid < 0)
- return posix_error();
- return PyLong_FromLong((long)sid);
+ pid_t pid;
+ int sid;
+ if (!PyArg_ParseTuple(args, _Py_PARSE_PID ":getsid", &pid))
+ return NULL;
+ sid = getsid(pid);
+ if (sid < 0)
+ return posix_error();
+ return PyLong_FromLong((long)sid);
}
#endif /* HAVE_GETSID */
static PyObject *
posix_setsid(PyObject *self, PyObject *noargs)
{
- if (setsid() < 0)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ if (setsid() < 0)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* HAVE_SETSID */
static PyObject *
posix_setpgid(PyObject *self, PyObject *args)
{
- pid_t pid;
- int pgrp;
- if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:setpgid", &pid, &pgrp))
- return NULL;
- if (setpgid(pid, pgrp) < 0)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ pid_t pid;
+ int pgrp;
+ if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:setpgid", &pid, &pgrp))
+ return NULL;
+ if (setpgid(pid, pgrp) < 0)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* HAVE_SETPGID */
static PyObject *
posix_tcgetpgrp(PyObject *self, PyObject *args)
{
- int fd;
- pid_t pgid;
- if (!PyArg_ParseTuple(args, "i:tcgetpgrp", &fd))
- return NULL;
- pgid = tcgetpgrp(fd);
- if (pgid < 0)
- return posix_error();
- return PyLong_FromPid(pgid);
+ int fd;
+ pid_t pgid;
+ if (!PyArg_ParseTuple(args, "i:tcgetpgrp", &fd))
+ return NULL;
+ pgid = tcgetpgrp(fd);
+ if (pgid < 0)
+ return posix_error();
+ return PyLong_FromPid(pgid);
}
#endif /* HAVE_TCGETPGRP */
static PyObject *
posix_tcsetpgrp(PyObject *self, PyObject *args)
{
- int fd;
- pid_t pgid;
- if (!PyArg_ParseTuple(args, "i" _Py_PARSE_PID ":tcsetpgrp", &fd, &pgid))
- return NULL;
- if (tcsetpgrp(fd, pgid) < 0)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ int fd;
+ pid_t pgid;
+ if (!PyArg_ParseTuple(args, "i" _Py_PARSE_PID ":tcsetpgrp", &fd, &pgid))
+ return NULL;
+ if (tcsetpgrp(fd, pgid) < 0)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* HAVE_TCSETPGRP */
static PyObject *
posix_open(PyObject *self, PyObject *args)
{
- PyObject *ofile;
- char *file;
- int flag;
- int mode = 0777;
- int fd;
+ PyObject *ofile;
+ char *file;
+ int flag;
+ int mode = 0777;
+ int fd;
#ifdef MS_WINDOWS
- PyUnicodeObject *po;
- if (PyArg_ParseTuple(args, "Ui|i:mkdir", &po, &flag, &mode)) {
- Py_BEGIN_ALLOW_THREADS
- /* PyUnicode_AS_UNICODE OK without thread
- lock as it is a simple dereference. */
- fd = _wopen(PyUnicode_AS_UNICODE(po), flag, mode);
- Py_END_ALLOW_THREADS
- if (fd < 0)
- return posix_error();
- return PyLong_FromLong((long)fd);
- }
- /* Drop the argument parsing error as narrow strings
- are also valid. */
- PyErr_Clear();
-#endif
-
- if (!PyArg_ParseTuple(args, "O&i|i",
- PyUnicode_FSConverter, &ofile,
- &flag, &mode))
- return NULL;
- file = PyBytes_AsString(ofile);
- Py_BEGIN_ALLOW_THREADS
- fd = open(file, flag, mode);
- Py_END_ALLOW_THREADS
- if (fd < 0)
- return posix_error_with_allocated_filename(ofile);
- Py_DECREF(ofile);
- return PyLong_FromLong((long)fd);
+ PyUnicodeObject *po;
+ if (PyArg_ParseTuple(args, "Ui|i:mkdir", &po, &flag, &mode)) {
+ Py_BEGIN_ALLOW_THREADS
+ /* PyUnicode_AS_UNICODE OK without thread
+ lock as it is a simple dereference. */
+ fd = _wopen(PyUnicode_AS_UNICODE(po), flag, mode);
+ Py_END_ALLOW_THREADS
+ if (fd < 0)
+ return posix_error();
+ return PyLong_FromLong((long)fd);
+ }
+ /* Drop the argument parsing error as narrow strings
+ are also valid. */
+ PyErr_Clear();
+#endif
+
+ if (!PyArg_ParseTuple(args, "O&i|i",
+ PyUnicode_FSConverter, &ofile,
+ &flag, &mode))
+ return NULL;
+ file = PyBytes_AsString(ofile);
+ Py_BEGIN_ALLOW_THREADS
+ fd = open(file, flag, mode);
+ Py_END_ALLOW_THREADS
+ if (fd < 0)
+ return posix_error_with_allocated_filename(ofile);
+ Py_DECREF(ofile);
+ return PyLong_FromLong((long)fd);
}
static PyObject *
posix_close(PyObject *self, PyObject *args)
{
- int fd, res;
- if (!PyArg_ParseTuple(args, "i:close", &fd))
- return NULL;
- if (!_PyVerify_fd(fd))
- return posix_error();
- Py_BEGIN_ALLOW_THREADS
- res = close(fd);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ int fd, res;
+ if (!PyArg_ParseTuple(args, "i:close", &fd))
+ return NULL;
+ if (!_PyVerify_fd(fd))
+ return posix_error();
+ Py_BEGIN_ALLOW_THREADS
+ res = close(fd);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
-PyDoc_STRVAR(posix_closerange__doc__,
+PyDoc_STRVAR(posix_closerange__doc__,
"closerange(fd_low, fd_high)\n\n\
Closes all file descriptors in [fd_low, fd_high), ignoring errors.");
static PyObject *
posix_closerange(PyObject *self, PyObject *args)
{
- int fd_from, fd_to, i;
- if (!PyArg_ParseTuple(args, "ii:closerange", &fd_from, &fd_to))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- for (i = fd_from; i < fd_to; i++)
- if (_PyVerify_fd(i))
- close(i);
- Py_END_ALLOW_THREADS
- Py_RETURN_NONE;
+ int fd_from, fd_to, i;
+ if (!PyArg_ParseTuple(args, "ii:closerange", &fd_from, &fd_to))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ for (i = fd_from; i < fd_to; i++)
+ if (_PyVerify_fd(i))
+ close(i);
+ Py_END_ALLOW_THREADS
+ Py_RETURN_NONE;
}
static PyObject *
posix_dup(PyObject *self, PyObject *args)
{
- int fd;
- if (!PyArg_ParseTuple(args, "i:dup", &fd))
- return NULL;
- if (!_PyVerify_fd(fd))
- return posix_error();
- Py_BEGIN_ALLOW_THREADS
- fd = dup(fd);
- Py_END_ALLOW_THREADS
- if (fd < 0)
- return posix_error();
- return PyLong_FromLong((long)fd);
+ int fd;
+ if (!PyArg_ParseTuple(args, "i:dup", &fd))
+ return NULL;
+ if (!_PyVerify_fd(fd))
+ return posix_error();
+ Py_BEGIN_ALLOW_THREADS
+ fd = dup(fd);
+ Py_END_ALLOW_THREADS
+ if (fd < 0)
+ return posix_error();
+ return PyLong_FromLong((long)fd);
}
static PyObject *
posix_dup2(PyObject *self, PyObject *args)
{
- int fd, fd2, res;
- if (!PyArg_ParseTuple(args, "ii:dup2", &fd, &fd2))
- return NULL;
- if (!_PyVerify_fd_dup2(fd, fd2))
- return posix_error();
- Py_BEGIN_ALLOW_THREADS
- res = dup2(fd, fd2);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ int fd, fd2, res;
+ if (!PyArg_ParseTuple(args, "ii:dup2", &fd, &fd2))
+ return NULL;
+ if (!_PyVerify_fd_dup2(fd, fd2))
+ return posix_error();
+ Py_BEGIN_ALLOW_THREADS
+ res = dup2(fd, fd2);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *
posix_lseek(PyObject *self, PyObject *args)
{
- int fd, how;
+ int fd, how;
#if defined(MS_WIN64) || defined(MS_WINDOWS)
- PY_LONG_LONG pos, res;
+ PY_LONG_LONG pos, res;
#else
- off_t pos, res;
+ off_t pos, res;
#endif
- PyObject *posobj;
- if (!PyArg_ParseTuple(args, "iOi:lseek", &fd, &posobj, &how))
- return NULL;
+ PyObject *posobj;
+ if (!PyArg_ParseTuple(args, "iOi:lseek", &fd, &posobj, &how))
+ return NULL;
#ifdef SEEK_SET
- /* Turn 0, 1, 2 into SEEK_{SET,CUR,END} */
- switch (how) {
- case 0: how = SEEK_SET; break;
- case 1: how = SEEK_CUR; break;
- case 2: how = SEEK_END; break;
- }
+ /* Turn 0, 1, 2 into SEEK_{SET,CUR,END} */
+ switch (how) {
+ case 0: how = SEEK_SET; break;
+ case 1: how = SEEK_CUR; break;
+ case 2: how = SEEK_END; break;
+ }
#endif /* SEEK_END */
#if !defined(HAVE_LARGEFILE_SUPPORT)
- pos = PyLong_AsLong(posobj);
+ pos = PyLong_AsLong(posobj);
#else
- pos = PyLong_Check(posobj) ?
- PyLong_AsLongLong(posobj) : PyLong_AsLong(posobj);
+ pos = PyLong_Check(posobj) ?
+ PyLong_AsLongLong(posobj) : PyLong_AsLong(posobj);
#endif
- if (PyErr_Occurred())
- return NULL;
+ if (PyErr_Occurred())
+ return NULL;
- if (!_PyVerify_fd(fd))
- return posix_error();
- Py_BEGIN_ALLOW_THREADS
+ if (!_PyVerify_fd(fd))
+ return posix_error();
+ Py_BEGIN_ALLOW_THREADS
#if defined(MS_WIN64) || defined(MS_WINDOWS)
- res = _lseeki64(fd, pos, how);
+ res = _lseeki64(fd, pos, how);
#else
- res = lseek(fd, pos, how);
+ res = lseek(fd, pos, how);
#endif
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error();
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error();
#if !defined(HAVE_LARGEFILE_SUPPORT)
- return PyLong_FromLong(res);
+ return PyLong_FromLong(res);
#else
- return PyLong_FromLongLong(res);
+ return PyLong_FromLongLong(res);
#endif
}
static PyObject *
posix_read(PyObject *self, PyObject *args)
{
- int fd, size;
- Py_ssize_t n;
- PyObject *buffer;
- if (!PyArg_ParseTuple(args, "ii:read", &fd, &size))
- return NULL;
- if (size < 0) {
- errno = EINVAL;
- return posix_error();
- }
- buffer = PyBytes_FromStringAndSize((char *)NULL, size);
- if (buffer == NULL)
- return NULL;
- if (!_PyVerify_fd(fd))
- return posix_error();
- Py_BEGIN_ALLOW_THREADS
- n = read(fd, PyBytes_AS_STRING(buffer), size);
- Py_END_ALLOW_THREADS
- if (n < 0) {
- Py_DECREF(buffer);
- return posix_error();
- }
- if (n != size)
- _PyBytes_Resize(&buffer, n);
- return buffer;
+ int fd, size;
+ Py_ssize_t n;
+ PyObject *buffer;
+ if (!PyArg_ParseTuple(args, "ii:read", &fd, &size))
+ return NULL;
+ if (size < 0) {
+ errno = EINVAL;
+ return posix_error();
+ }
+ buffer = PyBytes_FromStringAndSize((char *)NULL, size);
+ if (buffer == NULL)
+ return NULL;
+ if (!_PyVerify_fd(fd))
+ return posix_error();
+ Py_BEGIN_ALLOW_THREADS
+ n = read(fd, PyBytes_AS_STRING(buffer), size);
+ Py_END_ALLOW_THREADS
+ if (n < 0) {
+ Py_DECREF(buffer);
+ return posix_error();
+ }
+ if (n != size)
+ _PyBytes_Resize(&buffer, n);
+ return buffer;
}
static PyObject *
posix_write(PyObject *self, PyObject *args)
{
- Py_buffer pbuf;
- int fd;
- Py_ssize_t size;
+ Py_buffer pbuf;
+ int fd;
+ Py_ssize_t size;
- if (!PyArg_ParseTuple(args, "iy*:write", &fd, &pbuf))
- return NULL;
- if (!_PyVerify_fd(fd))
- return posix_error();
- Py_BEGIN_ALLOW_THREADS
- size = write(fd, pbuf.buf, (size_t)pbuf.len);
- Py_END_ALLOW_THREADS
- PyBuffer_Release(&pbuf);
- if (size < 0)
- return posix_error();
- return PyLong_FromSsize_t(size);
+ if (!PyArg_ParseTuple(args, "iy*:write", &fd, &pbuf))
+ return NULL;
+ if (!_PyVerify_fd(fd))
+ return posix_error();
+ Py_BEGIN_ALLOW_THREADS
+ size = write(fd, pbuf.buf, (size_t)pbuf.len);
+ Py_END_ALLOW_THREADS
+ PyBuffer_Release(&pbuf);
+ if (size < 0)
+ return posix_error();
+ return PyLong_FromSsize_t(size);
}
static PyObject *
posix_fstat(PyObject *self, PyObject *args)
{
- int fd;
- STRUCT_STAT st;
- int res;
- if (!PyArg_ParseTuple(args, "i:fstat", &fd))
- return NULL;
+ int fd;
+ STRUCT_STAT st;
+ int res;
+ if (!PyArg_ParseTuple(args, "i:fstat", &fd))
+ return NULL;
#ifdef __VMS
- /* on OpenVMS we must ensure that all bytes are written to the file */
- fsync(fd);
-#endif
- if (!_PyVerify_fd(fd))
- return posix_error();
- Py_BEGIN_ALLOW_THREADS
- res = FSTAT(fd, &st);
- Py_END_ALLOW_THREADS
- if (res != 0) {
+ /* on OpenVMS we must ensure that all bytes are written to the file */
+ fsync(fd);
+#endif
+ if (!_PyVerify_fd(fd))
+ return posix_error();
+ Py_BEGIN_ALLOW_THREADS
+ res = FSTAT(fd, &st);
+ Py_END_ALLOW_THREADS
+ if (res != 0) {
#ifdef MS_WINDOWS
- return win32_error("fstat", NULL);
+ return win32_error("fstat", NULL);
#else
- return posix_error();
+ return posix_error();
#endif
- }
+ }
- return _pystat_fromstructstat(&st);
+ return _pystat_fromstructstat(&st);
}
PyDoc_STRVAR(posix_isatty__doc__,
static PyObject *
posix_isatty(PyObject *self, PyObject *args)
{
- int fd;
- if (!PyArg_ParseTuple(args, "i:isatty", &fd))
- return NULL;
- if (!_PyVerify_fd(fd))
- return PyBool_FromLong(0);
- return PyBool_FromLong(isatty(fd));
+ int fd;
+ if (!PyArg_ParseTuple(args, "i:isatty", &fd))
+ return NULL;
+ if (!_PyVerify_fd(fd))
+ return PyBool_FromLong(0);
+ return PyBool_FromLong(isatty(fd));
}
#ifdef HAVE_PIPE
HFILE read, write;
APIRET rc;
- Py_BEGIN_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
rc = DosCreatePipe( &read, &write, 4096);
- Py_END_ALLOW_THREADS
+ Py_END_ALLOW_THREADS
if (rc != NO_ERROR)
return os2_error(rc);
return Py_BuildValue("(ii)", read, write);
#else
#if !defined(MS_WINDOWS)
- int fds[2];
- int res;
- Py_BEGIN_ALLOW_THREADS
- res = pipe(fds);
- Py_END_ALLOW_THREADS
- if (res != 0)
- return posix_error();
- return Py_BuildValue("(ii)", fds[0], fds[1]);
+ int fds[2];
+ int res;
+ Py_BEGIN_ALLOW_THREADS
+ res = pipe(fds);
+ Py_END_ALLOW_THREADS
+ if (res != 0)
+ return posix_error();
+ return Py_BuildValue("(ii)", fds[0], fds[1]);
#else /* MS_WINDOWS */
- HANDLE read, write;
- int read_fd, write_fd;
- BOOL ok;
- Py_BEGIN_ALLOW_THREADS
- ok = CreatePipe(&read, &write, NULL, 0);
- Py_END_ALLOW_THREADS
- if (!ok)
- return win32_error("CreatePipe", NULL);
- read_fd = _open_osfhandle((Py_intptr_t)read, 0);
- write_fd = _open_osfhandle((Py_intptr_t)write, 1);
- return Py_BuildValue("(ii)", read_fd, write_fd);
+ HANDLE read, write;
+ int read_fd, write_fd;
+ BOOL ok;
+ Py_BEGIN_ALLOW_THREADS
+ ok = CreatePipe(&read, &write, NULL, 0);
+ Py_END_ALLOW_THREADS
+ if (!ok)
+ return win32_error("CreatePipe", NULL);
+ read_fd = _open_osfhandle((Py_intptr_t)read, 0);
+ write_fd = _open_osfhandle((Py_intptr_t)write, 1);
+ return Py_BuildValue("(ii)", read_fd, write_fd);
#endif /* MS_WINDOWS */
#endif
}
static PyObject *
posix_mkfifo(PyObject *self, PyObject *args)
{
- char *filename;
- int mode = 0666;
- int res;
- if (!PyArg_ParseTuple(args, "s|i:mkfifo", &filename, &mode))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- res = mkfifo(filename, mode);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ char *filename;
+ int mode = 0666;
+ int res;
+ if (!PyArg_ParseTuple(args, "s|i:mkfifo", &filename, &mode))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ res = mkfifo(filename, mode);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif
static PyObject *
posix_mknod(PyObject *self, PyObject *args)
{
- char *filename;
- int mode = 0600;
- int device = 0;
- int res;
- if (!PyArg_ParseTuple(args, "s|ii:mknod", &filename, &mode, &device))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- res = mknod(filename, mode, device);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ char *filename;
+ int mode = 0600;
+ int device = 0;
+ int res;
+ if (!PyArg_ParseTuple(args, "s|ii:mknod", &filename, &mode, &device))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ res = mknod(filename, mode, device);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif
static PyObject *
posix_major(PyObject *self, PyObject *args)
{
- int device;
- if (!PyArg_ParseTuple(args, "i:major", &device))
- return NULL;
- return PyLong_FromLong((long)major(device));
+ int device;
+ if (!PyArg_ParseTuple(args, "i:major", &device))
+ return NULL;
+ return PyLong_FromLong((long)major(device));
}
PyDoc_STRVAR(posix_minor__doc__,
static PyObject *
posix_minor(PyObject *self, PyObject *args)
{
- int device;
- if (!PyArg_ParseTuple(args, "i:minor", &device))
- return NULL;
- return PyLong_FromLong((long)minor(device));
+ int device;
+ if (!PyArg_ParseTuple(args, "i:minor", &device))
+ return NULL;
+ return PyLong_FromLong((long)minor(device));
}
PyDoc_STRVAR(posix_makedev__doc__,
static PyObject *
posix_makedev(PyObject *self, PyObject *args)
{
- int major, minor;
- if (!PyArg_ParseTuple(args, "ii:makedev", &major, &minor))
- return NULL;
- return PyLong_FromLong((long)makedev(major, minor));
+ int major, minor;
+ if (!PyArg_ParseTuple(args, "ii:makedev", &major, &minor))
+ return NULL;
+ return PyLong_FromLong((long)makedev(major, minor));
}
#endif /* device macros */
static PyObject *
posix_ftruncate(PyObject *self, PyObject *args)
{
- int fd;
- off_t length;
- int res;
- PyObject *lenobj;
+ int fd;
+ off_t length;
+ int res;
+ PyObject *lenobj;
- if (!PyArg_ParseTuple(args, "iO:ftruncate", &fd, &lenobj))
- return NULL;
+ if (!PyArg_ParseTuple(args, "iO:ftruncate", &fd, &lenobj))
+ return NULL;
#if !defined(HAVE_LARGEFILE_SUPPORT)
- length = PyLong_AsLong(lenobj);
+ length = PyLong_AsLong(lenobj);
#else
- length = PyLong_Check(lenobj) ?
- PyLong_AsLongLong(lenobj) : PyLong_AsLong(lenobj);
+ length = PyLong_Check(lenobj) ?
+ PyLong_AsLongLong(lenobj) : PyLong_AsLong(lenobj);
#endif
- if (PyErr_Occurred())
- return NULL;
+ if (PyErr_Occurred())
+ return NULL;
- Py_BEGIN_ALLOW_THREADS
- res = ftruncate(fd, length);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return posix_error();
- Py_INCREF(Py_None);
- return Py_None;
+ Py_BEGIN_ALLOW_THREADS
+ res = ftruncate(fd, length);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return posix_error();
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif
posix_putenv(PyObject *self, PyObject *args)
{
#ifdef MS_WINDOWS
- wchar_t *s1, *s2;
- wchar_t *newenv;
+ wchar_t *s1, *s2;
+ wchar_t *newenv;
#else
- PyObject *os1, *os2;
- char *s1, *s2;
- char *newenv;
+ PyObject *os1, *os2;
+ char *s1, *s2;
+ char *newenv;
#endif
- PyObject *newstr;
- size_t len;
+ PyObject *newstr;
+ size_t len;
#ifdef MS_WINDOWS
- if (!PyArg_ParseTuple(args,
- "uu:putenv",
- &s1, &s2))
- return NULL;
+ if (!PyArg_ParseTuple(args,
+ "uu:putenv",
+ &s1, &s2))
+ return NULL;
#else
- if (!PyArg_ParseTuple(args,
- "O&O&:putenv",
- PyUnicode_FSConverter, &os1,
- PyUnicode_FSConverter, &os2))
- return NULL;
- s1 = PyBytes_AsString(os1);
- s2 = PyBytes_AsString(os2);
+ if (!PyArg_ParseTuple(args,
+ "O&O&:putenv",
+ PyUnicode_FSConverter, &os1,
+ PyUnicode_FSConverter, &os2))
+ return NULL;
+ s1 = PyBytes_AsString(os1);
+ s2 = PyBytes_AsString(os2);
#endif
#if defined(PYOS_OS2)
return os2_error(rc);
} else {
#endif
- /* XXX This can leak memory -- not easy to fix :-( */
- /* len includes space for a trailing \0; the size arg to
- PyBytes_FromStringAndSize does not count that */
+ /* XXX This can leak memory -- not easy to fix :-( */
+ /* len includes space for a trailing \0; the size arg to
+ PyBytes_FromStringAndSize does not count that */
#ifdef MS_WINDOWS
- len = wcslen(s1) + wcslen(s2) + 2;
- newstr = PyUnicode_FromUnicode(NULL, (int)len - 1);
+ len = wcslen(s1) + wcslen(s2) + 2;
+ newstr = PyUnicode_FromUnicode(NULL, (int)len - 1);
#else
- len = strlen(s1) + strlen(s2) + 2;
- newstr = PyBytes_FromStringAndSize(NULL, (int)len - 1);
+ len = strlen(s1) + strlen(s2) + 2;
+ newstr = PyBytes_FromStringAndSize(NULL, (int)len - 1);
#endif
- if (newstr == NULL)
- return PyErr_NoMemory();
+ if (newstr == NULL)
+ return PyErr_NoMemory();
#ifdef MS_WINDOWS
- newenv = PyUnicode_AsUnicode(newstr);
- _snwprintf(newenv, len, L"%s=%s", s1, s2);
- if (_wputenv(newenv)) {
- Py_DECREF(newstr);
- posix_error();
- return NULL;
- }
+ newenv = PyUnicode_AsUnicode(newstr);
+ _snwprintf(newenv, len, L"%s=%s", s1, s2);
+ if (_wputenv(newenv)) {
+ Py_DECREF(newstr);
+ posix_error();
+ return NULL;
+ }
#else
- newenv = PyBytes_AS_STRING(newstr);
- PyOS_snprintf(newenv, len, "%s=%s", s1, s2);
- if (putenv(newenv)) {
- Py_DECREF(newstr);
- Py_DECREF(os1);
- Py_DECREF(os2);
- posix_error();
- return NULL;
- }
-#endif
- /* Install the first arg and newstr in posix_putenv_garbage;
- * this will cause previous value to be collected. This has to
- * happen after the real putenv() call because the old value
- * was still accessible until then. */
- if (PyDict_SetItem(posix_putenv_garbage,
- PyTuple_GET_ITEM(args, 0), newstr)) {
- /* really not much we can do; just leak */
- PyErr_Clear();
- }
- else {
- Py_DECREF(newstr);
- }
+ newenv = PyBytes_AS_STRING(newstr);
+ PyOS_snprintf(newenv, len, "%s=%s", s1, s2);
+ if (putenv(newenv)) {
+ Py_DECREF(newstr);
+ Py_DECREF(os1);
+ Py_DECREF(os2);
+ posix_error();
+ return NULL;
+ }
+#endif
+ /* Install the first arg and newstr in posix_putenv_garbage;
+ * this will cause previous value to be collected. This has to
+ * happen after the real putenv() call because the old value
+ * was still accessible until then. */
+ if (PyDict_SetItem(posix_putenv_garbage,
+ PyTuple_GET_ITEM(args, 0), newstr)) {
+ /* really not much we can do; just leak */
+ PyErr_Clear();
+ }
+ else {
+ Py_DECREF(newstr);
+ }
#if defined(PYOS_OS2)
}
#endif
#ifndef MS_WINDOWS
- Py_DECREF(os1);
- Py_DECREF(os2);
+ Py_DECREF(os1);
+ Py_DECREF(os2);
#endif
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* putenv */
static PyObject *
posix_unsetenv(PyObject *self, PyObject *args)
{
- char *s1;
+ char *s1;
- if (!PyArg_ParseTuple(args, "s:unsetenv", &s1))
- return NULL;
-
- unsetenv(s1);
+ if (!PyArg_ParseTuple(args, "s:unsetenv", &s1))
+ return NULL;
- /* Remove the key from posix_putenv_garbage;
- * this will cause it to be collected. This has to
- * happen after the real unsetenv() call because the
- * old value was still accessible until then.
- */
- if (PyDict_DelItem(posix_putenv_garbage,
- PyTuple_GET_ITEM(args, 0))) {
- /* really not much we can do; just leak */
- PyErr_Clear();
- }
+ unsetenv(s1);
+
+ /* Remove the key from posix_putenv_garbage;
+ * this will cause it to be collected. This has to
+ * happen after the real unsetenv() call because the
+ * old value was still accessible until then.
+ */
+ if (PyDict_DelItem(posix_putenv_garbage,
+ PyTuple_GET_ITEM(args, 0))) {
+ /* really not much we can do; just leak */
+ PyErr_Clear();
+ }
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif /* unsetenv */
static PyObject *
posix_strerror(PyObject *self, PyObject *args)
{
- int code;
- char *message;
- if (!PyArg_ParseTuple(args, "i:strerror", &code))
- return NULL;
- message = strerror(code);
- if (message == NULL) {
- PyErr_SetString(PyExc_ValueError,
- "strerror() argument out of range");
- return NULL;
- }
- return PyUnicode_FromString(message);
+ int code;
+ char *message;
+ if (!PyArg_ParseTuple(args, "i:strerror", &code))
+ return NULL;
+ message = strerror(code);
+ if (message == NULL) {
+ PyErr_SetString(PyExc_ValueError,
+ "strerror() argument out of range");
+ return NULL;
+ }
+ return PyUnicode_FromString(message);
}
static PyObject *
posix_WCOREDUMP(PyObject *self, PyObject *args)
{
- WAIT_TYPE status;
- WAIT_STATUS_INT(status) = 0;
+ WAIT_TYPE status;
+ WAIT_STATUS_INT(status) = 0;
- if (!PyArg_ParseTuple(args, "i:WCOREDUMP", &WAIT_STATUS_INT(status)))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:WCOREDUMP", &WAIT_STATUS_INT(status)))
+ return NULL;
- return PyBool_FromLong(WCOREDUMP(status));
+ return PyBool_FromLong(WCOREDUMP(status));
}
#endif /* WCOREDUMP */
static PyObject *
posix_WIFCONTINUED(PyObject *self, PyObject *args)
{
- WAIT_TYPE status;
- WAIT_STATUS_INT(status) = 0;
+ WAIT_TYPE status;
+ WAIT_STATUS_INT(status) = 0;
- if (!PyArg_ParseTuple(args, "i:WCONTINUED", &WAIT_STATUS_INT(status)))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:WCONTINUED", &WAIT_STATUS_INT(status)))
+ return NULL;
- return PyBool_FromLong(WIFCONTINUED(status));
+ return PyBool_FromLong(WIFCONTINUED(status));
}
#endif /* WIFCONTINUED */
static PyObject *
posix_WIFSTOPPED(PyObject *self, PyObject *args)
{
- WAIT_TYPE status;
- WAIT_STATUS_INT(status) = 0;
+ WAIT_TYPE status;
+ WAIT_STATUS_INT(status) = 0;
- if (!PyArg_ParseTuple(args, "i:WIFSTOPPED", &WAIT_STATUS_INT(status)))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:WIFSTOPPED", &WAIT_STATUS_INT(status)))
+ return NULL;
- return PyBool_FromLong(WIFSTOPPED(status));
+ return PyBool_FromLong(WIFSTOPPED(status));
}
#endif /* WIFSTOPPED */
static PyObject *
posix_WIFSIGNALED(PyObject *self, PyObject *args)
{
- WAIT_TYPE status;
- WAIT_STATUS_INT(status) = 0;
+ WAIT_TYPE status;
+ WAIT_STATUS_INT(status) = 0;
- if (!PyArg_ParseTuple(args, "i:WIFSIGNALED", &WAIT_STATUS_INT(status)))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:WIFSIGNALED", &WAIT_STATUS_INT(status)))
+ return NULL;
- return PyBool_FromLong(WIFSIGNALED(status));
+ return PyBool_FromLong(WIFSIGNALED(status));
}
#endif /* WIFSIGNALED */
static PyObject *
posix_WIFEXITED(PyObject *self, PyObject *args)
{
- WAIT_TYPE status;
- WAIT_STATUS_INT(status) = 0;
+ WAIT_TYPE status;
+ WAIT_STATUS_INT(status) = 0;
- if (!PyArg_ParseTuple(args, "i:WIFEXITED", &WAIT_STATUS_INT(status)))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:WIFEXITED", &WAIT_STATUS_INT(status)))
+ return NULL;
- return PyBool_FromLong(WIFEXITED(status));
+ return PyBool_FromLong(WIFEXITED(status));
}
#endif /* WIFEXITED */
static PyObject *
posix_WEXITSTATUS(PyObject *self, PyObject *args)
{
- WAIT_TYPE status;
- WAIT_STATUS_INT(status) = 0;
+ WAIT_TYPE status;
+ WAIT_STATUS_INT(status) = 0;
- if (!PyArg_ParseTuple(args, "i:WEXITSTATUS", &WAIT_STATUS_INT(status)))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:WEXITSTATUS", &WAIT_STATUS_INT(status)))
+ return NULL;
- return Py_BuildValue("i", WEXITSTATUS(status));
+ return Py_BuildValue("i", WEXITSTATUS(status));
}
#endif /* WEXITSTATUS */
static PyObject *
posix_WTERMSIG(PyObject *self, PyObject *args)
{
- WAIT_TYPE status;
- WAIT_STATUS_INT(status) = 0;
+ WAIT_TYPE status;
+ WAIT_STATUS_INT(status) = 0;
- if (!PyArg_ParseTuple(args, "i:WTERMSIG", &WAIT_STATUS_INT(status)))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:WTERMSIG", &WAIT_STATUS_INT(status)))
+ return NULL;
- return Py_BuildValue("i", WTERMSIG(status));
+ return Py_BuildValue("i", WTERMSIG(status));
}
#endif /* WTERMSIG */
static PyObject *
posix_WSTOPSIG(PyObject *self, PyObject *args)
{
- WAIT_TYPE status;
- WAIT_STATUS_INT(status) = 0;
+ WAIT_TYPE status;
+ WAIT_STATUS_INT(status) = 0;
- if (!PyArg_ParseTuple(args, "i:WSTOPSIG", &WAIT_STATUS_INT(status)))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:WSTOPSIG", &WAIT_STATUS_INT(status)))
+ return NULL;
- return Py_BuildValue("i", WSTOPSIG(status));
+ return Py_BuildValue("i", WSTOPSIG(status));
}
#endif /* WSTOPSIG */
static PyObject*
_pystatvfs_fromstructstatvfs(struct statvfs st) {
- PyObject *v = PyStructSequence_New(&StatVFSResultType);
- if (v == NULL)
- return NULL;
+ PyObject *v = PyStructSequence_New(&StatVFSResultType);
+ if (v == NULL)
+ return NULL;
#if !defined(HAVE_LARGEFILE_SUPPORT)
- PyStructSequence_SET_ITEM(v, 0, PyLong_FromLong((long) st.f_bsize));
- PyStructSequence_SET_ITEM(v, 1, PyLong_FromLong((long) st.f_frsize));
- PyStructSequence_SET_ITEM(v, 2, PyLong_FromLong((long) st.f_blocks));
- PyStructSequence_SET_ITEM(v, 3, PyLong_FromLong((long) st.f_bfree));
- PyStructSequence_SET_ITEM(v, 4, PyLong_FromLong((long) st.f_bavail));
- PyStructSequence_SET_ITEM(v, 5, PyLong_FromLong((long) st.f_files));
- PyStructSequence_SET_ITEM(v, 6, PyLong_FromLong((long) st.f_ffree));
- PyStructSequence_SET_ITEM(v, 7, PyLong_FromLong((long) st.f_favail));
- PyStructSequence_SET_ITEM(v, 8, PyLong_FromLong((long) st.f_flag));
- PyStructSequence_SET_ITEM(v, 9, PyLong_FromLong((long) st.f_namemax));
+ PyStructSequence_SET_ITEM(v, 0, PyLong_FromLong((long) st.f_bsize));
+ PyStructSequence_SET_ITEM(v, 1, PyLong_FromLong((long) st.f_frsize));
+ PyStructSequence_SET_ITEM(v, 2, PyLong_FromLong((long) st.f_blocks));
+ PyStructSequence_SET_ITEM(v, 3, PyLong_FromLong((long) st.f_bfree));
+ PyStructSequence_SET_ITEM(v, 4, PyLong_FromLong((long) st.f_bavail));
+ PyStructSequence_SET_ITEM(v, 5, PyLong_FromLong((long) st.f_files));
+ PyStructSequence_SET_ITEM(v, 6, PyLong_FromLong((long) st.f_ffree));
+ PyStructSequence_SET_ITEM(v, 7, PyLong_FromLong((long) st.f_favail));
+ PyStructSequence_SET_ITEM(v, 8, PyLong_FromLong((long) st.f_flag));
+ PyStructSequence_SET_ITEM(v, 9, PyLong_FromLong((long) st.f_namemax));
#else
- PyStructSequence_SET_ITEM(v, 0, PyLong_FromLong((long) st.f_bsize));
- PyStructSequence_SET_ITEM(v, 1, PyLong_FromLong((long) st.f_frsize));
- PyStructSequence_SET_ITEM(v, 2,
- PyLong_FromLongLong((PY_LONG_LONG) st.f_blocks));
- PyStructSequence_SET_ITEM(v, 3,
- PyLong_FromLongLong((PY_LONG_LONG) st.f_bfree));
- PyStructSequence_SET_ITEM(v, 4,
- PyLong_FromLongLong((PY_LONG_LONG) st.f_bavail));
- PyStructSequence_SET_ITEM(v, 5,
- PyLong_FromLongLong((PY_LONG_LONG) st.f_files));
- PyStructSequence_SET_ITEM(v, 6,
- PyLong_FromLongLong((PY_LONG_LONG) st.f_ffree));
- PyStructSequence_SET_ITEM(v, 7,
- PyLong_FromLongLong((PY_LONG_LONG) st.f_favail));
- PyStructSequence_SET_ITEM(v, 8, PyLong_FromLong((long) st.f_flag));
- PyStructSequence_SET_ITEM(v, 9, PyLong_FromLong((long) st.f_namemax));
-#endif
-
- return v;
+ PyStructSequence_SET_ITEM(v, 0, PyLong_FromLong((long) st.f_bsize));
+ PyStructSequence_SET_ITEM(v, 1, PyLong_FromLong((long) st.f_frsize));
+ PyStructSequence_SET_ITEM(v, 2,
+ PyLong_FromLongLong((PY_LONG_LONG) st.f_blocks));
+ PyStructSequence_SET_ITEM(v, 3,
+ PyLong_FromLongLong((PY_LONG_LONG) st.f_bfree));
+ PyStructSequence_SET_ITEM(v, 4,
+ PyLong_FromLongLong((PY_LONG_LONG) st.f_bavail));
+ PyStructSequence_SET_ITEM(v, 5,
+ PyLong_FromLongLong((PY_LONG_LONG) st.f_files));
+ PyStructSequence_SET_ITEM(v, 6,
+ PyLong_FromLongLong((PY_LONG_LONG) st.f_ffree));
+ PyStructSequence_SET_ITEM(v, 7,
+ PyLong_FromLongLong((PY_LONG_LONG) st.f_favail));
+ PyStructSequence_SET_ITEM(v, 8, PyLong_FromLong((long) st.f_flag));
+ PyStructSequence_SET_ITEM(v, 9, PyLong_FromLong((long) st.f_namemax));
+#endif
+
+ return v;
}
PyDoc_STRVAR(posix_fstatvfs__doc__,
static PyObject *
posix_fstatvfs(PyObject *self, PyObject *args)
{
- int fd, res;
- struct statvfs st;
+ int fd, res;
+ struct statvfs st;
- if (!PyArg_ParseTuple(args, "i:fstatvfs", &fd))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- res = fstatvfs(fd, &st);
- Py_END_ALLOW_THREADS
- if (res != 0)
- return posix_error();
+ if (!PyArg_ParseTuple(args, "i:fstatvfs", &fd))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ res = fstatvfs(fd, &st);
+ Py_END_ALLOW_THREADS
+ if (res != 0)
+ return posix_error();
- return _pystatvfs_fromstructstatvfs(st);
+ return _pystatvfs_fromstructstatvfs(st);
}
#endif /* HAVE_FSTATVFS && HAVE_SYS_STATVFS_H */
static PyObject *
posix_statvfs(PyObject *self, PyObject *args)
{
- char *path;
- int res;
- struct statvfs st;
- if (!PyArg_ParseTuple(args, "s:statvfs", &path))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- res = statvfs(path, &st);
- Py_END_ALLOW_THREADS
- if (res != 0)
- return posix_error_with_filename(path);
+ char *path;
+ int res;
+ struct statvfs st;
+ if (!PyArg_ParseTuple(args, "s:statvfs", &path))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ res = statvfs(path, &st);
+ Py_END_ALLOW_THREADS
+ if (res != 0)
+ return posix_error_with_filename(path);
- return _pystatvfs_fromstructstatvfs(st);
+ return _pystatvfs_fromstructstatvfs(st);
}
#endif /* HAVE_STATVFS */
size_t tablesize)
{
if (PyLong_Check(arg)) {
- *valuep = PyLong_AS_LONG(arg);
- return 1;
+ *valuep = PyLong_AS_LONG(arg);
+ return 1;
}
else {
- /* look up the value in the table using a binary search */
- size_t lo = 0;
- size_t mid;
- size_t hi = tablesize;
- int cmp;
- const char *confname;
- if (!PyUnicode_Check(arg)) {
- PyErr_SetString(PyExc_TypeError,
- "configuration names must be strings or integers");
- return 0;
- }
- confname = _PyUnicode_AsString(arg);
- if (confname == NULL)
- return 0;
- while (lo < hi) {
- mid = (lo + hi) / 2;
- cmp = strcmp(confname, table[mid].name);
- if (cmp < 0)
- hi = mid;
- else if (cmp > 0)
- lo = mid + 1;
- else {
- *valuep = table[mid].value;
- return 1;
- }
- }
- PyErr_SetString(PyExc_ValueError, "unrecognized configuration name");
+ /* look up the value in the table using a binary search */
+ size_t lo = 0;
+ size_t mid;
+ size_t hi = tablesize;
+ int cmp;
+ const char *confname;
+ if (!PyUnicode_Check(arg)) {
+ PyErr_SetString(PyExc_TypeError,
+ "configuration names must be strings or integers");
return 0;
}
+ confname = _PyUnicode_AsString(arg);
+ if (confname == NULL)
+ return 0;
+ while (lo < hi) {
+ mid = (lo + hi) / 2;
+ cmp = strcmp(confname, table[mid].name);
+ if (cmp < 0)
+ hi = mid;
+ else if (cmp > 0)
+ lo = mid + 1;
+ else {
+ *valuep = table[mid].value;
+ return 1;
+ }
+ }
+ PyErr_SetString(PyExc_ValueError, "unrecognized configuration name");
+ return 0;
+ }
}
#if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)
static struct constdef posix_constants_pathconf[] = {
#ifdef _PC_ABI_AIO_XFER_MAX
- {"PC_ABI_AIO_XFER_MAX", _PC_ABI_AIO_XFER_MAX},
+ {"PC_ABI_AIO_XFER_MAX", _PC_ABI_AIO_XFER_MAX},
#endif
#ifdef _PC_ABI_ASYNC_IO
- {"PC_ABI_ASYNC_IO", _PC_ABI_ASYNC_IO},
+ {"PC_ABI_ASYNC_IO", _PC_ABI_ASYNC_IO},
#endif
#ifdef _PC_ASYNC_IO
- {"PC_ASYNC_IO", _PC_ASYNC_IO},
+ {"PC_ASYNC_IO", _PC_ASYNC_IO},
#endif
#ifdef _PC_CHOWN_RESTRICTED
- {"PC_CHOWN_RESTRICTED", _PC_CHOWN_RESTRICTED},
+ {"PC_CHOWN_RESTRICTED", _PC_CHOWN_RESTRICTED},
#endif
#ifdef _PC_FILESIZEBITS
- {"PC_FILESIZEBITS", _PC_FILESIZEBITS},
+ {"PC_FILESIZEBITS", _PC_FILESIZEBITS},
#endif
#ifdef _PC_LAST
- {"PC_LAST", _PC_LAST},
+ {"PC_LAST", _PC_LAST},
#endif
#ifdef _PC_LINK_MAX
- {"PC_LINK_MAX", _PC_LINK_MAX},
+ {"PC_LINK_MAX", _PC_LINK_MAX},
#endif
#ifdef _PC_MAX_CANON
- {"PC_MAX_CANON", _PC_MAX_CANON},
+ {"PC_MAX_CANON", _PC_MAX_CANON},
#endif
#ifdef _PC_MAX_INPUT
- {"PC_MAX_INPUT", _PC_MAX_INPUT},
+ {"PC_MAX_INPUT", _PC_MAX_INPUT},
#endif
#ifdef _PC_NAME_MAX
- {"PC_NAME_MAX", _PC_NAME_MAX},
+ {"PC_NAME_MAX", _PC_NAME_MAX},
#endif
#ifdef _PC_NO_TRUNC
- {"PC_NO_TRUNC", _PC_NO_TRUNC},
+ {"PC_NO_TRUNC", _PC_NO_TRUNC},
#endif
#ifdef _PC_PATH_MAX
- {"PC_PATH_MAX", _PC_PATH_MAX},
+ {"PC_PATH_MAX", _PC_PATH_MAX},
#endif
#ifdef _PC_PIPE_BUF
- {"PC_PIPE_BUF", _PC_PIPE_BUF},
+ {"PC_PIPE_BUF", _PC_PIPE_BUF},
#endif
#ifdef _PC_PRIO_IO
- {"PC_PRIO_IO", _PC_PRIO_IO},
+ {"PC_PRIO_IO", _PC_PRIO_IO},
#endif
#ifdef _PC_SOCK_MAXBUF
- {"PC_SOCK_MAXBUF", _PC_SOCK_MAXBUF},
+ {"PC_SOCK_MAXBUF", _PC_SOCK_MAXBUF},
#endif
#ifdef _PC_SYNC_IO
- {"PC_SYNC_IO", _PC_SYNC_IO},
+ {"PC_SYNC_IO", _PC_SYNC_IO},
#endif
#ifdef _PC_VDISABLE
- {"PC_VDISABLE", _PC_VDISABLE},
+ {"PC_VDISABLE", _PC_VDISABLE},
#endif
};
if (PyArg_ParseTuple(args, "iO&:fpathconf", &fd,
conv_path_confname, &name)) {
- long limit;
+ long limit;
- errno = 0;
- limit = fpathconf(fd, name);
- if (limit == -1 && errno != 0)
- posix_error();
- else
- result = PyLong_FromLong(limit);
+ errno = 0;
+ limit = fpathconf(fd, name);
+ if (limit == -1 && errno != 0)
+ posix_error();
+ else
+ result = PyLong_FromLong(limit);
}
return result;
}
if (PyArg_ParseTuple(args, "sO&:pathconf", &path,
conv_path_confname, &name)) {
- long limit;
-
- errno = 0;
- limit = pathconf(path, name);
- if (limit == -1 && errno != 0) {
- if (errno == EINVAL)
- /* could be a path or name problem */
- posix_error();
- else
- posix_error_with_filename(path);
- }
+ long limit;
+
+ errno = 0;
+ limit = pathconf(path, name);
+ if (limit == -1 && errno != 0) {
+ if (errno == EINVAL)
+ /* could be a path or name problem */
+ posix_error();
else
- result = PyLong_FromLong(limit);
+ posix_error_with_filename(path);
+ }
+ else
+ result = PyLong_FromLong(limit);
}
return result;
}
#ifdef HAVE_CONFSTR
static struct constdef posix_constants_confstr[] = {
#ifdef _CS_ARCHITECTURE
- {"CS_ARCHITECTURE", _CS_ARCHITECTURE},
+ {"CS_ARCHITECTURE", _CS_ARCHITECTURE},
#endif
#ifdef _CS_GNU_LIBC_VERSION
- {"CS_GNU_LIBC_VERSION", _CS_GNU_LIBC_VERSION},
+ {"CS_GNU_LIBC_VERSION", _CS_GNU_LIBC_VERSION},
#endif
#ifdef _CS_GNU_LIBPTHREAD_VERSION
- {"CS_GNU_LIBPTHREAD_VERSION", _CS_GNU_LIBPTHREAD_VERSION},
+ {"CS_GNU_LIBPTHREAD_VERSION", _CS_GNU_LIBPTHREAD_VERSION},
#endif
#ifdef _CS_HOSTNAME
- {"CS_HOSTNAME", _CS_HOSTNAME},
+ {"CS_HOSTNAME", _CS_HOSTNAME},
#endif
#ifdef _CS_HW_PROVIDER
- {"CS_HW_PROVIDER", _CS_HW_PROVIDER},
+ {"CS_HW_PROVIDER", _CS_HW_PROVIDER},
#endif
#ifdef _CS_HW_SERIAL
- {"CS_HW_SERIAL", _CS_HW_SERIAL},
+ {"CS_HW_SERIAL", _CS_HW_SERIAL},
#endif
#ifdef _CS_INITTAB_NAME
- {"CS_INITTAB_NAME", _CS_INITTAB_NAME},
+ {"CS_INITTAB_NAME", _CS_INITTAB_NAME},
#endif
#ifdef _CS_LFS64_CFLAGS
- {"CS_LFS64_CFLAGS", _CS_LFS64_CFLAGS},
+ {"CS_LFS64_CFLAGS", _CS_LFS64_CFLAGS},
#endif
#ifdef _CS_LFS64_LDFLAGS
- {"CS_LFS64_LDFLAGS", _CS_LFS64_LDFLAGS},
+ {"CS_LFS64_LDFLAGS", _CS_LFS64_LDFLAGS},
#endif
#ifdef _CS_LFS64_LIBS
- {"CS_LFS64_LIBS", _CS_LFS64_LIBS},
+ {"CS_LFS64_LIBS", _CS_LFS64_LIBS},
#endif
#ifdef _CS_LFS64_LINTFLAGS
- {"CS_LFS64_LINTFLAGS", _CS_LFS64_LINTFLAGS},
+ {"CS_LFS64_LINTFLAGS", _CS_LFS64_LINTFLAGS},
#endif
#ifdef _CS_LFS_CFLAGS
- {"CS_LFS_CFLAGS", _CS_LFS_CFLAGS},
+ {"CS_LFS_CFLAGS", _CS_LFS_CFLAGS},
#endif
#ifdef _CS_LFS_LDFLAGS
- {"CS_LFS_LDFLAGS", _CS_LFS_LDFLAGS},
+ {"CS_LFS_LDFLAGS", _CS_LFS_LDFLAGS},
#endif
#ifdef _CS_LFS_LIBS
- {"CS_LFS_LIBS", _CS_LFS_LIBS},
+ {"CS_LFS_LIBS", _CS_LFS_LIBS},
#endif
#ifdef _CS_LFS_LINTFLAGS
- {"CS_LFS_LINTFLAGS", _CS_LFS_LINTFLAGS},
+ {"CS_LFS_LINTFLAGS", _CS_LFS_LINTFLAGS},
#endif
#ifdef _CS_MACHINE
- {"CS_MACHINE", _CS_MACHINE},
+ {"CS_MACHINE", _CS_MACHINE},
#endif
#ifdef _CS_PATH
- {"CS_PATH", _CS_PATH},
+ {"CS_PATH", _CS_PATH},
#endif
#ifdef _CS_RELEASE
- {"CS_RELEASE", _CS_RELEASE},
+ {"CS_RELEASE", _CS_RELEASE},
#endif
#ifdef _CS_SRPC_DOMAIN
- {"CS_SRPC_DOMAIN", _CS_SRPC_DOMAIN},
+ {"CS_SRPC_DOMAIN", _CS_SRPC_DOMAIN},
#endif
#ifdef _CS_SYSNAME
- {"CS_SYSNAME", _CS_SYSNAME},
+ {"CS_SYSNAME", _CS_SYSNAME},
#endif
#ifdef _CS_VERSION
- {"CS_VERSION", _CS_VERSION},
+ {"CS_VERSION", _CS_VERSION},
#endif
#ifdef _CS_XBS5_ILP32_OFF32_CFLAGS
- {"CS_XBS5_ILP32_OFF32_CFLAGS", _CS_XBS5_ILP32_OFF32_CFLAGS},
+ {"CS_XBS5_ILP32_OFF32_CFLAGS", _CS_XBS5_ILP32_OFF32_CFLAGS},
#endif
#ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS
- {"CS_XBS5_ILP32_OFF32_LDFLAGS", _CS_XBS5_ILP32_OFF32_LDFLAGS},
+ {"CS_XBS5_ILP32_OFF32_LDFLAGS", _CS_XBS5_ILP32_OFF32_LDFLAGS},
#endif
#ifdef _CS_XBS5_ILP32_OFF32_LIBS
- {"CS_XBS5_ILP32_OFF32_LIBS", _CS_XBS5_ILP32_OFF32_LIBS},
+ {"CS_XBS5_ILP32_OFF32_LIBS", _CS_XBS5_ILP32_OFF32_LIBS},
#endif
#ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS
- {"CS_XBS5_ILP32_OFF32_LINTFLAGS", _CS_XBS5_ILP32_OFF32_LINTFLAGS},
+ {"CS_XBS5_ILP32_OFF32_LINTFLAGS", _CS_XBS5_ILP32_OFF32_LINTFLAGS},
#endif
#ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS
- {"CS_XBS5_ILP32_OFFBIG_CFLAGS", _CS_XBS5_ILP32_OFFBIG_CFLAGS},
+ {"CS_XBS5_ILP32_OFFBIG_CFLAGS", _CS_XBS5_ILP32_OFFBIG_CFLAGS},
#endif
#ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS
- {"CS_XBS5_ILP32_OFFBIG_LDFLAGS", _CS_XBS5_ILP32_OFFBIG_LDFLAGS},
+ {"CS_XBS5_ILP32_OFFBIG_LDFLAGS", _CS_XBS5_ILP32_OFFBIG_LDFLAGS},
#endif
#ifdef _CS_XBS5_ILP32_OFFBIG_LIBS
- {"CS_XBS5_ILP32_OFFBIG_LIBS", _CS_XBS5_ILP32_OFFBIG_LIBS},
+ {"CS_XBS5_ILP32_OFFBIG_LIBS", _CS_XBS5_ILP32_OFFBIG_LIBS},
#endif
#ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
- {"CS_XBS5_ILP32_OFFBIG_LINTFLAGS", _CS_XBS5_ILP32_OFFBIG_LINTFLAGS},
+ {"CS_XBS5_ILP32_OFFBIG_LINTFLAGS", _CS_XBS5_ILP32_OFFBIG_LINTFLAGS},
#endif
#ifdef _CS_XBS5_LP64_OFF64_CFLAGS
- {"CS_XBS5_LP64_OFF64_CFLAGS", _CS_XBS5_LP64_OFF64_CFLAGS},
+ {"CS_XBS5_LP64_OFF64_CFLAGS", _CS_XBS5_LP64_OFF64_CFLAGS},
#endif
#ifdef _CS_XBS5_LP64_OFF64_LDFLAGS
- {"CS_XBS5_LP64_OFF64_LDFLAGS", _CS_XBS5_LP64_OFF64_LDFLAGS},
+ {"CS_XBS5_LP64_OFF64_LDFLAGS", _CS_XBS5_LP64_OFF64_LDFLAGS},
#endif
#ifdef _CS_XBS5_LP64_OFF64_LIBS
- {"CS_XBS5_LP64_OFF64_LIBS", _CS_XBS5_LP64_OFF64_LIBS},
+ {"CS_XBS5_LP64_OFF64_LIBS", _CS_XBS5_LP64_OFF64_LIBS},
#endif
#ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS
- {"CS_XBS5_LP64_OFF64_LINTFLAGS", _CS_XBS5_LP64_OFF64_LINTFLAGS},
+ {"CS_XBS5_LP64_OFF64_LINTFLAGS", _CS_XBS5_LP64_OFF64_LINTFLAGS},
#endif
#ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS
- {"CS_XBS5_LPBIG_OFFBIG_CFLAGS", _CS_XBS5_LPBIG_OFFBIG_CFLAGS},
+ {"CS_XBS5_LPBIG_OFFBIG_CFLAGS", _CS_XBS5_LPBIG_OFFBIG_CFLAGS},
#endif
#ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
- {"CS_XBS5_LPBIG_OFFBIG_LDFLAGS", _CS_XBS5_LPBIG_OFFBIG_LDFLAGS},
+ {"CS_XBS5_LPBIG_OFFBIG_LDFLAGS", _CS_XBS5_LPBIG_OFFBIG_LDFLAGS},
#endif
#ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS
- {"CS_XBS5_LPBIG_OFFBIG_LIBS", _CS_XBS5_LPBIG_OFFBIG_LIBS},
+ {"CS_XBS5_LPBIG_OFFBIG_LIBS", _CS_XBS5_LPBIG_OFFBIG_LIBS},
#endif
#ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
- {"CS_XBS5_LPBIG_OFFBIG_LINTFLAGS", _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS},
+ {"CS_XBS5_LPBIG_OFFBIG_LINTFLAGS", _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS},
#endif
#ifdef _MIPS_CS_AVAIL_PROCESSORS
- {"MIPS_CS_AVAIL_PROCESSORS", _MIPS_CS_AVAIL_PROCESSORS},
+ {"MIPS_CS_AVAIL_PROCESSORS", _MIPS_CS_AVAIL_PROCESSORS},
#endif
#ifdef _MIPS_CS_BASE
- {"MIPS_CS_BASE", _MIPS_CS_BASE},
+ {"MIPS_CS_BASE", _MIPS_CS_BASE},
#endif
#ifdef _MIPS_CS_HOSTID
- {"MIPS_CS_HOSTID", _MIPS_CS_HOSTID},
+ {"MIPS_CS_HOSTID", _MIPS_CS_HOSTID},
#endif
#ifdef _MIPS_CS_HW_NAME
- {"MIPS_CS_HW_NAME", _MIPS_CS_HW_NAME},
+ {"MIPS_CS_HW_NAME", _MIPS_CS_HW_NAME},
#endif
#ifdef _MIPS_CS_NUM_PROCESSORS
- {"MIPS_CS_NUM_PROCESSORS", _MIPS_CS_NUM_PROCESSORS},
+ {"MIPS_CS_NUM_PROCESSORS", _MIPS_CS_NUM_PROCESSORS},
#endif
#ifdef _MIPS_CS_OSREL_MAJ
- {"MIPS_CS_OSREL_MAJ", _MIPS_CS_OSREL_MAJ},
+ {"MIPS_CS_OSREL_MAJ", _MIPS_CS_OSREL_MAJ},
#endif
#ifdef _MIPS_CS_OSREL_MIN
- {"MIPS_CS_OSREL_MIN", _MIPS_CS_OSREL_MIN},
+ {"MIPS_CS_OSREL_MIN", _MIPS_CS_OSREL_MIN},
#endif
#ifdef _MIPS_CS_OSREL_PATCH
- {"MIPS_CS_OSREL_PATCH", _MIPS_CS_OSREL_PATCH},
+ {"MIPS_CS_OSREL_PATCH", _MIPS_CS_OSREL_PATCH},
#endif
#ifdef _MIPS_CS_OS_NAME
- {"MIPS_CS_OS_NAME", _MIPS_CS_OS_NAME},
+ {"MIPS_CS_OS_NAME", _MIPS_CS_OS_NAME},
#endif
#ifdef _MIPS_CS_OS_PROVIDER
- {"MIPS_CS_OS_PROVIDER", _MIPS_CS_OS_PROVIDER},
+ {"MIPS_CS_OS_PROVIDER", _MIPS_CS_OS_PROVIDER},
#endif
#ifdef _MIPS_CS_PROCESSORS
- {"MIPS_CS_PROCESSORS", _MIPS_CS_PROCESSORS},
+ {"MIPS_CS_PROCESSORS", _MIPS_CS_PROCESSORS},
#endif
#ifdef _MIPS_CS_SERIAL
- {"MIPS_CS_SERIAL", _MIPS_CS_SERIAL},
+ {"MIPS_CS_SERIAL", _MIPS_CS_SERIAL},
#endif
#ifdef _MIPS_CS_VENDOR
- {"MIPS_CS_VENDOR", _MIPS_CS_VENDOR},
+ {"MIPS_CS_VENDOR", _MIPS_CS_VENDOR},
#endif
};
char buffer[256];
if (PyArg_ParseTuple(args, "O&:confstr", conv_confstr_confname, &name)) {
- int len;
+ int len;
errno = 0;
- len = confstr(name, buffer, sizeof(buffer));
- if (len == 0) {
- if (errno) {
- posix_error();
- }
- else {
- result = Py_None;
- Py_INCREF(Py_None);
- }
+ len = confstr(name, buffer, sizeof(buffer));
+ if (len == 0) {
+ if (errno) {
+ posix_error();
+ }
+ else {
+ result = Py_None;
+ Py_INCREF(Py_None);
+ }
}
else {
- if ((unsigned int)len >= sizeof(buffer)) {
+ if ((unsigned int)len >= sizeof(buffer)) {
result = PyUnicode_FromStringAndSize(NULL, len-1);
if (result != NULL)
confstr(name, _PyUnicode_AsString(result), len);
#ifdef HAVE_SYSCONF
static struct constdef posix_constants_sysconf[] = {
#ifdef _SC_2_CHAR_TERM
- {"SC_2_CHAR_TERM", _SC_2_CHAR_TERM},
+ {"SC_2_CHAR_TERM", _SC_2_CHAR_TERM},
#endif
#ifdef _SC_2_C_BIND
- {"SC_2_C_BIND", _SC_2_C_BIND},
+ {"SC_2_C_BIND", _SC_2_C_BIND},
#endif
#ifdef _SC_2_C_DEV
- {"SC_2_C_DEV", _SC_2_C_DEV},
+ {"SC_2_C_DEV", _SC_2_C_DEV},
#endif
#ifdef _SC_2_C_VERSION
- {"SC_2_C_VERSION", _SC_2_C_VERSION},
+ {"SC_2_C_VERSION", _SC_2_C_VERSION},
#endif
#ifdef _SC_2_FORT_DEV
- {"SC_2_FORT_DEV", _SC_2_FORT_DEV},
+ {"SC_2_FORT_DEV", _SC_2_FORT_DEV},
#endif
#ifdef _SC_2_FORT_RUN
- {"SC_2_FORT_RUN", _SC_2_FORT_RUN},
+ {"SC_2_FORT_RUN", _SC_2_FORT_RUN},
#endif
#ifdef _SC_2_LOCALEDEF
- {"SC_2_LOCALEDEF", _SC_2_LOCALEDEF},
+ {"SC_2_LOCALEDEF", _SC_2_LOCALEDEF},
#endif
#ifdef _SC_2_SW_DEV
- {"SC_2_SW_DEV", _SC_2_SW_DEV},
+ {"SC_2_SW_DEV", _SC_2_SW_DEV},
#endif
#ifdef _SC_2_UPE
- {"SC_2_UPE", _SC_2_UPE},
+ {"SC_2_UPE", _SC_2_UPE},
#endif
#ifdef _SC_2_VERSION
- {"SC_2_VERSION", _SC_2_VERSION},
+ {"SC_2_VERSION", _SC_2_VERSION},
#endif
#ifdef _SC_ABI_ASYNCHRONOUS_IO
- {"SC_ABI_ASYNCHRONOUS_IO", _SC_ABI_ASYNCHRONOUS_IO},
+ {"SC_ABI_ASYNCHRONOUS_IO", _SC_ABI_ASYNCHRONOUS_IO},
#endif
#ifdef _SC_ACL
- {"SC_ACL", _SC_ACL},
+ {"SC_ACL", _SC_ACL},
#endif
#ifdef _SC_AIO_LISTIO_MAX
- {"SC_AIO_LISTIO_MAX", _SC_AIO_LISTIO_MAX},
+ {"SC_AIO_LISTIO_MAX", _SC_AIO_LISTIO_MAX},
#endif
#ifdef _SC_AIO_MAX
- {"SC_AIO_MAX", _SC_AIO_MAX},
+ {"SC_AIO_MAX", _SC_AIO_MAX},
#endif
#ifdef _SC_AIO_PRIO_DELTA_MAX
- {"SC_AIO_PRIO_DELTA_MAX", _SC_AIO_PRIO_DELTA_MAX},
+ {"SC_AIO_PRIO_DELTA_MAX", _SC_AIO_PRIO_DELTA_MAX},
#endif
#ifdef _SC_ARG_MAX
- {"SC_ARG_MAX", _SC_ARG_MAX},
+ {"SC_ARG_MAX", _SC_ARG_MAX},
#endif
#ifdef _SC_ASYNCHRONOUS_IO
- {"SC_ASYNCHRONOUS_IO", _SC_ASYNCHRONOUS_IO},
+ {"SC_ASYNCHRONOUS_IO", _SC_ASYNCHRONOUS_IO},
#endif
#ifdef _SC_ATEXIT_MAX
- {"SC_ATEXIT_MAX", _SC_ATEXIT_MAX},
+ {"SC_ATEXIT_MAX", _SC_ATEXIT_MAX},
#endif
#ifdef _SC_AUDIT
- {"SC_AUDIT", _SC_AUDIT},
+ {"SC_AUDIT", _SC_AUDIT},
#endif
#ifdef _SC_AVPHYS_PAGES
- {"SC_AVPHYS_PAGES", _SC_AVPHYS_PAGES},
+ {"SC_AVPHYS_PAGES", _SC_AVPHYS_PAGES},
#endif
#ifdef _SC_BC_BASE_MAX
- {"SC_BC_BASE_MAX", _SC_BC_BASE_MAX},
+ {"SC_BC_BASE_MAX", _SC_BC_BASE_MAX},
#endif
#ifdef _SC_BC_DIM_MAX
- {"SC_BC_DIM_MAX", _SC_BC_DIM_MAX},
+ {"SC_BC_DIM_MAX", _SC_BC_DIM_MAX},
#endif
#ifdef _SC_BC_SCALE_MAX
- {"SC_BC_SCALE_MAX", _SC_BC_SCALE_MAX},
+ {"SC_BC_SCALE_MAX", _SC_BC_SCALE_MAX},
#endif
#ifdef _SC_BC_STRING_MAX
- {"SC_BC_STRING_MAX", _SC_BC_STRING_MAX},
+ {"SC_BC_STRING_MAX", _SC_BC_STRING_MAX},
#endif
#ifdef _SC_CAP
- {"SC_CAP", _SC_CAP},
+ {"SC_CAP", _SC_CAP},
#endif
#ifdef _SC_CHARCLASS_NAME_MAX
- {"SC_CHARCLASS_NAME_MAX", _SC_CHARCLASS_NAME_MAX},
+ {"SC_CHARCLASS_NAME_MAX", _SC_CHARCLASS_NAME_MAX},
#endif
#ifdef _SC_CHAR_BIT
- {"SC_CHAR_BIT", _SC_CHAR_BIT},
+ {"SC_CHAR_BIT", _SC_CHAR_BIT},
#endif
#ifdef _SC_CHAR_MAX
- {"SC_CHAR_MAX", _SC_CHAR_MAX},
+ {"SC_CHAR_MAX", _SC_CHAR_MAX},
#endif
#ifdef _SC_CHAR_MIN
- {"SC_CHAR_MIN", _SC_CHAR_MIN},
+ {"SC_CHAR_MIN", _SC_CHAR_MIN},
#endif
#ifdef _SC_CHILD_MAX
- {"SC_CHILD_MAX", _SC_CHILD_MAX},
+ {"SC_CHILD_MAX", _SC_CHILD_MAX},
#endif
#ifdef _SC_CLK_TCK
- {"SC_CLK_TCK", _SC_CLK_TCK},
+ {"SC_CLK_TCK", _SC_CLK_TCK},
#endif
#ifdef _SC_COHER_BLKSZ
- {"SC_COHER_BLKSZ", _SC_COHER_BLKSZ},
+ {"SC_COHER_BLKSZ", _SC_COHER_BLKSZ},
#endif
#ifdef _SC_COLL_WEIGHTS_MAX
- {"SC_COLL_WEIGHTS_MAX", _SC_COLL_WEIGHTS_MAX},
+ {"SC_COLL_WEIGHTS_MAX", _SC_COLL_WEIGHTS_MAX},
#endif
#ifdef _SC_DCACHE_ASSOC
- {"SC_DCACHE_ASSOC", _SC_DCACHE_ASSOC},
+ {"SC_DCACHE_ASSOC", _SC_DCACHE_ASSOC},
#endif
#ifdef _SC_DCACHE_BLKSZ
- {"SC_DCACHE_BLKSZ", _SC_DCACHE_BLKSZ},
+ {"SC_DCACHE_BLKSZ", _SC_DCACHE_BLKSZ},
#endif
#ifdef _SC_DCACHE_LINESZ
- {"SC_DCACHE_LINESZ", _SC_DCACHE_LINESZ},
+ {"SC_DCACHE_LINESZ", _SC_DCACHE_LINESZ},
#endif
#ifdef _SC_DCACHE_SZ
- {"SC_DCACHE_SZ", _SC_DCACHE_SZ},
+ {"SC_DCACHE_SZ", _SC_DCACHE_SZ},
#endif
#ifdef _SC_DCACHE_TBLKSZ
- {"SC_DCACHE_TBLKSZ", _SC_DCACHE_TBLKSZ},
+ {"SC_DCACHE_TBLKSZ", _SC_DCACHE_TBLKSZ},
#endif
#ifdef _SC_DELAYTIMER_MAX
- {"SC_DELAYTIMER_MAX", _SC_DELAYTIMER_MAX},
+ {"SC_DELAYTIMER_MAX", _SC_DELAYTIMER_MAX},
#endif
#ifdef _SC_EQUIV_CLASS_MAX
- {"SC_EQUIV_CLASS_MAX", _SC_EQUIV_CLASS_MAX},
+ {"SC_EQUIV_CLASS_MAX", _SC_EQUIV_CLASS_MAX},
#endif
#ifdef _SC_EXPR_NEST_MAX
- {"SC_EXPR_NEST_MAX", _SC_EXPR_NEST_MAX},
+ {"SC_EXPR_NEST_MAX", _SC_EXPR_NEST_MAX},
#endif
#ifdef _SC_FSYNC
- {"SC_FSYNC", _SC_FSYNC},
+ {"SC_FSYNC", _SC_FSYNC},
#endif
#ifdef _SC_GETGR_R_SIZE_MAX
- {"SC_GETGR_R_SIZE_MAX", _SC_GETGR_R_SIZE_MAX},
+ {"SC_GETGR_R_SIZE_MAX", _SC_GETGR_R_SIZE_MAX},
#endif
#ifdef _SC_GETPW_R_SIZE_MAX
- {"SC_GETPW_R_SIZE_MAX", _SC_GETPW_R_SIZE_MAX},
+ {"SC_GETPW_R_SIZE_MAX", _SC_GETPW_R_SIZE_MAX},
#endif
#ifdef _SC_ICACHE_ASSOC
- {"SC_ICACHE_ASSOC", _SC_ICACHE_ASSOC},
+ {"SC_ICACHE_ASSOC", _SC_ICACHE_ASSOC},
#endif
#ifdef _SC_ICACHE_BLKSZ
- {"SC_ICACHE_BLKSZ", _SC_ICACHE_BLKSZ},
+ {"SC_ICACHE_BLKSZ", _SC_ICACHE_BLKSZ},
#endif
#ifdef _SC_ICACHE_LINESZ
- {"SC_ICACHE_LINESZ", _SC_ICACHE_LINESZ},
+ {"SC_ICACHE_LINESZ", _SC_ICACHE_LINESZ},
#endif
#ifdef _SC_ICACHE_SZ
- {"SC_ICACHE_SZ", _SC_ICACHE_SZ},
+ {"SC_ICACHE_SZ", _SC_ICACHE_SZ},
#endif
#ifdef _SC_INF
- {"SC_INF", _SC_INF},
+ {"SC_INF", _SC_INF},
#endif
#ifdef _SC_INT_MAX
- {"SC_INT_MAX", _SC_INT_MAX},
+ {"SC_INT_MAX", _SC_INT_MAX},
#endif
#ifdef _SC_INT_MIN
- {"SC_INT_MIN", _SC_INT_MIN},
+ {"SC_INT_MIN", _SC_INT_MIN},
#endif
#ifdef _SC_IOV_MAX
- {"SC_IOV_MAX", _SC_IOV_MAX},
+ {"SC_IOV_MAX", _SC_IOV_MAX},
#endif
#ifdef _SC_IP_SECOPTS
- {"SC_IP_SECOPTS", _SC_IP_SECOPTS},
+ {"SC_IP_SECOPTS", _SC_IP_SECOPTS},
#endif
#ifdef _SC_JOB_CONTROL
- {"SC_JOB_CONTROL", _SC_JOB_CONTROL},
+ {"SC_JOB_CONTROL", _SC_JOB_CONTROL},
#endif
#ifdef _SC_KERN_POINTERS
- {"SC_KERN_POINTERS", _SC_KERN_POINTERS},
+ {"SC_KERN_POINTERS", _SC_KERN_POINTERS},
#endif
#ifdef _SC_KERN_SIM
- {"SC_KERN_SIM", _SC_KERN_SIM},
+ {"SC_KERN_SIM", _SC_KERN_SIM},
#endif
#ifdef _SC_LINE_MAX
- {"SC_LINE_MAX", _SC_LINE_MAX},
+ {"SC_LINE_MAX", _SC_LINE_MAX},
#endif
#ifdef _SC_LOGIN_NAME_MAX
- {"SC_LOGIN_NAME_MAX", _SC_LOGIN_NAME_MAX},
+ {"SC_LOGIN_NAME_MAX", _SC_LOGIN_NAME_MAX},
#endif
#ifdef _SC_LOGNAME_MAX
- {"SC_LOGNAME_MAX", _SC_LOGNAME_MAX},
+ {"SC_LOGNAME_MAX", _SC_LOGNAME_MAX},
#endif
#ifdef _SC_LONG_BIT
- {"SC_LONG_BIT", _SC_LONG_BIT},
+ {"SC_LONG_BIT", _SC_LONG_BIT},
#endif
#ifdef _SC_MAC
- {"SC_MAC", _SC_MAC},
+ {"SC_MAC", _SC_MAC},
#endif
#ifdef _SC_MAPPED_FILES
- {"SC_MAPPED_FILES", _SC_MAPPED_FILES},
+ {"SC_MAPPED_FILES", _SC_MAPPED_FILES},
#endif
#ifdef _SC_MAXPID
- {"SC_MAXPID", _SC_MAXPID},
+ {"SC_MAXPID", _SC_MAXPID},
#endif
#ifdef _SC_MB_LEN_MAX
- {"SC_MB_LEN_MAX", _SC_MB_LEN_MAX},
+ {"SC_MB_LEN_MAX", _SC_MB_LEN_MAX},
#endif
#ifdef _SC_MEMLOCK
- {"SC_MEMLOCK", _SC_MEMLOCK},
+ {"SC_MEMLOCK", _SC_MEMLOCK},
#endif
#ifdef _SC_MEMLOCK_RANGE
- {"SC_MEMLOCK_RANGE", _SC_MEMLOCK_RANGE},
+ {"SC_MEMLOCK_RANGE", _SC_MEMLOCK_RANGE},
#endif
#ifdef _SC_MEMORY_PROTECTION
- {"SC_MEMORY_PROTECTION", _SC_MEMORY_PROTECTION},
+ {"SC_MEMORY_PROTECTION", _SC_MEMORY_PROTECTION},
#endif
#ifdef _SC_MESSAGE_PASSING
- {"SC_MESSAGE_PASSING", _SC_MESSAGE_PASSING},
+ {"SC_MESSAGE_PASSING", _SC_MESSAGE_PASSING},
#endif
#ifdef _SC_MMAP_FIXED_ALIGNMENT
- {"SC_MMAP_FIXED_ALIGNMENT", _SC_MMAP_FIXED_ALIGNMENT},
+ {"SC_MMAP_FIXED_ALIGNMENT", _SC_MMAP_FIXED_ALIGNMENT},
#endif
#ifdef _SC_MQ_OPEN_MAX
- {"SC_MQ_OPEN_MAX", _SC_MQ_OPEN_MAX},
+ {"SC_MQ_OPEN_MAX", _SC_MQ_OPEN_MAX},
#endif
#ifdef _SC_MQ_PRIO_MAX
- {"SC_MQ_PRIO_MAX", _SC_MQ_PRIO_MAX},
+ {"SC_MQ_PRIO_MAX", _SC_MQ_PRIO_MAX},
#endif
#ifdef _SC_NACLS_MAX
- {"SC_NACLS_MAX", _SC_NACLS_MAX},
+ {"SC_NACLS_MAX", _SC_NACLS_MAX},
#endif
#ifdef _SC_NGROUPS_MAX
- {"SC_NGROUPS_MAX", _SC_NGROUPS_MAX},
+ {"SC_NGROUPS_MAX", _SC_NGROUPS_MAX},
#endif
#ifdef _SC_NL_ARGMAX
- {"SC_NL_ARGMAX", _SC_NL_ARGMAX},
+ {"SC_NL_ARGMAX", _SC_NL_ARGMAX},
#endif
#ifdef _SC_NL_LANGMAX
- {"SC_NL_LANGMAX", _SC_NL_LANGMAX},
+ {"SC_NL_LANGMAX", _SC_NL_LANGMAX},
#endif
#ifdef _SC_NL_MSGMAX
- {"SC_NL_MSGMAX", _SC_NL_MSGMAX},
+ {"SC_NL_MSGMAX", _SC_NL_MSGMAX},
#endif
#ifdef _SC_NL_NMAX
- {"SC_NL_NMAX", _SC_NL_NMAX},
+ {"SC_NL_NMAX", _SC_NL_NMAX},
#endif
#ifdef _SC_NL_SETMAX
- {"SC_NL_SETMAX", _SC_NL_SETMAX},
+ {"SC_NL_SETMAX", _SC_NL_SETMAX},
#endif
#ifdef _SC_NL_TEXTMAX
- {"SC_NL_TEXTMAX", _SC_NL_TEXTMAX},
+ {"SC_NL_TEXTMAX", _SC_NL_TEXTMAX},
#endif
#ifdef _SC_NPROCESSORS_CONF
- {"SC_NPROCESSORS_CONF", _SC_NPROCESSORS_CONF},
+ {"SC_NPROCESSORS_CONF", _SC_NPROCESSORS_CONF},
#endif
#ifdef _SC_NPROCESSORS_ONLN
- {"SC_NPROCESSORS_ONLN", _SC_NPROCESSORS_ONLN},
+ {"SC_NPROCESSORS_ONLN", _SC_NPROCESSORS_ONLN},
#endif
#ifdef _SC_NPROC_CONF
- {"SC_NPROC_CONF", _SC_NPROC_CONF},
+ {"SC_NPROC_CONF", _SC_NPROC_CONF},
#endif
#ifdef _SC_NPROC_ONLN
- {"SC_NPROC_ONLN", _SC_NPROC_ONLN},
+ {"SC_NPROC_ONLN", _SC_NPROC_ONLN},
#endif
#ifdef _SC_NZERO
- {"SC_NZERO", _SC_NZERO},
+ {"SC_NZERO", _SC_NZERO},
#endif
#ifdef _SC_OPEN_MAX
- {"SC_OPEN_MAX", _SC_OPEN_MAX},
+ {"SC_OPEN_MAX", _SC_OPEN_MAX},
#endif
#ifdef _SC_PAGESIZE
- {"SC_PAGESIZE", _SC_PAGESIZE},
+ {"SC_PAGESIZE", _SC_PAGESIZE},
#endif
#ifdef _SC_PAGE_SIZE
- {"SC_PAGE_SIZE", _SC_PAGE_SIZE},
+ {"SC_PAGE_SIZE", _SC_PAGE_SIZE},
#endif
#ifdef _SC_PASS_MAX
- {"SC_PASS_MAX", _SC_PASS_MAX},
+ {"SC_PASS_MAX", _SC_PASS_MAX},
#endif
#ifdef _SC_PHYS_PAGES
- {"SC_PHYS_PAGES", _SC_PHYS_PAGES},
+ {"SC_PHYS_PAGES", _SC_PHYS_PAGES},
#endif
#ifdef _SC_PII
- {"SC_PII", _SC_PII},
+ {"SC_PII", _SC_PII},
#endif
#ifdef _SC_PII_INTERNET
- {"SC_PII_INTERNET", _SC_PII_INTERNET},
+ {"SC_PII_INTERNET", _SC_PII_INTERNET},
#endif
#ifdef _SC_PII_INTERNET_DGRAM
- {"SC_PII_INTERNET_DGRAM", _SC_PII_INTERNET_DGRAM},
+ {"SC_PII_INTERNET_DGRAM", _SC_PII_INTERNET_DGRAM},
#endif
#ifdef _SC_PII_INTERNET_STREAM
- {"SC_PII_INTERNET_STREAM", _SC_PII_INTERNET_STREAM},
+ {"SC_PII_INTERNET_STREAM", _SC_PII_INTERNET_STREAM},
#endif
#ifdef _SC_PII_OSI
- {"SC_PII_OSI", _SC_PII_OSI},
+ {"SC_PII_OSI", _SC_PII_OSI},
#endif
#ifdef _SC_PII_OSI_CLTS
- {"SC_PII_OSI_CLTS", _SC_PII_OSI_CLTS},
+ {"SC_PII_OSI_CLTS", _SC_PII_OSI_CLTS},
#endif
#ifdef _SC_PII_OSI_COTS
- {"SC_PII_OSI_COTS", _SC_PII_OSI_COTS},
+ {"SC_PII_OSI_COTS", _SC_PII_OSI_COTS},
#endif
#ifdef _SC_PII_OSI_M
- {"SC_PII_OSI_M", _SC_PII_OSI_M},
+ {"SC_PII_OSI_M", _SC_PII_OSI_M},
#endif
#ifdef _SC_PII_SOCKET
- {"SC_PII_SOCKET", _SC_PII_SOCKET},
+ {"SC_PII_SOCKET", _SC_PII_SOCKET},
#endif
#ifdef _SC_PII_XTI
- {"SC_PII_XTI", _SC_PII_XTI},
+ {"SC_PII_XTI", _SC_PII_XTI},
#endif
#ifdef _SC_POLL
- {"SC_POLL", _SC_POLL},
+ {"SC_POLL", _SC_POLL},
#endif
#ifdef _SC_PRIORITIZED_IO
- {"SC_PRIORITIZED_IO", _SC_PRIORITIZED_IO},
+ {"SC_PRIORITIZED_IO", _SC_PRIORITIZED_IO},
#endif
#ifdef _SC_PRIORITY_SCHEDULING
- {"SC_PRIORITY_SCHEDULING", _SC_PRIORITY_SCHEDULING},
+ {"SC_PRIORITY_SCHEDULING", _SC_PRIORITY_SCHEDULING},
#endif
#ifdef _SC_REALTIME_SIGNALS
- {"SC_REALTIME_SIGNALS", _SC_REALTIME_SIGNALS},
+ {"SC_REALTIME_SIGNALS", _SC_REALTIME_SIGNALS},
#endif
#ifdef _SC_RE_DUP_MAX
- {"SC_RE_DUP_MAX", _SC_RE_DUP_MAX},
+ {"SC_RE_DUP_MAX", _SC_RE_DUP_MAX},
#endif
#ifdef _SC_RTSIG_MAX
- {"SC_RTSIG_MAX", _SC_RTSIG_MAX},
+ {"SC_RTSIG_MAX", _SC_RTSIG_MAX},
#endif
#ifdef _SC_SAVED_IDS
- {"SC_SAVED_IDS", _SC_SAVED_IDS},
+ {"SC_SAVED_IDS", _SC_SAVED_IDS},
#endif
#ifdef _SC_SCHAR_MAX
- {"SC_SCHAR_MAX", _SC_SCHAR_MAX},
+ {"SC_SCHAR_MAX", _SC_SCHAR_MAX},
#endif
#ifdef _SC_SCHAR_MIN
- {"SC_SCHAR_MIN", _SC_SCHAR_MIN},
+ {"SC_SCHAR_MIN", _SC_SCHAR_MIN},
#endif
#ifdef _SC_SELECT
- {"SC_SELECT", _SC_SELECT},
+ {"SC_SELECT", _SC_SELECT},
#endif
#ifdef _SC_SEMAPHORES
- {"SC_SEMAPHORES", _SC_SEMAPHORES},
+ {"SC_SEMAPHORES", _SC_SEMAPHORES},
#endif
#ifdef _SC_SEM_NSEMS_MAX
- {"SC_SEM_NSEMS_MAX", _SC_SEM_NSEMS_MAX},
+ {"SC_SEM_NSEMS_MAX", _SC_SEM_NSEMS_MAX},
#endif
#ifdef _SC_SEM_VALUE_MAX
- {"SC_SEM_VALUE_MAX", _SC_SEM_VALUE_MAX},
+ {"SC_SEM_VALUE_MAX", _SC_SEM_VALUE_MAX},
#endif
#ifdef _SC_SHARED_MEMORY_OBJECTS
- {"SC_SHARED_MEMORY_OBJECTS", _SC_SHARED_MEMORY_OBJECTS},
+ {"SC_SHARED_MEMORY_OBJECTS", _SC_SHARED_MEMORY_OBJECTS},
#endif
#ifdef _SC_SHRT_MAX
- {"SC_SHRT_MAX", _SC_SHRT_MAX},
+ {"SC_SHRT_MAX", _SC_SHRT_MAX},
#endif
#ifdef _SC_SHRT_MIN
- {"SC_SHRT_MIN", _SC_SHRT_MIN},
+ {"SC_SHRT_MIN", _SC_SHRT_MIN},
#endif
#ifdef _SC_SIGQUEUE_MAX
- {"SC_SIGQUEUE_MAX", _SC_SIGQUEUE_MAX},
+ {"SC_SIGQUEUE_MAX", _SC_SIGQUEUE_MAX},
#endif
#ifdef _SC_SIGRT_MAX
- {"SC_SIGRT_MAX", _SC_SIGRT_MAX},
+ {"SC_SIGRT_MAX", _SC_SIGRT_MAX},
#endif
#ifdef _SC_SIGRT_MIN
- {"SC_SIGRT_MIN", _SC_SIGRT_MIN},
+ {"SC_SIGRT_MIN", _SC_SIGRT_MIN},
#endif
#ifdef _SC_SOFTPOWER
- {"SC_SOFTPOWER", _SC_SOFTPOWER},
+ {"SC_SOFTPOWER", _SC_SOFTPOWER},
#endif
#ifdef _SC_SPLIT_CACHE
- {"SC_SPLIT_CACHE", _SC_SPLIT_CACHE},
+ {"SC_SPLIT_CACHE", _SC_SPLIT_CACHE},
#endif
#ifdef _SC_SSIZE_MAX
- {"SC_SSIZE_MAX", _SC_SSIZE_MAX},
+ {"SC_SSIZE_MAX", _SC_SSIZE_MAX},
#endif
#ifdef _SC_STACK_PROT
- {"SC_STACK_PROT", _SC_STACK_PROT},
+ {"SC_STACK_PROT", _SC_STACK_PROT},
#endif
#ifdef _SC_STREAM_MAX
- {"SC_STREAM_MAX", _SC_STREAM_MAX},
+ {"SC_STREAM_MAX", _SC_STREAM_MAX},
#endif
#ifdef _SC_SYNCHRONIZED_IO
- {"SC_SYNCHRONIZED_IO", _SC_SYNCHRONIZED_IO},
+ {"SC_SYNCHRONIZED_IO", _SC_SYNCHRONIZED_IO},
#endif
#ifdef _SC_THREADS
- {"SC_THREADS", _SC_THREADS},
+ {"SC_THREADS", _SC_THREADS},
#endif
#ifdef _SC_THREAD_ATTR_STACKADDR
- {"SC_THREAD_ATTR_STACKADDR", _SC_THREAD_ATTR_STACKADDR},
+ {"SC_THREAD_ATTR_STACKADDR", _SC_THREAD_ATTR_STACKADDR},
#endif
#ifdef _SC_THREAD_ATTR_STACKSIZE
- {"SC_THREAD_ATTR_STACKSIZE", _SC_THREAD_ATTR_STACKSIZE},
+ {"SC_THREAD_ATTR_STACKSIZE", _SC_THREAD_ATTR_STACKSIZE},
#endif
#ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS
- {"SC_THREAD_DESTRUCTOR_ITERATIONS", _SC_THREAD_DESTRUCTOR_ITERATIONS},
+ {"SC_THREAD_DESTRUCTOR_ITERATIONS", _SC_THREAD_DESTRUCTOR_ITERATIONS},
#endif
#ifdef _SC_THREAD_KEYS_MAX
- {"SC_THREAD_KEYS_MAX", _SC_THREAD_KEYS_MAX},
+ {"SC_THREAD_KEYS_MAX", _SC_THREAD_KEYS_MAX},
#endif
#ifdef _SC_THREAD_PRIORITY_SCHEDULING
- {"SC_THREAD_PRIORITY_SCHEDULING", _SC_THREAD_PRIORITY_SCHEDULING},
+ {"SC_THREAD_PRIORITY_SCHEDULING", _SC_THREAD_PRIORITY_SCHEDULING},
#endif
#ifdef _SC_THREAD_PRIO_INHERIT
- {"SC_THREAD_PRIO_INHERIT", _SC_THREAD_PRIO_INHERIT},
+ {"SC_THREAD_PRIO_INHERIT", _SC_THREAD_PRIO_INHERIT},
#endif
#ifdef _SC_THREAD_PRIO_PROTECT
- {"SC_THREAD_PRIO_PROTECT", _SC_THREAD_PRIO_PROTECT},
+ {"SC_THREAD_PRIO_PROTECT", _SC_THREAD_PRIO_PROTECT},
#endif
#ifdef _SC_THREAD_PROCESS_SHARED
- {"SC_THREAD_PROCESS_SHARED", _SC_THREAD_PROCESS_SHARED},
+ {"SC_THREAD_PROCESS_SHARED", _SC_THREAD_PROCESS_SHARED},
#endif
#ifdef _SC_THREAD_SAFE_FUNCTIONS
- {"SC_THREAD_SAFE_FUNCTIONS", _SC_THREAD_SAFE_FUNCTIONS},
+ {"SC_THREAD_SAFE_FUNCTIONS", _SC_THREAD_SAFE_FUNCTIONS},
#endif
#ifdef _SC_THREAD_STACK_MIN
- {"SC_THREAD_STACK_MIN", _SC_THREAD_STACK_MIN},
+ {"SC_THREAD_STACK_MIN", _SC_THREAD_STACK_MIN},
#endif
#ifdef _SC_THREAD_THREADS_MAX
- {"SC_THREAD_THREADS_MAX", _SC_THREAD_THREADS_MAX},
+ {"SC_THREAD_THREADS_MAX", _SC_THREAD_THREADS_MAX},
#endif
#ifdef _SC_TIMERS
- {"SC_TIMERS", _SC_TIMERS},
+ {"SC_TIMERS", _SC_TIMERS},
#endif
#ifdef _SC_TIMER_MAX
- {"SC_TIMER_MAX", _SC_TIMER_MAX},
+ {"SC_TIMER_MAX", _SC_TIMER_MAX},
#endif
#ifdef _SC_TTY_NAME_MAX
- {"SC_TTY_NAME_MAX", _SC_TTY_NAME_MAX},
+ {"SC_TTY_NAME_MAX", _SC_TTY_NAME_MAX},
#endif
#ifdef _SC_TZNAME_MAX
- {"SC_TZNAME_MAX", _SC_TZNAME_MAX},
+ {"SC_TZNAME_MAX", _SC_TZNAME_MAX},
#endif
#ifdef _SC_T_IOV_MAX
- {"SC_T_IOV_MAX", _SC_T_IOV_MAX},
+ {"SC_T_IOV_MAX", _SC_T_IOV_MAX},
#endif
#ifdef _SC_UCHAR_MAX
- {"SC_UCHAR_MAX", _SC_UCHAR_MAX},
+ {"SC_UCHAR_MAX", _SC_UCHAR_MAX},
#endif
#ifdef _SC_UINT_MAX
- {"SC_UINT_MAX", _SC_UINT_MAX},
+ {"SC_UINT_MAX", _SC_UINT_MAX},
#endif
#ifdef _SC_UIO_MAXIOV
- {"SC_UIO_MAXIOV", _SC_UIO_MAXIOV},
+ {"SC_UIO_MAXIOV", _SC_UIO_MAXIOV},
#endif
#ifdef _SC_ULONG_MAX
- {"SC_ULONG_MAX", _SC_ULONG_MAX},
+ {"SC_ULONG_MAX", _SC_ULONG_MAX},
#endif
#ifdef _SC_USHRT_MAX
- {"SC_USHRT_MAX", _SC_USHRT_MAX},
+ {"SC_USHRT_MAX", _SC_USHRT_MAX},
#endif
#ifdef _SC_VERSION
- {"SC_VERSION", _SC_VERSION},
+ {"SC_VERSION", _SC_VERSION},
#endif
#ifdef _SC_WORD_BIT
- {"SC_WORD_BIT", _SC_WORD_BIT},
+ {"SC_WORD_BIT", _SC_WORD_BIT},
#endif
#ifdef _SC_XBS5_ILP32_OFF32
- {"SC_XBS5_ILP32_OFF32", _SC_XBS5_ILP32_OFF32},
+ {"SC_XBS5_ILP32_OFF32", _SC_XBS5_ILP32_OFF32},
#endif
#ifdef _SC_XBS5_ILP32_OFFBIG
- {"SC_XBS5_ILP32_OFFBIG", _SC_XBS5_ILP32_OFFBIG},
+ {"SC_XBS5_ILP32_OFFBIG", _SC_XBS5_ILP32_OFFBIG},
#endif
#ifdef _SC_XBS5_LP64_OFF64
- {"SC_XBS5_LP64_OFF64", _SC_XBS5_LP64_OFF64},
+ {"SC_XBS5_LP64_OFF64", _SC_XBS5_LP64_OFF64},
#endif
#ifdef _SC_XBS5_LPBIG_OFFBIG
- {"SC_XBS5_LPBIG_OFFBIG", _SC_XBS5_LPBIG_OFFBIG},
+ {"SC_XBS5_LPBIG_OFFBIG", _SC_XBS5_LPBIG_OFFBIG},
#endif
#ifdef _SC_XOPEN_CRYPT
- {"SC_XOPEN_CRYPT", _SC_XOPEN_CRYPT},
+ {"SC_XOPEN_CRYPT", _SC_XOPEN_CRYPT},
#endif
#ifdef _SC_XOPEN_ENH_I18N
- {"SC_XOPEN_ENH_I18N", _SC_XOPEN_ENH_I18N},
+ {"SC_XOPEN_ENH_I18N", _SC_XOPEN_ENH_I18N},
#endif
#ifdef _SC_XOPEN_LEGACY
- {"SC_XOPEN_LEGACY", _SC_XOPEN_LEGACY},
+ {"SC_XOPEN_LEGACY", _SC_XOPEN_LEGACY},
#endif
#ifdef _SC_XOPEN_REALTIME
- {"SC_XOPEN_REALTIME", _SC_XOPEN_REALTIME},
+ {"SC_XOPEN_REALTIME", _SC_XOPEN_REALTIME},
#endif
#ifdef _SC_XOPEN_REALTIME_THREADS
- {"SC_XOPEN_REALTIME_THREADS", _SC_XOPEN_REALTIME_THREADS},
+ {"SC_XOPEN_REALTIME_THREADS", _SC_XOPEN_REALTIME_THREADS},
#endif
#ifdef _SC_XOPEN_SHM
- {"SC_XOPEN_SHM", _SC_XOPEN_SHM},
+ {"SC_XOPEN_SHM", _SC_XOPEN_SHM},
#endif
#ifdef _SC_XOPEN_UNIX
- {"SC_XOPEN_UNIX", _SC_XOPEN_UNIX},
+ {"SC_XOPEN_UNIX", _SC_XOPEN_UNIX},
#endif
#ifdef _SC_XOPEN_VERSION
- {"SC_XOPEN_VERSION", _SC_XOPEN_VERSION},
+ {"SC_XOPEN_VERSION", _SC_XOPEN_VERSION},
#endif
#ifdef _SC_XOPEN_XCU_VERSION
- {"SC_XOPEN_XCU_VERSION", _SC_XOPEN_XCU_VERSION},
+ {"SC_XOPEN_XCU_VERSION", _SC_XOPEN_XCU_VERSION},
#endif
#ifdef _SC_XOPEN_XPG2
- {"SC_XOPEN_XPG2", _SC_XOPEN_XPG2},
+ {"SC_XOPEN_XPG2", _SC_XOPEN_XPG2},
#endif
#ifdef _SC_XOPEN_XPG3
- {"SC_XOPEN_XPG3", _SC_XOPEN_XPG3},
+ {"SC_XOPEN_XPG3", _SC_XOPEN_XPG3},
#endif
#ifdef _SC_XOPEN_XPG4
- {"SC_XOPEN_XPG4", _SC_XOPEN_XPG4},
+ {"SC_XOPEN_XPG4", _SC_XOPEN_XPG4},
#endif
};
cmp_constdefs(const void *v1, const void *v2)
{
const struct constdef *c1 =
- (const struct constdef *) v1;
+ (const struct constdef *) v1;
const struct constdef *c2 =
- (const struct constdef *) v2;
+ (const struct constdef *) v2;
return strcmp(c1->name, c2->name);
}
static int
setup_confname_table(struct constdef *table, size_t tablesize,
- char *tablename, PyObject *module)
+ char *tablename, PyObject *module)
{
PyObject *d = NULL;
size_t i;
qsort(table, tablesize, sizeof(struct constdef), cmp_constdefs);
d = PyDict_New();
if (d == NULL)
- return -1;
+ return -1;
for (i=0; i < tablesize; ++i) {
- PyObject *o = PyLong_FromLong(table[i].value);
- if (o == NULL || PyDict_SetItemString(d, table[i].name, o) == -1) {
- Py_XDECREF(o);
- Py_DECREF(d);
- return -1;
- }
- Py_DECREF(o);
+ PyObject *o = PyLong_FromLong(table[i].value);
+ if (o == NULL || PyDict_SetItemString(d, table[i].name, o) == -1) {
+ Py_XDECREF(o);
+ Py_DECREF(d);
+ return -1;
+ }
+ Py_DECREF(o);
}
return PyModule_AddObject(module, tablename, d);
}
sizeof(posix_constants_pathconf)
/ sizeof(struct constdef),
"pathconf_names", module))
- return -1;
+ return -1;
#endif
#ifdef HAVE_CONFSTR
if (setup_confname_table(posix_constants_confstr,
sizeof(posix_constants_confstr)
/ sizeof(struct constdef),
"confstr_names", module))
- return -1;
+ return -1;
#endif
#ifdef HAVE_SYSCONF
if (setup_confname_table(posix_constants_sysconf,
sizeof(posix_constants_sysconf)
/ sizeof(struct constdef),
"sysconf_names", module))
- return -1;
+ return -1;
#endif
return 0;
}
static PyObject *
win32_startfile(PyObject *self, PyObject *args)
{
- PyObject *ofilepath;
- char *filepath;
- char *operation = NULL;
- HINSTANCE rc;
-
- PyObject *unipath, *woperation = NULL;
- if (!PyArg_ParseTuple(args, "U|s:startfile",
- &unipath, &operation)) {
- PyErr_Clear();
- goto normal;
- }
-
- if (operation) {
- woperation = PyUnicode_DecodeASCII(operation,
- strlen(operation), NULL);
- if (!woperation) {
- PyErr_Clear();
- operation = NULL;
- goto normal;
- }
- }
-
- Py_BEGIN_ALLOW_THREADS
- rc = ShellExecuteW((HWND)0, woperation ? PyUnicode_AS_UNICODE(woperation) : 0,
- PyUnicode_AS_UNICODE(unipath),
- NULL, NULL, SW_SHOWNORMAL);
- Py_END_ALLOW_THREADS
-
- Py_XDECREF(woperation);
- if (rc <= (HINSTANCE)32) {
- PyObject *errval = win32_error_unicode("startfile",
- PyUnicode_AS_UNICODE(unipath));
- return errval;
- }
- Py_INCREF(Py_None);
- return Py_None;
+ PyObject *ofilepath;
+ char *filepath;
+ char *operation = NULL;
+ HINSTANCE rc;
+
+ PyObject *unipath, *woperation = NULL;
+ if (!PyArg_ParseTuple(args, "U|s:startfile",
+ &unipath, &operation)) {
+ PyErr_Clear();
+ goto normal;
+ }
+
+ if (operation) {
+ woperation = PyUnicode_DecodeASCII(operation,
+ strlen(operation), NULL);
+ if (!woperation) {
+ PyErr_Clear();
+ operation = NULL;
+ goto normal;
+ }
+ }
+
+ Py_BEGIN_ALLOW_THREADS
+ rc = ShellExecuteW((HWND)0, woperation ? PyUnicode_AS_UNICODE(woperation) : 0,
+ PyUnicode_AS_UNICODE(unipath),
+ NULL, NULL, SW_SHOWNORMAL);
+ Py_END_ALLOW_THREADS
+
+ Py_XDECREF(woperation);
+ if (rc <= (HINSTANCE)32) {
+ PyObject *errval = win32_error_unicode("startfile",
+ PyUnicode_AS_UNICODE(unipath));
+ return errval;
+ }
+ Py_INCREF(Py_None);
+ return Py_None;
normal:
- if (!PyArg_ParseTuple(args, "O&|s:startfile",
- PyUnicode_FSConverter, &ofilepath,
- &operation))
- return NULL;
- filepath = PyBytes_AsString(ofilepath);
- Py_BEGIN_ALLOW_THREADS
- rc = ShellExecute((HWND)0, operation, filepath,
- NULL, NULL, SW_SHOWNORMAL);
- Py_END_ALLOW_THREADS
- if (rc <= (HINSTANCE)32) {
- PyObject *errval = win32_error("startfile", filepath);
- Py_DECREF(ofilepath);
- return errval;
- }
- Py_DECREF(ofilepath);
- Py_INCREF(Py_None);
- return Py_None;
+ if (!PyArg_ParseTuple(args, "O&|s:startfile",
+ PyUnicode_FSConverter, &ofilepath,
+ &operation))
+ return NULL;
+ filepath = PyBytes_AsString(ofilepath);
+ Py_BEGIN_ALLOW_THREADS
+ rc = ShellExecute((HWND)0, operation, filepath,
+ NULL, NULL, SW_SHOWNORMAL);
+ Py_END_ALLOW_THREADS
+ if (rc <= (HINSTANCE)32) {
+ PyObject *errval = win32_error("startfile", filepath);
+ Py_DECREF(ofilepath);
+ return errval;
+ }
+ Py_DECREF(ofilepath);
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif
{
double loadavg[3];
if (getloadavg(loadavg, 3)!=3) {
- PyErr_SetString(PyExc_OSError, "Load averages are unobtainable");
- return NULL;
+ PyErr_SetString(PyExc_OSError, "Load averages are unobtainable");
+ return NULL;
} else
- return Py_BuildValue("ddd", loadavg[0], loadavg[1], loadavg[2]);
+ return Py_BuildValue("ddd", loadavg[0], loadavg[1], loadavg[2]);
}
#endif
static PyObject*
win32_urandom(PyObject *self, PyObject *args)
{
- int howMany;
- PyObject* result;
-
- /* Read arguments */
- if (! PyArg_ParseTuple(args, "i:urandom", &howMany))
- return NULL;
- if (howMany < 0)
- return PyErr_Format(PyExc_ValueError,
- "negative argument not allowed");
-
- if (hCryptProv == 0) {
- HINSTANCE hAdvAPI32 = NULL;
- CRYPTACQUIRECONTEXTA pCryptAcquireContext = NULL;
-
- /* Obtain handle to the DLL containing CryptoAPI
- This should not fail */
- hAdvAPI32 = GetModuleHandle("advapi32.dll");
- if(hAdvAPI32 == NULL)
- return win32_error("GetModuleHandle", NULL);
-
- /* Obtain pointers to the CryptoAPI functions
- This will fail on some early versions of Win95 */
- pCryptAcquireContext = (CRYPTACQUIRECONTEXTA)GetProcAddress(
- hAdvAPI32,
- "CryptAcquireContextA");
- if (pCryptAcquireContext == NULL)
- return PyErr_Format(PyExc_NotImplementedError,
- "CryptAcquireContextA not found");
-
- pCryptGenRandom = (CRYPTGENRANDOM)GetProcAddress(
- hAdvAPI32, "CryptGenRandom");
- if (pCryptGenRandom == NULL)
- return PyErr_Format(PyExc_NotImplementedError,
- "CryptGenRandom not found");
-
- /* Acquire context */
- if (! pCryptAcquireContext(&hCryptProv, NULL, NULL,
- PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
- return win32_error("CryptAcquireContext", NULL);
- }
-
- /* Allocate bytes */
- result = PyBytes_FromStringAndSize(NULL, howMany);
- if (result != NULL) {
- /* Get random data */
- memset(PyBytes_AS_STRING(result), 0, howMany); /* zero seed */
- if (! pCryptGenRandom(hCryptProv, howMany, (unsigned char*)
- PyBytes_AS_STRING(result))) {
- Py_DECREF(result);
- return win32_error("CryptGenRandom", NULL);
- }
- }
- return result;
+ int howMany;
+ PyObject* result;
+
+ /* Read arguments */
+ if (! PyArg_ParseTuple(args, "i:urandom", &howMany))
+ return NULL;
+ if (howMany < 0)
+ return PyErr_Format(PyExc_ValueError,
+ "negative argument not allowed");
+
+ if (hCryptProv == 0) {
+ HINSTANCE hAdvAPI32 = NULL;
+ CRYPTACQUIRECONTEXTA pCryptAcquireContext = NULL;
+
+ /* Obtain handle to the DLL containing CryptoAPI
+ This should not fail */
+ hAdvAPI32 = GetModuleHandle("advapi32.dll");
+ if(hAdvAPI32 == NULL)
+ return win32_error("GetModuleHandle", NULL);
+
+ /* Obtain pointers to the CryptoAPI functions
+ This will fail on some early versions of Win95 */
+ pCryptAcquireContext = (CRYPTACQUIRECONTEXTA)GetProcAddress(
+ hAdvAPI32,
+ "CryptAcquireContextA");
+ if (pCryptAcquireContext == NULL)
+ return PyErr_Format(PyExc_NotImplementedError,
+ "CryptAcquireContextA not found");
+
+ pCryptGenRandom = (CRYPTGENRANDOM)GetProcAddress(
+ hAdvAPI32, "CryptGenRandom");
+ if (pCryptGenRandom == NULL)
+ return PyErr_Format(PyExc_NotImplementedError,
+ "CryptGenRandom not found");
+
+ /* Acquire context */
+ if (! pCryptAcquireContext(&hCryptProv, NULL, NULL,
+ PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
+ return win32_error("CryptAcquireContext", NULL);
+ }
+
+ /* Allocate bytes */
+ result = PyBytes_FromStringAndSize(NULL, howMany);
+ if (result != NULL) {
+ /* Get random data */
+ memset(PyBytes_AS_STRING(result), 0, howMany); /* zero seed */
+ if (! pCryptGenRandom(hCryptProv, howMany, (unsigned char*)
+ PyBytes_AS_STRING(result))) {
+ Py_DECREF(result);
+ return win32_error("CryptGenRandom", NULL);
+ }
+ }
+ return result;
}
#endif
static PyObject *
device_encoding(PyObject *self, PyObject *args)
{
- int fd;
- if (!PyArg_ParseTuple(args, "i:device_encoding", &fd))
- return NULL;
- if (!_PyVerify_fd(fd) || !isatty(fd)) {
- Py_INCREF(Py_None);
- return Py_None;
- }
+ int fd;
+ if (!PyArg_ParseTuple(args, "i:device_encoding", &fd))
+ return NULL;
+ if (!_PyVerify_fd(fd) || !isatty(fd)) {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
#if defined(MS_WINDOWS) || defined(MS_WIN64)
- if (fd == 0) {
- char buf[100];
- sprintf(buf, "cp%d", GetConsoleCP());
- return PyUnicode_FromString(buf);
- }
- if (fd == 1 || fd == 2) {
- char buf[100];
- sprintf(buf, "cp%d", GetConsoleOutputCP());
- return PyUnicode_FromString(buf);
- }
+ if (fd == 0) {
+ char buf[100];
+ sprintf(buf, "cp%d", GetConsoleCP());
+ return PyUnicode_FromString(buf);
+ }
+ if (fd == 1 || fd == 2) {
+ char buf[100];
+ sprintf(buf, "cp%d", GetConsoleOutputCP());
+ return PyUnicode_FromString(buf);
+ }
#elif defined(CODESET)
- {
- char *codeset = nl_langinfo(CODESET);
- if (codeset != NULL && codeset[0] != 0)
- return PyUnicode_FromString(codeset);
- }
+ {
+ char *codeset = nl_langinfo(CODESET);
+ if (codeset != NULL && codeset[0] != 0)
+ return PyUnicode_FromString(codeset);
+ }
#endif
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
#ifdef __VMS
static PyObject*
vms_urandom(PyObject *self, PyObject *args)
{
- int howMany;
- PyObject* result;
+ int howMany;
+ PyObject* result;
- /* Read arguments */
- if (! PyArg_ParseTuple(args, "i:urandom", &howMany))
- return NULL;
- if (howMany < 0)
- return PyErr_Format(PyExc_ValueError,
- "negative argument not allowed");
-
- /* Allocate bytes */
- result = PyBytes_FromStringAndSize(NULL, howMany);
- if (result != NULL) {
- /* Get random data */
- if (RAND_pseudo_bytes((unsigned char*)
- PyBytes_AS_STRING(result),
- howMany) < 0) {
- Py_DECREF(result);
- return PyErr_Format(PyExc_ValueError,
- "RAND_pseudo_bytes");
- }
- }
- return result;
+ /* Read arguments */
+ if (! PyArg_ParseTuple(args, "i:urandom", &howMany))
+ return NULL;
+ if (howMany < 0)
+ return PyErr_Format(PyExc_ValueError,
+ "negative argument not allowed");
+
+ /* Allocate bytes */
+ result = PyBytes_FromStringAndSize(NULL, howMany);
+ if (result != NULL) {
+ /* Get random data */
+ if (RAND_pseudo_bytes((unsigned char*)
+ PyBytes_AS_STRING(result),
+ howMany) < 0) {
+ Py_DECREF(result);
+ return PyErr_Format(PyExc_ValueError,
+ "RAND_pseudo_bytes");
+ }
+ }
+ return result;
}
#endif
static PyObject*
posix_setresuid (PyObject *self, PyObject *args)
{
- /* We assume uid_t is no larger than a long. */
- long ruid, euid, suid;
- if (!PyArg_ParseTuple(args, "lll", &ruid, &euid, &suid))
- return NULL;
- if (setresuid(ruid, euid, suid) < 0)
- return posix_error();
- Py_RETURN_NONE;
+ /* We assume uid_t is no larger than a long. */
+ long ruid, euid, suid;
+ if (!PyArg_ParseTuple(args, "lll", &ruid, &euid, &suid))
+ return NULL;
+ if (setresuid(ruid, euid, suid) < 0)
+ return posix_error();
+ Py_RETURN_NONE;
}
#endif
static PyObject*
posix_setresgid (PyObject *self, PyObject *args)
{
- /* We assume uid_t is no larger than a long. */
- long rgid, egid, sgid;
- if (!PyArg_ParseTuple(args, "lll", &rgid, &egid, &sgid))
- return NULL;
- if (setresgid(rgid, egid, sgid) < 0)
- return posix_error();
- Py_RETURN_NONE;
+ /* We assume uid_t is no larger than a long. */
+ long rgid, egid, sgid;
+ if (!PyArg_ParseTuple(args, "lll", &rgid, &egid, &sgid))
+ return NULL;
+ if (setresgid(rgid, egid, sgid) < 0)
+ return posix_error();
+ Py_RETURN_NONE;
}
#endif
static PyObject*
posix_getresuid (PyObject *self, PyObject *noargs)
{
- uid_t ruid, euid, suid;
- long l_ruid, l_euid, l_suid;
- if (getresuid(&ruid, &euid, &suid) < 0)
- return posix_error();
- /* Force the values into long's as we don't know the size of uid_t. */
- l_ruid = ruid;
- l_euid = euid;
- l_suid = suid;
- return Py_BuildValue("(lll)", l_ruid, l_euid, l_suid);
+ uid_t ruid, euid, suid;
+ long l_ruid, l_euid, l_suid;
+ if (getresuid(&ruid, &euid, &suid) < 0)
+ return posix_error();
+ /* Force the values into long's as we don't know the size of uid_t. */
+ l_ruid = ruid;
+ l_euid = euid;
+ l_suid = suid;
+ return Py_BuildValue("(lll)", l_ruid, l_euid, l_suid);
}
#endif
static PyObject*
posix_getresgid (PyObject *self, PyObject *noargs)
{
- uid_t rgid, egid, sgid;
- long l_rgid, l_egid, l_sgid;
- if (getresgid(&rgid, &egid, &sgid) < 0)
- return posix_error();
- /* Force the values into long's as we don't know the size of uid_t. */
- l_rgid = rgid;
- l_egid = egid;
- l_sgid = sgid;
- return Py_BuildValue("(lll)", l_rgid, l_egid, l_sgid);
+ uid_t rgid, egid, sgid;
+ long l_rgid, l_egid, l_sgid;
+ if (getresgid(&rgid, &egid, &sgid) < 0)
+ return posix_error();
+ /* Force the values into long's as we don't know the size of uid_t. */
+ l_rgid = rgid;
+ l_egid = egid;
+ l_sgid = sgid;
+ return Py_BuildValue("(lll)", l_rgid, l_egid, l_sgid);
}
#endif
static PyMethodDef posix_methods[] = {
- {"access", posix_access, METH_VARARGS, posix_access__doc__},
+ {"access", posix_access, METH_VARARGS, posix_access__doc__},
#ifdef HAVE_TTYNAME
- {"ttyname", posix_ttyname, METH_VARARGS, posix_ttyname__doc__},
+ {"ttyname", posix_ttyname, METH_VARARGS, posix_ttyname__doc__},
#endif
- {"chdir", posix_chdir, METH_VARARGS, posix_chdir__doc__},
+ {"chdir", posix_chdir, METH_VARARGS, posix_chdir__doc__},
#ifdef HAVE_CHFLAGS
- {"chflags", posix_chflags, METH_VARARGS, posix_chflags__doc__},
+ {"chflags", posix_chflags, METH_VARARGS, posix_chflags__doc__},
#endif /* HAVE_CHFLAGS */
- {"chmod", posix_chmod, METH_VARARGS, posix_chmod__doc__},
+ {"chmod", posix_chmod, METH_VARARGS, posix_chmod__doc__},
#ifdef HAVE_FCHMOD
- {"fchmod", posix_fchmod, METH_VARARGS, posix_fchmod__doc__},
+ {"fchmod", posix_fchmod, METH_VARARGS, posix_fchmod__doc__},
#endif /* HAVE_FCHMOD */
#ifdef HAVE_CHOWN
- {"chown", posix_chown, METH_VARARGS, posix_chown__doc__},
+ {"chown", posix_chown, METH_VARARGS, posix_chown__doc__},
#endif /* HAVE_CHOWN */
#ifdef HAVE_LCHMOD
- {"lchmod", posix_lchmod, METH_VARARGS, posix_lchmod__doc__},
+ {"lchmod", posix_lchmod, METH_VARARGS, posix_lchmod__doc__},
#endif /* HAVE_LCHMOD */
#ifdef HAVE_FCHOWN
- {"fchown", posix_fchown, METH_VARARGS, posix_fchown__doc__},
+ {"fchown", posix_fchown, METH_VARARGS, posix_fchown__doc__},
#endif /* HAVE_FCHOWN */
#ifdef HAVE_LCHFLAGS
- {"lchflags", posix_lchflags, METH_VARARGS, posix_lchflags__doc__},
+ {"lchflags", posix_lchflags, METH_VARARGS, posix_lchflags__doc__},
#endif /* HAVE_LCHFLAGS */
#ifdef HAVE_LCHOWN
- {"lchown", posix_lchown, METH_VARARGS, posix_lchown__doc__},
+ {"lchown", posix_lchown, METH_VARARGS, posix_lchown__doc__},
#endif /* HAVE_LCHOWN */
#ifdef HAVE_CHROOT
- {"chroot", posix_chroot, METH_VARARGS, posix_chroot__doc__},
+ {"chroot", posix_chroot, METH_VARARGS, posix_chroot__doc__},
#endif
#ifdef HAVE_CTERMID
- {"ctermid", posix_ctermid, METH_NOARGS, posix_ctermid__doc__},
+ {"ctermid", posix_ctermid, METH_NOARGS, posix_ctermid__doc__},
#endif
#ifdef HAVE_GETCWD
- {"getcwd", (PyCFunction)posix_getcwd_unicode,
- METH_NOARGS, posix_getcwd__doc__},
- {"getcwdb", (PyCFunction)posix_getcwd_bytes,
- METH_NOARGS, posix_getcwdb__doc__},
+ {"getcwd", (PyCFunction)posix_getcwd_unicode,
+ METH_NOARGS, posix_getcwd__doc__},
+ {"getcwdb", (PyCFunction)posix_getcwd_bytes,
+ METH_NOARGS, posix_getcwdb__doc__},
#endif
#ifdef HAVE_LINK
- {"link", posix_link, METH_VARARGS, posix_link__doc__},
+ {"link", posix_link, METH_VARARGS, posix_link__doc__},
#endif /* HAVE_LINK */
- {"listdir", posix_listdir, METH_VARARGS, posix_listdir__doc__},
- {"lstat", posix_lstat, METH_VARARGS, posix_lstat__doc__},
- {"mkdir", posix_mkdir, METH_VARARGS, posix_mkdir__doc__},
+ {"listdir", posix_listdir, METH_VARARGS, posix_listdir__doc__},
+ {"lstat", posix_lstat, METH_VARARGS, posix_lstat__doc__},
+ {"mkdir", posix_mkdir, METH_VARARGS, posix_mkdir__doc__},
#ifdef HAVE_NICE
- {"nice", posix_nice, METH_VARARGS, posix_nice__doc__},
+ {"nice", posix_nice, METH_VARARGS, posix_nice__doc__},
#endif /* HAVE_NICE */
#ifdef HAVE_READLINK
- {"readlink", posix_readlink, METH_VARARGS, posix_readlink__doc__},
+ {"readlink", posix_readlink, METH_VARARGS, posix_readlink__doc__},
#endif /* HAVE_READLINK */
- {"rename", posix_rename, METH_VARARGS, posix_rename__doc__},
- {"rmdir", posix_rmdir, METH_VARARGS, posix_rmdir__doc__},
- {"stat", posix_stat, METH_VARARGS, posix_stat__doc__},
- {"stat_float_times", stat_float_times, METH_VARARGS, stat_float_times__doc__},
+ {"rename", posix_rename, METH_VARARGS, posix_rename__doc__},
+ {"rmdir", posix_rmdir, METH_VARARGS, posix_rmdir__doc__},
+ {"stat", posix_stat, METH_VARARGS, posix_stat__doc__},
+ {"stat_float_times", stat_float_times, METH_VARARGS, stat_float_times__doc__},
#ifdef HAVE_SYMLINK
- {"symlink", posix_symlink, METH_VARARGS, posix_symlink__doc__},
+ {"symlink", posix_symlink, METH_VARARGS, posix_symlink__doc__},
#endif /* HAVE_SYMLINK */
#ifdef HAVE_SYSTEM
- {"system", posix_system, METH_VARARGS, posix_system__doc__},
+ {"system", posix_system, METH_VARARGS, posix_system__doc__},
#endif
- {"umask", posix_umask, METH_VARARGS, posix_umask__doc__},
+ {"umask", posix_umask, METH_VARARGS, posix_umask__doc__},
#ifdef HAVE_UNAME
- {"uname", posix_uname, METH_NOARGS, posix_uname__doc__},
+ {"uname", posix_uname, METH_NOARGS, posix_uname__doc__},
#endif /* HAVE_UNAME */
- {"unlink", posix_unlink, METH_VARARGS, posix_unlink__doc__},
- {"remove", posix_unlink, METH_VARARGS, posix_remove__doc__},
- {"utime", posix_utime, METH_VARARGS, posix_utime__doc__},
+ {"unlink", posix_unlink, METH_VARARGS, posix_unlink__doc__},
+ {"remove", posix_unlink, METH_VARARGS, posix_remove__doc__},
+ {"utime", posix_utime, METH_VARARGS, posix_utime__doc__},
#ifdef HAVE_TIMES
- {"times", posix_times, METH_NOARGS, posix_times__doc__},
+ {"times", posix_times, METH_NOARGS, posix_times__doc__},
#endif /* HAVE_TIMES */
- {"_exit", posix__exit, METH_VARARGS, posix__exit__doc__},
+ {"_exit", posix__exit, METH_VARARGS, posix__exit__doc__},
#ifdef HAVE_EXECV
- {"execv", posix_execv, METH_VARARGS, posix_execv__doc__},
- {"execve", posix_execve, METH_VARARGS, posix_execve__doc__},
+ {"execv", posix_execv, METH_VARARGS, posix_execv__doc__},
+ {"execve", posix_execve, METH_VARARGS, posix_execve__doc__},
#endif /* HAVE_EXECV */
#ifdef HAVE_SPAWNV
- {"spawnv", posix_spawnv, METH_VARARGS, posix_spawnv__doc__},
- {"spawnve", posix_spawnve, METH_VARARGS, posix_spawnve__doc__},
+ {"spawnv", posix_spawnv, METH_VARARGS, posix_spawnv__doc__},
+ {"spawnve", posix_spawnve, METH_VARARGS, posix_spawnve__doc__},
#if defined(PYOS_OS2)
- {"spawnvp", posix_spawnvp, METH_VARARGS, posix_spawnvp__doc__},
- {"spawnvpe", posix_spawnvpe, METH_VARARGS, posix_spawnvpe__doc__},
+ {"spawnvp", posix_spawnvp, METH_VARARGS, posix_spawnvp__doc__},
+ {"spawnvpe", posix_spawnvpe, METH_VARARGS, posix_spawnvpe__doc__},
#endif /* PYOS_OS2 */
#endif /* HAVE_SPAWNV */
#ifdef HAVE_FORK1
- {"fork1", posix_fork1, METH_NOARGS, posix_fork1__doc__},
+ {"fork1", posix_fork1, METH_NOARGS, posix_fork1__doc__},
#endif /* HAVE_FORK1 */
#ifdef HAVE_FORK
- {"fork", posix_fork, METH_NOARGS, posix_fork__doc__},
+ {"fork", posix_fork, METH_NOARGS, posix_fork__doc__},
#endif /* HAVE_FORK */
#if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)
- {"openpty", posix_openpty, METH_NOARGS, posix_openpty__doc__},
+ {"openpty", posix_openpty, METH_NOARGS, posix_openpty__doc__},
#endif /* HAVE_OPENPTY || HAVE__GETPTY || HAVE_DEV_PTMX */
#ifdef HAVE_FORKPTY
- {"forkpty", posix_forkpty, METH_NOARGS, posix_forkpty__doc__},
+ {"forkpty", posix_forkpty, METH_NOARGS, posix_forkpty__doc__},
#endif /* HAVE_FORKPTY */
#ifdef HAVE_GETEGID
- {"getegid", posix_getegid, METH_NOARGS, posix_getegid__doc__},
+ {"getegid", posix_getegid, METH_NOARGS, posix_getegid__doc__},
#endif /* HAVE_GETEGID */
#ifdef HAVE_GETEUID
- {"geteuid", posix_geteuid, METH_NOARGS, posix_geteuid__doc__},
+ {"geteuid", posix_geteuid, METH_NOARGS, posix_geteuid__doc__},
#endif /* HAVE_GETEUID */
#ifdef HAVE_GETGID
- {"getgid", posix_getgid, METH_NOARGS, posix_getgid__doc__},
+ {"getgid", posix_getgid, METH_NOARGS, posix_getgid__doc__},
#endif /* HAVE_GETGID */
#ifdef HAVE_GETGROUPS
- {"getgroups", posix_getgroups, METH_NOARGS, posix_getgroups__doc__},
+ {"getgroups", posix_getgroups, METH_NOARGS, posix_getgroups__doc__},
#endif
- {"getpid", posix_getpid, METH_NOARGS, posix_getpid__doc__},
+ {"getpid", posix_getpid, METH_NOARGS, posix_getpid__doc__},
#ifdef HAVE_GETPGRP
- {"getpgrp", posix_getpgrp, METH_NOARGS, posix_getpgrp__doc__},
+ {"getpgrp", posix_getpgrp, METH_NOARGS, posix_getpgrp__doc__},
#endif /* HAVE_GETPGRP */
#ifdef HAVE_GETPPID
- {"getppid", posix_getppid, METH_NOARGS, posix_getppid__doc__},
+ {"getppid", posix_getppid, METH_NOARGS, posix_getppid__doc__},
#endif /* HAVE_GETPPID */
#ifdef HAVE_GETUID
- {"getuid", posix_getuid, METH_NOARGS, posix_getuid__doc__},
+ {"getuid", posix_getuid, METH_NOARGS, posix_getuid__doc__},
#endif /* HAVE_GETUID */
#ifdef HAVE_GETLOGIN
- {"getlogin", posix_getlogin, METH_NOARGS, posix_getlogin__doc__},
+ {"getlogin", posix_getlogin, METH_NOARGS, posix_getlogin__doc__},
#endif
#ifdef HAVE_KILL
- {"kill", posix_kill, METH_VARARGS, posix_kill__doc__},
+ {"kill", posix_kill, METH_VARARGS, posix_kill__doc__},
#endif /* HAVE_KILL */
#ifdef HAVE_KILLPG
- {"killpg", posix_killpg, METH_VARARGS, posix_killpg__doc__},
+ {"killpg", posix_killpg, METH_VARARGS, posix_killpg__doc__},
#endif /* HAVE_KILLPG */
#ifdef HAVE_PLOCK
- {"plock", posix_plock, METH_VARARGS, posix_plock__doc__},
+ {"plock", posix_plock, METH_VARARGS, posix_plock__doc__},
#endif /* HAVE_PLOCK */
#ifdef MS_WINDOWS
- {"startfile", win32_startfile, METH_VARARGS, win32_startfile__doc__},
- {"kill", win32_kill, METH_VARARGS, win32_kill__doc__},
+ {"startfile", win32_startfile, METH_VARARGS, win32_startfile__doc__},
+ {"kill", win32_kill, METH_VARARGS, win32_kill__doc__},
#endif
#ifdef HAVE_SETUID
- {"setuid", posix_setuid, METH_VARARGS, posix_setuid__doc__},
+ {"setuid", posix_setuid, METH_VARARGS, posix_setuid__doc__},
#endif /* HAVE_SETUID */
#ifdef HAVE_SETEUID
- {"seteuid", posix_seteuid, METH_VARARGS, posix_seteuid__doc__},
+ {"seteuid", posix_seteuid, METH_VARARGS, posix_seteuid__doc__},
#endif /* HAVE_SETEUID */
#ifdef HAVE_SETEGID
- {"setegid", posix_setegid, METH_VARARGS, posix_setegid__doc__},
+ {"setegid", posix_setegid, METH_VARARGS, posix_setegid__doc__},
#endif /* HAVE_SETEGID */
#ifdef HAVE_SETREUID
- {"setreuid", posix_setreuid, METH_VARARGS, posix_setreuid__doc__},
+ {"setreuid", posix_setreuid, METH_VARARGS, posix_setreuid__doc__},
#endif /* HAVE_SETREUID */
#ifdef HAVE_SETREGID
- {"setregid", posix_setregid, METH_VARARGS, posix_setregid__doc__},
+ {"setregid", posix_setregid, METH_VARARGS, posix_setregid__doc__},
#endif /* HAVE_SETREGID */
#ifdef HAVE_SETGID
- {"setgid", posix_setgid, METH_VARARGS, posix_setgid__doc__},
+ {"setgid", posix_setgid, METH_VARARGS, posix_setgid__doc__},
#endif /* HAVE_SETGID */
#ifdef HAVE_SETGROUPS
- {"setgroups", posix_setgroups, METH_O, posix_setgroups__doc__},
+ {"setgroups", posix_setgroups, METH_O, posix_setgroups__doc__},
#endif /* HAVE_SETGROUPS */
#ifdef HAVE_INITGROUPS
- {"initgroups", posix_initgroups, METH_VARARGS, posix_initgroups__doc__},
+ {"initgroups", posix_initgroups, METH_VARARGS, posix_initgroups__doc__},
#endif /* HAVE_INITGROUPS */
#ifdef HAVE_GETPGID
- {"getpgid", posix_getpgid, METH_VARARGS, posix_getpgid__doc__},
+ {"getpgid", posix_getpgid, METH_VARARGS, posix_getpgid__doc__},
#endif /* HAVE_GETPGID */
#ifdef HAVE_SETPGRP
- {"setpgrp", posix_setpgrp, METH_NOARGS, posix_setpgrp__doc__},
+ {"setpgrp", posix_setpgrp, METH_NOARGS, posix_setpgrp__doc__},
#endif /* HAVE_SETPGRP */
#ifdef HAVE_WAIT
- {"wait", posix_wait, METH_NOARGS, posix_wait__doc__},
+ {"wait", posix_wait, METH_NOARGS, posix_wait__doc__},
#endif /* HAVE_WAIT */
#ifdef HAVE_WAIT3
- {"wait3", posix_wait3, METH_VARARGS, posix_wait3__doc__},
+ {"wait3", posix_wait3, METH_VARARGS, posix_wait3__doc__},
#endif /* HAVE_WAIT3 */
#ifdef HAVE_WAIT4
- {"wait4", posix_wait4, METH_VARARGS, posix_wait4__doc__},
+ {"wait4", posix_wait4, METH_VARARGS, posix_wait4__doc__},
#endif /* HAVE_WAIT4 */
#if defined(HAVE_WAITPID) || defined(HAVE_CWAIT)
- {"waitpid", posix_waitpid, METH_VARARGS, posix_waitpid__doc__},
+ {"waitpid", posix_waitpid, METH_VARARGS, posix_waitpid__doc__},
#endif /* HAVE_WAITPID */
#ifdef HAVE_GETSID
- {"getsid", posix_getsid, METH_VARARGS, posix_getsid__doc__},
+ {"getsid", posix_getsid, METH_VARARGS, posix_getsid__doc__},
#endif /* HAVE_GETSID */
#ifdef HAVE_SETSID
- {"setsid", posix_setsid, METH_NOARGS, posix_setsid__doc__},
+ {"setsid", posix_setsid, METH_NOARGS, posix_setsid__doc__},
#endif /* HAVE_SETSID */
#ifdef HAVE_SETPGID
- {"setpgid", posix_setpgid, METH_VARARGS, posix_setpgid__doc__},
+ {"setpgid", posix_setpgid, METH_VARARGS, posix_setpgid__doc__},
#endif /* HAVE_SETPGID */
#ifdef HAVE_TCGETPGRP
- {"tcgetpgrp", posix_tcgetpgrp, METH_VARARGS, posix_tcgetpgrp__doc__},
+ {"tcgetpgrp", posix_tcgetpgrp, METH_VARARGS, posix_tcgetpgrp__doc__},
#endif /* HAVE_TCGETPGRP */
#ifdef HAVE_TCSETPGRP
- {"tcsetpgrp", posix_tcsetpgrp, METH_VARARGS, posix_tcsetpgrp__doc__},
+ {"tcsetpgrp", posix_tcsetpgrp, METH_VARARGS, posix_tcsetpgrp__doc__},
#endif /* HAVE_TCSETPGRP */
- {"open", posix_open, METH_VARARGS, posix_open__doc__},
- {"close", posix_close, METH_VARARGS, posix_close__doc__},
- {"closerange", posix_closerange, METH_VARARGS, posix_closerange__doc__},
- {"device_encoding", device_encoding, METH_VARARGS, device_encoding__doc__},
- {"dup", posix_dup, METH_VARARGS, posix_dup__doc__},
- {"dup2", posix_dup2, METH_VARARGS, posix_dup2__doc__},
- {"lseek", posix_lseek, METH_VARARGS, posix_lseek__doc__},
- {"read", posix_read, METH_VARARGS, posix_read__doc__},
- {"write", posix_write, METH_VARARGS, posix_write__doc__},
- {"fstat", posix_fstat, METH_VARARGS, posix_fstat__doc__},
- {"isatty", posix_isatty, METH_VARARGS, posix_isatty__doc__},
+ {"open", posix_open, METH_VARARGS, posix_open__doc__},
+ {"close", posix_close, METH_VARARGS, posix_close__doc__},
+ {"closerange", posix_closerange, METH_VARARGS, posix_closerange__doc__},
+ {"device_encoding", device_encoding, METH_VARARGS, device_encoding__doc__},
+ {"dup", posix_dup, METH_VARARGS, posix_dup__doc__},
+ {"dup2", posix_dup2, METH_VARARGS, posix_dup2__doc__},
+ {"lseek", posix_lseek, METH_VARARGS, posix_lseek__doc__},
+ {"read", posix_read, METH_VARARGS, posix_read__doc__},
+ {"write", posix_write, METH_VARARGS, posix_write__doc__},
+ {"fstat", posix_fstat, METH_VARARGS, posix_fstat__doc__},
+ {"isatty", posix_isatty, METH_VARARGS, posix_isatty__doc__},
#ifdef HAVE_PIPE
- {"pipe", posix_pipe, METH_NOARGS, posix_pipe__doc__},
+ {"pipe", posix_pipe, METH_NOARGS, posix_pipe__doc__},
#endif
#ifdef HAVE_MKFIFO
- {"mkfifo", posix_mkfifo, METH_VARARGS, posix_mkfifo__doc__},
+ {"mkfifo", posix_mkfifo, METH_VARARGS, posix_mkfifo__doc__},
#endif
#if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)
- {"mknod", posix_mknod, METH_VARARGS, posix_mknod__doc__},
+ {"mknod", posix_mknod, METH_VARARGS, posix_mknod__doc__},
#endif
#ifdef HAVE_DEVICE_MACROS
- {"major", posix_major, METH_VARARGS, posix_major__doc__},
- {"minor", posix_minor, METH_VARARGS, posix_minor__doc__},
- {"makedev", posix_makedev, METH_VARARGS, posix_makedev__doc__},
+ {"major", posix_major, METH_VARARGS, posix_major__doc__},
+ {"minor", posix_minor, METH_VARARGS, posix_minor__doc__},
+ {"makedev", posix_makedev, METH_VARARGS, posix_makedev__doc__},
#endif
#ifdef HAVE_FTRUNCATE
- {"ftruncate", posix_ftruncate, METH_VARARGS, posix_ftruncate__doc__},
+ {"ftruncate", posix_ftruncate, METH_VARARGS, posix_ftruncate__doc__},
#endif
#ifdef HAVE_PUTENV
- {"putenv", posix_putenv, METH_VARARGS, posix_putenv__doc__},
+ {"putenv", posix_putenv, METH_VARARGS, posix_putenv__doc__},
#endif
#ifdef HAVE_UNSETENV
- {"unsetenv", posix_unsetenv, METH_VARARGS, posix_unsetenv__doc__},
+ {"unsetenv", posix_unsetenv, METH_VARARGS, posix_unsetenv__doc__},
#endif
- {"strerror", posix_strerror, METH_VARARGS, posix_strerror__doc__},
+ {"strerror", posix_strerror, METH_VARARGS, posix_strerror__doc__},
#ifdef HAVE_FCHDIR
- {"fchdir", posix_fchdir, METH_O, posix_fchdir__doc__},
+ {"fchdir", posix_fchdir, METH_O, posix_fchdir__doc__},
#endif
#ifdef HAVE_FSYNC
- {"fsync", posix_fsync, METH_O, posix_fsync__doc__},
+ {"fsync", posix_fsync, METH_O, posix_fsync__doc__},
#endif
#ifdef HAVE_FDATASYNC
- {"fdatasync", posix_fdatasync, METH_O, posix_fdatasync__doc__},
+ {"fdatasync", posix_fdatasync, METH_O, posix_fdatasync__doc__},
#endif
#ifdef HAVE_SYS_WAIT_H
#ifdef WCOREDUMP
- {"WCOREDUMP", posix_WCOREDUMP, METH_VARARGS, posix_WCOREDUMP__doc__},
+ {"WCOREDUMP", posix_WCOREDUMP, METH_VARARGS, posix_WCOREDUMP__doc__},
#endif /* WCOREDUMP */
#ifdef WIFCONTINUED
- {"WIFCONTINUED",posix_WIFCONTINUED, METH_VARARGS, posix_WIFCONTINUED__doc__},
+ {"WIFCONTINUED",posix_WIFCONTINUED, METH_VARARGS, posix_WIFCONTINUED__doc__},
#endif /* WIFCONTINUED */
#ifdef WIFSTOPPED
- {"WIFSTOPPED", posix_WIFSTOPPED, METH_VARARGS, posix_WIFSTOPPED__doc__},
+ {"WIFSTOPPED", posix_WIFSTOPPED, METH_VARARGS, posix_WIFSTOPPED__doc__},
#endif /* WIFSTOPPED */
#ifdef WIFSIGNALED
- {"WIFSIGNALED", posix_WIFSIGNALED, METH_VARARGS, posix_WIFSIGNALED__doc__},
+ {"WIFSIGNALED", posix_WIFSIGNALED, METH_VARARGS, posix_WIFSIGNALED__doc__},
#endif /* WIFSIGNALED */
#ifdef WIFEXITED
- {"WIFEXITED", posix_WIFEXITED, METH_VARARGS, posix_WIFEXITED__doc__},
+ {"WIFEXITED", posix_WIFEXITED, METH_VARARGS, posix_WIFEXITED__doc__},
#endif /* WIFEXITED */
#ifdef WEXITSTATUS
- {"WEXITSTATUS", posix_WEXITSTATUS, METH_VARARGS, posix_WEXITSTATUS__doc__},
+ {"WEXITSTATUS", posix_WEXITSTATUS, METH_VARARGS, posix_WEXITSTATUS__doc__},
#endif /* WEXITSTATUS */
#ifdef WTERMSIG
- {"WTERMSIG", posix_WTERMSIG, METH_VARARGS, posix_WTERMSIG__doc__},
+ {"WTERMSIG", posix_WTERMSIG, METH_VARARGS, posix_WTERMSIG__doc__},
#endif /* WTERMSIG */
#ifdef WSTOPSIG
- {"WSTOPSIG", posix_WSTOPSIG, METH_VARARGS, posix_WSTOPSIG__doc__},
+ {"WSTOPSIG", posix_WSTOPSIG, METH_VARARGS, posix_WSTOPSIG__doc__},
#endif /* WSTOPSIG */
#endif /* HAVE_SYS_WAIT_H */
#if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)
- {"fstatvfs", posix_fstatvfs, METH_VARARGS, posix_fstatvfs__doc__},
+ {"fstatvfs", posix_fstatvfs, METH_VARARGS, posix_fstatvfs__doc__},
#endif
#if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)
- {"statvfs", posix_statvfs, METH_VARARGS, posix_statvfs__doc__},
+ {"statvfs", posix_statvfs, METH_VARARGS, posix_statvfs__doc__},
#endif
#ifdef HAVE_CONFSTR
- {"confstr", posix_confstr, METH_VARARGS, posix_confstr__doc__},
+ {"confstr", posix_confstr, METH_VARARGS, posix_confstr__doc__},
#endif
#ifdef HAVE_SYSCONF
- {"sysconf", posix_sysconf, METH_VARARGS, posix_sysconf__doc__},
+ {"sysconf", posix_sysconf, METH_VARARGS, posix_sysconf__doc__},
#endif
#ifdef HAVE_FPATHCONF
- {"fpathconf", posix_fpathconf, METH_VARARGS, posix_fpathconf__doc__},
+ {"fpathconf", posix_fpathconf, METH_VARARGS, posix_fpathconf__doc__},
#endif
#ifdef HAVE_PATHCONF
- {"pathconf", posix_pathconf, METH_VARARGS, posix_pathconf__doc__},
+ {"pathconf", posix_pathconf, METH_VARARGS, posix_pathconf__doc__},
#endif
- {"abort", posix_abort, METH_NOARGS, posix_abort__doc__},
+ {"abort", posix_abort, METH_NOARGS, posix_abort__doc__},
#ifdef MS_WINDOWS
- {"_getfullpathname", posix__getfullpathname, METH_VARARGS, NULL},
+ {"_getfullpathname", posix__getfullpathname, METH_VARARGS, NULL},
#endif
#ifdef HAVE_GETLOADAVG
- {"getloadavg", posix_getloadavg, METH_NOARGS, posix_getloadavg__doc__},
+ {"getloadavg", posix_getloadavg, METH_NOARGS, posix_getloadavg__doc__},
#endif
#ifdef MS_WINDOWS
- {"urandom", win32_urandom, METH_VARARGS, win32_urandom__doc__},
+ {"urandom", win32_urandom, METH_VARARGS, win32_urandom__doc__},
#endif
#ifdef __VMS
- {"urandom", vms_urandom, METH_VARARGS, vms_urandom__doc__},
+ {"urandom", vms_urandom, METH_VARARGS, vms_urandom__doc__},
#endif
#ifdef HAVE_SETRESUID
- {"setresuid", posix_setresuid, METH_VARARGS, posix_setresuid__doc__},
+ {"setresuid", posix_setresuid, METH_VARARGS, posix_setresuid__doc__},
#endif
#ifdef HAVE_SETRESGID
- {"setresgid", posix_setresgid, METH_VARARGS, posix_setresgid__doc__},
+ {"setresgid", posix_setresgid, METH_VARARGS, posix_setresgid__doc__},
#endif
#ifdef HAVE_GETRESUID
- {"getresuid", posix_getresuid, METH_NOARGS, posix_getresuid__doc__},
+ {"getresuid", posix_getresuid, METH_NOARGS, posix_getresuid__doc__},
#endif
#ifdef HAVE_GETRESGID
- {"getresgid", posix_getresgid, METH_NOARGS, posix_getresgid__doc__},
+ {"getresgid", posix_getresgid, METH_NOARGS, posix_getresgid__doc__},
#endif
- {NULL, NULL} /* Sentinel */
+ {NULL, NULL} /* Sentinel */
};
static int
ins(PyObject *module, char *symbol, long value)
{
- return PyModule_AddIntConstant(module, symbol, value);
+ return PyModule_AddIntConstant(module, symbol, value);
}
#if defined(PYOS_OS2)
case 50: ver = "5.00"; break;
default:
PyOS_snprintf(tmp, sizeof(tmp),
- "%d-%d", values[QSV_VERSION_MAJOR],
+ "%d-%d", values[QSV_VERSION_MAJOR],
values[QSV_VERSION_MINOR]);
ver = &tmp[0];
}
all_ins(PyObject *d)
{
#ifdef F_OK
- if (ins(d, "F_OK", (long)F_OK)) return -1;
+ if (ins(d, "F_OK", (long)F_OK)) return -1;
#endif
#ifdef R_OK
- if (ins(d, "R_OK", (long)R_OK)) return -1;
+ if (ins(d, "R_OK", (long)R_OK)) return -1;
#endif
#ifdef W_OK
- if (ins(d, "W_OK", (long)W_OK)) return -1;
+ if (ins(d, "W_OK", (long)W_OK)) return -1;
#endif
#ifdef X_OK
- if (ins(d, "X_OK", (long)X_OK)) return -1;
+ if (ins(d, "X_OK", (long)X_OK)) return -1;
#endif
#ifdef NGROUPS_MAX
- if (ins(d, "NGROUPS_MAX", (long)NGROUPS_MAX)) return -1;
+ if (ins(d, "NGROUPS_MAX", (long)NGROUPS_MAX)) return -1;
#endif
#ifdef TMP_MAX
- if (ins(d, "TMP_MAX", (long)TMP_MAX)) return -1;
+ if (ins(d, "TMP_MAX", (long)TMP_MAX)) return -1;
#endif
#ifdef WCONTINUED
- if (ins(d, "WCONTINUED", (long)WCONTINUED)) return -1;
+ if (ins(d, "WCONTINUED", (long)WCONTINUED)) return -1;
#endif
#ifdef WNOHANG
- if (ins(d, "WNOHANG", (long)WNOHANG)) return -1;
+ if (ins(d, "WNOHANG", (long)WNOHANG)) return -1;
#endif
#ifdef WUNTRACED
- if (ins(d, "WUNTRACED", (long)WUNTRACED)) return -1;
+ if (ins(d, "WUNTRACED", (long)WUNTRACED)) return -1;
#endif
#ifdef O_RDONLY
- if (ins(d, "O_RDONLY", (long)O_RDONLY)) return -1;
+ if (ins(d, "O_RDONLY", (long)O_RDONLY)) return -1;
#endif
#ifdef O_WRONLY
- if (ins(d, "O_WRONLY", (long)O_WRONLY)) return -1;
+ if (ins(d, "O_WRONLY", (long)O_WRONLY)) return -1;
#endif
#ifdef O_RDWR
- if (ins(d, "O_RDWR", (long)O_RDWR)) return -1;
+ if (ins(d, "O_RDWR", (long)O_RDWR)) return -1;
#endif
#ifdef O_NDELAY
- if (ins(d, "O_NDELAY", (long)O_NDELAY)) return -1;
+ if (ins(d, "O_NDELAY", (long)O_NDELAY)) return -1;
#endif
#ifdef O_NONBLOCK
- if (ins(d, "O_NONBLOCK", (long)O_NONBLOCK)) return -1;
+ if (ins(d, "O_NONBLOCK", (long)O_NONBLOCK)) return -1;
#endif
#ifdef O_APPEND
- if (ins(d, "O_APPEND", (long)O_APPEND)) return -1;
+ if (ins(d, "O_APPEND", (long)O_APPEND)) return -1;
#endif
#ifdef O_DSYNC
- if (ins(d, "O_DSYNC", (long)O_DSYNC)) return -1;
+ if (ins(d, "O_DSYNC", (long)O_DSYNC)) return -1;
#endif
#ifdef O_RSYNC
- if (ins(d, "O_RSYNC", (long)O_RSYNC)) return -1;
+ if (ins(d, "O_RSYNC", (long)O_RSYNC)) return -1;
#endif
#ifdef O_SYNC
- if (ins(d, "O_SYNC", (long)O_SYNC)) return -1;
+ if (ins(d, "O_SYNC", (long)O_SYNC)) return -1;
#endif
#ifdef O_NOCTTY
- if (ins(d, "O_NOCTTY", (long)O_NOCTTY)) return -1;
+ if (ins(d, "O_NOCTTY", (long)O_NOCTTY)) return -1;
#endif
#ifdef O_CREAT
- if (ins(d, "O_CREAT", (long)O_CREAT)) return -1;
+ if (ins(d, "O_CREAT", (long)O_CREAT)) return -1;
#endif
#ifdef O_EXCL
- if (ins(d, "O_EXCL", (long)O_EXCL)) return -1;
+ if (ins(d, "O_EXCL", (long)O_EXCL)) return -1;
#endif
#ifdef O_TRUNC
- if (ins(d, "O_TRUNC", (long)O_TRUNC)) return -1;
+ if (ins(d, "O_TRUNC", (long)O_TRUNC)) return -1;
#endif
#ifdef O_BINARY
- if (ins(d, "O_BINARY", (long)O_BINARY)) return -1;
+ if (ins(d, "O_BINARY", (long)O_BINARY)) return -1;
#endif
#ifdef O_TEXT
- if (ins(d, "O_TEXT", (long)O_TEXT)) return -1;
+ if (ins(d, "O_TEXT", (long)O_TEXT)) return -1;
#endif
#ifdef O_LARGEFILE
- if (ins(d, "O_LARGEFILE", (long)O_LARGEFILE)) return -1;
+ if (ins(d, "O_LARGEFILE", (long)O_LARGEFILE)) return -1;
#endif
#ifdef O_SHLOCK
- if (ins(d, "O_SHLOCK", (long)O_SHLOCK)) return -1;
+ if (ins(d, "O_SHLOCK", (long)O_SHLOCK)) return -1;
#endif
#ifdef O_EXLOCK
- if (ins(d, "O_EXLOCK", (long)O_EXLOCK)) return -1;
+ if (ins(d, "O_EXLOCK", (long)O_EXLOCK)) return -1;
#endif
/* MS Windows */
#ifdef O_NOINHERIT
- /* Don't inherit in child processes. */
- if (ins(d, "O_NOINHERIT", (long)O_NOINHERIT)) return -1;
+ /* Don't inherit in child processes. */
+ if (ins(d, "O_NOINHERIT", (long)O_NOINHERIT)) return -1;
#endif
#ifdef _O_SHORT_LIVED
- /* Optimize for short life (keep in memory). */
- /* MS forgot to define this one with a non-underscore form too. */
- if (ins(d, "O_SHORT_LIVED", (long)_O_SHORT_LIVED)) return -1;
+ /* Optimize for short life (keep in memory). */
+ /* MS forgot to define this one with a non-underscore form too. */
+ if (ins(d, "O_SHORT_LIVED", (long)_O_SHORT_LIVED)) return -1;
#endif
#ifdef O_TEMPORARY
- /* Automatically delete when last handle is closed. */
- if (ins(d, "O_TEMPORARY", (long)O_TEMPORARY)) return -1;
+ /* Automatically delete when last handle is closed. */
+ if (ins(d, "O_TEMPORARY", (long)O_TEMPORARY)) return -1;
#endif
#ifdef O_RANDOM
- /* Optimize for random access. */
- if (ins(d, "O_RANDOM", (long)O_RANDOM)) return -1;
+ /* Optimize for random access. */
+ if (ins(d, "O_RANDOM", (long)O_RANDOM)) return -1;
#endif
#ifdef O_SEQUENTIAL
- /* Optimize for sequential access. */
- if (ins(d, "O_SEQUENTIAL", (long)O_SEQUENTIAL)) return -1;
+ /* Optimize for sequential access. */
+ if (ins(d, "O_SEQUENTIAL", (long)O_SEQUENTIAL)) return -1;
#endif
/* GNU extensions. */
#ifdef O_ASYNC
- /* Send a SIGIO signal whenever input or output
- becomes available on file descriptor */
- if (ins(d, "O_ASYNC", (long)O_ASYNC)) return -1;
+ /* Send a SIGIO signal whenever input or output
+ becomes available on file descriptor */
+ if (ins(d, "O_ASYNC", (long)O_ASYNC)) return -1;
#endif
#ifdef O_DIRECT
- /* Direct disk access. */
- if (ins(d, "O_DIRECT", (long)O_DIRECT)) return -1;
+ /* Direct disk access. */
+ if (ins(d, "O_DIRECT", (long)O_DIRECT)) return -1;
#endif
#ifdef O_DIRECTORY
- /* Must be a directory. */
- if (ins(d, "O_DIRECTORY", (long)O_DIRECTORY)) return -1;
+ /* Must be a directory. */
+ if (ins(d, "O_DIRECTORY", (long)O_DIRECTORY)) return -1;
#endif
#ifdef O_NOFOLLOW
- /* Do not follow links. */
- if (ins(d, "O_NOFOLLOW", (long)O_NOFOLLOW)) return -1;
+ /* Do not follow links. */
+ if (ins(d, "O_NOFOLLOW", (long)O_NOFOLLOW)) return -1;
#endif
#ifdef O_NOATIME
- /* Do not update the access time. */
- if (ins(d, "O_NOATIME", (long)O_NOATIME)) return -1;
+ /* Do not update the access time. */
+ if (ins(d, "O_NOATIME", (long)O_NOATIME)) return -1;
#endif
- /* These come from sysexits.h */
+ /* These come from sysexits.h */
#ifdef EX_OK
- if (ins(d, "EX_OK", (long)EX_OK)) return -1;
+ if (ins(d, "EX_OK", (long)EX_OK)) return -1;
#endif /* EX_OK */
#ifdef EX_USAGE
- if (ins(d, "EX_USAGE", (long)EX_USAGE)) return -1;
+ if (ins(d, "EX_USAGE", (long)EX_USAGE)) return -1;
#endif /* EX_USAGE */
#ifdef EX_DATAERR
- if (ins(d, "EX_DATAERR", (long)EX_DATAERR)) return -1;
+ if (ins(d, "EX_DATAERR", (long)EX_DATAERR)) return -1;
#endif /* EX_DATAERR */
#ifdef EX_NOINPUT
- if (ins(d, "EX_NOINPUT", (long)EX_NOINPUT)) return -1;
+ if (ins(d, "EX_NOINPUT", (long)EX_NOINPUT)) return -1;
#endif /* EX_NOINPUT */
#ifdef EX_NOUSER
- if (ins(d, "EX_NOUSER", (long)EX_NOUSER)) return -1;
+ if (ins(d, "EX_NOUSER", (long)EX_NOUSER)) return -1;
#endif /* EX_NOUSER */
#ifdef EX_NOHOST
- if (ins(d, "EX_NOHOST", (long)EX_NOHOST)) return -1;
+ if (ins(d, "EX_NOHOST", (long)EX_NOHOST)) return -1;
#endif /* EX_NOHOST */
#ifdef EX_UNAVAILABLE
- if (ins(d, "EX_UNAVAILABLE", (long)EX_UNAVAILABLE)) return -1;
+ if (ins(d, "EX_UNAVAILABLE", (long)EX_UNAVAILABLE)) return -1;
#endif /* EX_UNAVAILABLE */
#ifdef EX_SOFTWARE
- if (ins(d, "EX_SOFTWARE", (long)EX_SOFTWARE)) return -1;
+ if (ins(d, "EX_SOFTWARE", (long)EX_SOFTWARE)) return -1;
#endif /* EX_SOFTWARE */
#ifdef EX_OSERR
- if (ins(d, "EX_OSERR", (long)EX_OSERR)) return -1;
+ if (ins(d, "EX_OSERR", (long)EX_OSERR)) return -1;
#endif /* EX_OSERR */
#ifdef EX_OSFILE
- if (ins(d, "EX_OSFILE", (long)EX_OSFILE)) return -1;
+ if (ins(d, "EX_OSFILE", (long)EX_OSFILE)) return -1;
#endif /* EX_OSFILE */
#ifdef EX_CANTCREAT
- if (ins(d, "EX_CANTCREAT", (long)EX_CANTCREAT)) return -1;
+ if (ins(d, "EX_CANTCREAT", (long)EX_CANTCREAT)) return -1;
#endif /* EX_CANTCREAT */
#ifdef EX_IOERR
- if (ins(d, "EX_IOERR", (long)EX_IOERR)) return -1;
+ if (ins(d, "EX_IOERR", (long)EX_IOERR)) return -1;
#endif /* EX_IOERR */
#ifdef EX_TEMPFAIL
- if (ins(d, "EX_TEMPFAIL", (long)EX_TEMPFAIL)) return -1;
+ if (ins(d, "EX_TEMPFAIL", (long)EX_TEMPFAIL)) return -1;
#endif /* EX_TEMPFAIL */
#ifdef EX_PROTOCOL
- if (ins(d, "EX_PROTOCOL", (long)EX_PROTOCOL)) return -1;
+ if (ins(d, "EX_PROTOCOL", (long)EX_PROTOCOL)) return -1;
#endif /* EX_PROTOCOL */
#ifdef EX_NOPERM
- if (ins(d, "EX_NOPERM", (long)EX_NOPERM)) return -1;
+ if (ins(d, "EX_NOPERM", (long)EX_NOPERM)) return -1;
#endif /* EX_NOPERM */
#ifdef EX_CONFIG
- if (ins(d, "EX_CONFIG", (long)EX_CONFIG)) return -1;
+ if (ins(d, "EX_CONFIG", (long)EX_CONFIG)) return -1;
#endif /* EX_CONFIG */
#ifdef EX_NOTFOUND
- if (ins(d, "EX_NOTFOUND", (long)EX_NOTFOUND)) return -1;
+ if (ins(d, "EX_NOTFOUND", (long)EX_NOTFOUND)) return -1;
#endif /* EX_NOTFOUND */
#ifdef HAVE_SPAWNV
#if defined(PYOS_OS2) && defined(PYCC_GCC)
- if (ins(d, "P_WAIT", (long)P_WAIT)) return -1;
- if (ins(d, "P_NOWAIT", (long)P_NOWAIT)) return -1;
- if (ins(d, "P_OVERLAY", (long)P_OVERLAY)) return -1;
- if (ins(d, "P_DEBUG", (long)P_DEBUG)) return -1;
- if (ins(d, "P_SESSION", (long)P_SESSION)) return -1;
- if (ins(d, "P_DETACH", (long)P_DETACH)) return -1;
- if (ins(d, "P_PM", (long)P_PM)) return -1;
- if (ins(d, "P_DEFAULT", (long)P_DEFAULT)) return -1;
- if (ins(d, "P_MINIMIZE", (long)P_MINIMIZE)) return -1;
- if (ins(d, "P_MAXIMIZE", (long)P_MAXIMIZE)) return -1;
- if (ins(d, "P_FULLSCREEN", (long)P_FULLSCREEN)) return -1;
- if (ins(d, "P_WINDOWED", (long)P_WINDOWED)) return -1;
- if (ins(d, "P_FOREGROUND", (long)P_FOREGROUND)) return -1;
- if (ins(d, "P_BACKGROUND", (long)P_BACKGROUND)) return -1;
- if (ins(d, "P_NOCLOSE", (long)P_NOCLOSE)) return -1;
- if (ins(d, "P_NOSESSION", (long)P_NOSESSION)) return -1;
- if (ins(d, "P_QUOTE", (long)P_QUOTE)) return -1;
- if (ins(d, "P_TILDE", (long)P_TILDE)) return -1;
- if (ins(d, "P_UNRELATED", (long)P_UNRELATED)) return -1;
- if (ins(d, "P_DEBUGDESC", (long)P_DEBUGDESC)) return -1;
+ if (ins(d, "P_WAIT", (long)P_WAIT)) return -1;
+ if (ins(d, "P_NOWAIT", (long)P_NOWAIT)) return -1;
+ if (ins(d, "P_OVERLAY", (long)P_OVERLAY)) return -1;
+ if (ins(d, "P_DEBUG", (long)P_DEBUG)) return -1;
+ if (ins(d, "P_SESSION", (long)P_SESSION)) return -1;
+ if (ins(d, "P_DETACH", (long)P_DETACH)) return -1;
+ if (ins(d, "P_PM", (long)P_PM)) return -1;
+ if (ins(d, "P_DEFAULT", (long)P_DEFAULT)) return -1;
+ if (ins(d, "P_MINIMIZE", (long)P_MINIMIZE)) return -1;
+ if (ins(d, "P_MAXIMIZE", (long)P_MAXIMIZE)) return -1;
+ if (ins(d, "P_FULLSCREEN", (long)P_FULLSCREEN)) return -1;
+ if (ins(d, "P_WINDOWED", (long)P_WINDOWED)) return -1;
+ if (ins(d, "P_FOREGROUND", (long)P_FOREGROUND)) return -1;
+ if (ins(d, "P_BACKGROUND", (long)P_BACKGROUND)) return -1;
+ if (ins(d, "P_NOCLOSE", (long)P_NOCLOSE)) return -1;
+ if (ins(d, "P_NOSESSION", (long)P_NOSESSION)) return -1;
+ if (ins(d, "P_QUOTE", (long)P_QUOTE)) return -1;
+ if (ins(d, "P_TILDE", (long)P_TILDE)) return -1;
+ if (ins(d, "P_UNRELATED", (long)P_UNRELATED)) return -1;
+ if (ins(d, "P_DEBUGDESC", (long)P_DEBUGDESC)) return -1;
#else
- if (ins(d, "P_WAIT", (long)_P_WAIT)) return -1;
- if (ins(d, "P_NOWAIT", (long)_P_NOWAIT)) return -1;
- if (ins(d, "P_OVERLAY", (long)_OLD_P_OVERLAY)) return -1;
- if (ins(d, "P_NOWAITO", (long)_P_NOWAITO)) return -1;
- if (ins(d, "P_DETACH", (long)_P_DETACH)) return -1;
+ if (ins(d, "P_WAIT", (long)_P_WAIT)) return -1;
+ if (ins(d, "P_NOWAIT", (long)_P_NOWAIT)) return -1;
+ if (ins(d, "P_OVERLAY", (long)_OLD_P_OVERLAY)) return -1;
+ if (ins(d, "P_NOWAITO", (long)_P_NOWAITO)) return -1;
+ if (ins(d, "P_DETACH", (long)_P_DETACH)) return -1;
#endif
#endif
#if defined(PYOS_OS2)
- if (insertvalues(d)) return -1;
+ if (insertvalues(d)) return -1;
#endif
- return 0;
+ return 0;
}
#endif
static struct PyModuleDef posixmodule = {
- PyModuleDef_HEAD_INIT,
- MODNAME,
- posix__doc__,
- -1,
- posix_methods,
- NULL,
- NULL,
- NULL,
- NULL
+ PyModuleDef_HEAD_INIT,
+ MODNAME,
+ posix__doc__,
+ -1,
+ posix_methods,
+ NULL,
+ NULL,
+ NULL,
+ NULL
};
PyMODINIT_FUNC
INITFUNC(void)
{
- PyObject *m, *v;
+ PyObject *m, *v;
- m = PyModule_Create(&posixmodule);
- if (m == NULL)
- return NULL;
+ m = PyModule_Create(&posixmodule);
+ if (m == NULL)
+ return NULL;
- /* Initialize environ dictionary */
- v = convertenviron();
- Py_XINCREF(v);
- if (v == NULL || PyModule_AddObject(m, "environ", v) != 0)
- return NULL;
- Py_DECREF(v);
+ /* Initialize environ dictionary */
+ v = convertenviron();
+ Py_XINCREF(v);
+ if (v == NULL || PyModule_AddObject(m, "environ", v) != 0)
+ return NULL;
+ Py_DECREF(v);
- if (all_ins(m))
- return NULL;
+ if (all_ins(m))
+ return NULL;
- if (setup_confname_tables(m))
- return NULL;
+ if (setup_confname_tables(m))
+ return NULL;
- Py_INCREF(PyExc_OSError);
- PyModule_AddObject(m, "error", PyExc_OSError);
+ Py_INCREF(PyExc_OSError);
+ PyModule_AddObject(m, "error", PyExc_OSError);
#ifdef HAVE_PUTENV
- if (posix_putenv_garbage == NULL)
- posix_putenv_garbage = PyDict_New();
+ if (posix_putenv_garbage == NULL)
+ posix_putenv_garbage = PyDict_New();
#endif
- if (!initialized) {
- stat_result_desc.name = MODNAME ".stat_result";
- stat_result_desc.fields[7].name = PyStructSequence_UnnamedField;
- stat_result_desc.fields[8].name = PyStructSequence_UnnamedField;
- stat_result_desc.fields[9].name = PyStructSequence_UnnamedField;
- PyStructSequence_InitType(&StatResultType, &stat_result_desc);
- structseq_new = StatResultType.tp_new;
- StatResultType.tp_new = statresult_new;
+ if (!initialized) {
+ stat_result_desc.name = MODNAME ".stat_result";
+ stat_result_desc.fields[7].name = PyStructSequence_UnnamedField;
+ stat_result_desc.fields[8].name = PyStructSequence_UnnamedField;
+ stat_result_desc.fields[9].name = PyStructSequence_UnnamedField;
+ PyStructSequence_InitType(&StatResultType, &stat_result_desc);
+ structseq_new = StatResultType.tp_new;
+ StatResultType.tp_new = statresult_new;
- statvfs_result_desc.name = MODNAME ".statvfs_result";
- PyStructSequence_InitType(&StatVFSResultType, &statvfs_result_desc);
+ statvfs_result_desc.name = MODNAME ".statvfs_result";
+ PyStructSequence_InitType(&StatVFSResultType, &statvfs_result_desc);
#ifdef NEED_TICKS_PER_SECOND
# if defined(HAVE_SYSCONF) && defined(_SC_CLK_TCK)
- ticks_per_second = sysconf(_SC_CLK_TCK);
+ ticks_per_second = sysconf(_SC_CLK_TCK);
# elif defined(HZ)
- ticks_per_second = HZ;
+ ticks_per_second = HZ;
# else
- ticks_per_second = 60; /* magic fallback value; may be bogus */
+ ticks_per_second = 60; /* magic fallback value; may be bogus */
# endif
#endif
- }
- Py_INCREF((PyObject*) &StatResultType);
- PyModule_AddObject(m, "stat_result", (PyObject*) &StatResultType);
- Py_INCREF((PyObject*) &StatVFSResultType);
- PyModule_AddObject(m, "statvfs_result",
- (PyObject*) &StatVFSResultType);
- initialized = 1;
+ }
+ Py_INCREF((PyObject*) &StatResultType);
+ PyModule_AddObject(m, "stat_result", (PyObject*) &StatResultType);
+ Py_INCREF((PyObject*) &StatVFSResultType);
+ PyModule_AddObject(m, "statvfs_result",
+ (PyObject*) &StatVFSResultType);
+ initialized = 1;
#ifdef __APPLE__
- /*
- * Step 2 of weak-linking support on Mac OS X.
- *
- * The code below removes functions that are not available on the
- * currently active platform.
- *
- * This block allow one to use a python binary that was build on
- * OSX 10.4 on OSX 10.3, without loosing access to new APIs on
- * OSX 10.4.
- */
+ /*
+ * Step 2 of weak-linking support on Mac OS X.
+ *
+ * The code below removes functions that are not available on the
+ * currently active platform.
+ *
+ * This block allow one to use a python binary that was build on
+ * OSX 10.4 on OSX 10.3, without loosing access to new APIs on
+ * OSX 10.4.
+ */
#ifdef HAVE_FSTATVFS
- if (fstatvfs == NULL) {
- if (PyObject_DelAttrString(m, "fstatvfs") == -1) {
- return NULL;
- }
- }
+ if (fstatvfs == NULL) {
+ if (PyObject_DelAttrString(m, "fstatvfs") == -1) {
+ return NULL;
+ }
+ }
#endif /* HAVE_FSTATVFS */
#ifdef HAVE_STATVFS
- if (statvfs == NULL) {
- if (PyObject_DelAttrString(m, "statvfs") == -1) {
- return NULL;
- }
- }
+ if (statvfs == NULL) {
+ if (PyObject_DelAttrString(m, "statvfs") == -1) {
+ return NULL;
+ }
+ }
#endif /* HAVE_STATVFS */
# ifdef HAVE_LCHOWN
- if (lchown == NULL) {
- if (PyObject_DelAttrString(m, "lchown") == -1) {
- return NULL;
- }
- }
+ if (lchown == NULL) {
+ if (PyObject_DelAttrString(m, "lchown") == -1) {
+ return NULL;
+ }
+ }
#endif /* HAVE_LCHOWN */
#endif /* __APPLE__ */
- return m;
+ return m;
}
projects / python / commitdiff