/* POSIX generic methods */
static PyObject *
-posix_int(args, func)
+posix_int(args, format, func)
PyObject *args;
+ char *format;
int (*func) Py_FPROTO((int));
{
int fd;
int res;
- if (!PyArg_Parse(args, "i", &fd))
+ if (!PyArg_ParseTuple(args, format, &fd))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = (*func)(fd);
static PyObject *
-posix_1str(args, func)
+posix_1str(args, format, func)
PyObject *args;
+ char *format;
int (*func) Py_FPROTO((const char *));
{
char *path1;
int res;
- if (!PyArg_Parse(args, "s", &path1))
+ if (!PyArg_ParseTuple(args, format, &path1))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = (*func)(path1);
}
static PyObject *
-posix_2str(args, func)
+posix_2str(args, format, func)
PyObject *args;
+ char *format;
int (*func) Py_FPROTO((const char *, const char *));
{
char *path1, *path2;
int res;
- if (!PyArg_Parse(args, "(ss)", &path1, &path2))
+ if (!PyArg_ParseTuple(args, format, &path1, &path2))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = (*func)(path1, path2);
}
static PyObject *
-posix_strint(args, func)
+posix_strint(args, format, func)
PyObject *args;
+ char *format;
int (*func) Py_FPROTO((const char *, int));
{
char *path;
int i;
int res;
- if (!PyArg_Parse(args, "(si)", &path, &i))
+ if (!PyArg_ParseTuple(args, format, &path, &i))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = (*func)(path, i);
}
static PyObject *
-posix_strintint(args, func)
+posix_strintint(args, format, func)
PyObject *args;
+ char *format;
int (*func) Py_FPROTO((const char *, int, int));
{
char *path;
int i,i2;
int res;
- if (!PyArg_Parse(args, "(sii)", &path, &i, &i2))
+ if (!PyArg_ParseTuple(args, format, &path, &i, &i2))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = (*func)(path, i, i2);
}
static PyObject *
-posix_do_stat(self, args, statfunc)
+posix_do_stat(self, args, format, statfunc)
PyObject *self;
PyObject *args;
+ char *format;
int (*statfunc) Py_FPROTO((const char *, struct stat *));
{
struct stat st;
char *path;
int res;
- if (!PyArg_Parse(args, "s", &path))
+ if (!PyArg_ParseTuple(args, format, &path))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = (*statfunc)(path, &st);
int mode;
int res;
- if (!PyArg_Parse(args, "(si)", &path, &mode))
+ if (!PyArg_ParseTuple(args, "si:access", &path, &mode))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = access(path, mode);
PyObject *self;
PyObject *args;
{
- PyObject *file;
int id;
char *ret;
- if (!PyArg_Parse(args, "i", &id))
+ if (!PyArg_ParseTuple(args, "i:ttyname", &id))
return NULL;
ret = ttyname(id);
}
#endif
+#ifdef HAVE_CTERMID
+static char posix_ctermid__doc__[] =
+"ctermid() -> String\n\
+Return the name of the controlling terminal for this process.";
+
+static PyObject *
+posix_ctermid(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *ret;
+ char buffer[L_ctermid];
+
+ if (!PyArg_ParseTuple(args, ":ctermid"))
+ return NULL;
+
+#ifdef HAVE_CTERMID_R
+ ret = ctermid_r(buffer);
+#else
+ ret = ctermid(buffer);
+#endif
+ if (ret == NULL)
+ return(posix_error());
+ return(PyString_FromString(buffer));
+}
+#endif
+
static char posix_chdir__doc__[] =
"chdir(path) -> None\n\
Change the current working directory to the specified path.";
PyObject *self;
PyObject *args;
{
- return posix_1str(args, chdir);
+ return posix_1str(args, "s:chdir", chdir);
}
PyObject *self;
PyObject *args;
{
- return posix_strint(args, chmod);
+ return posix_strint(args, "si:chmod", chmod);
}
PyObject *self;
PyObject *args;
{
- return posix_int(args, fsync);
+ return posix_int(args, "i:fsync", fsync);
}
#endif /* HAVE_FSYNC */
PyObject *self;
PyObject *args;
{
- return posix_int(args, fdatasync);
+ return posix_int(args, "i:fdatasync", fdatasync);
}
#endif /* HAVE_FDATASYNC */
PyObject *self;
PyObject *args;
{
- return posix_strintint(args, chown);
+ return posix_strintint(args, "sii:chown", chown);
}
#endif /* HAVE_CHOWN */
{
char buf[1026];
char *res;
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":getcwd"))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = getcwd(buf, sizeof buf);
PyObject *self;
PyObject *args;
{
- return posix_2str(args, link);
+ return posix_2str(args, "ss:link", link);
}
#endif /* HAVE_LINK */
WIN32_FIND_DATA FileData;
char namebuf[MAX_PATH+5];
- if (!PyArg_Parse(args, "t#", &name, &len))
+ if (!PyArg_ParseTuple(args, "t#:listdir", &name, &len))
return NULL;
if (len >= MAX_PATH) {
PyErr_SetString(PyExc_ValueError, "path too long");
char namebuf[MAX_PATH+5];
struct _find_t ep;
- if (!PyArg_Parse(args, "t#", &name, &len))
+ if (!PyArg_ParseTuple(args, "t#:listdir", &name, &len))
return NULL;
if (len >= MAX_PATH) {
PyErr_SetString(PyExc_ValueError, "path too long");
FILEFINDBUF3 ep;
APIRET rc;
- if (!PyArg_Parse(args, "t#", &name, &len))
+ if (!PyArg_ParseTuple(args, "t#:listdir", &name, &len))
return NULL;
if (len >= MAX_PATH) {
PyErr_SetString(PyExc_ValueError, "path too long");
PyObject *d, *v;
DIR *dirp;
struct dirent *ep;
- if (!PyArg_Parse(args, "s", &name))
+ if (!PyArg_ParseTuple(args, "s:listdir", &name))
return NULL;
Py_BEGIN_ALLOW_THREADS
if ((dirp = opendir(name)) == NULL) {
int res;
char *path;
int mode = 0777;
- if (!PyArg_ParseTuple(args, "s|i", &path, &mode))
+ if (!PyArg_ParseTuple(args, "s|i:mkdir", &path, &mode))
return NULL;
Py_BEGIN_ALLOW_THREADS
#if ( defined(__WATCOMC__) || defined(_MSC_VER) || defined(PYCC_VACPP) ) && !defined(__QNX__)
{
int increment, value;
- if (!PyArg_Parse(args, "i", &increment))
+ if (!PyArg_ParseTuple(args, "i:nice", &increment))
return NULL;
value = nice(increment);
if (value == -1)
PyObject *self;
PyObject *args;
{
- return posix_2str(args, rename);
+ return posix_2str(args, "ss:rename", rename);
}
PyObject *self;
PyObject *args;
{
- return posix_1str(args, rmdir);
+ return posix_1str(args, "s:rmdir", rmdir);
}
PyObject *self;
PyObject *args;
{
- return posix_do_stat(self, args, stat);
+ return posix_do_stat(self, args, "s:stat", stat);
}
{
char *command;
long sts;
- if (!PyArg_Parse(args, "s", &command))
+ if (!PyArg_ParseTuple(args, "s:system", &command))
return NULL;
Py_BEGIN_ALLOW_THREADS
sts = system(command);
PyObject *args;
{
int i;
- if (!PyArg_Parse(args, "i", &i))
+ if (!PyArg_ParseTuple(args, "i:umask", &i))
return NULL;
i = umask(i);
if (i < 0)
PyObject *self;
PyObject *args;
{
- return posix_1str(args, unlink);
+ return posix_1str(args, "s:remove", unlink);
}
{
struct utsname u;
int res;
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":uname"))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = uname(&u);
#define UTIME_ARG buf
#endif /* HAVE_UTIME_H */
- if (!PyArg_Parse(args, "(s(ll))", &path, &atime, &mtime))
+ if (!PyArg_ParseTuple(args, "s(ll):utime", &path, &atime, &mtime))
return NULL;
ATIME = atime;
MTIME = mtime;
PyObject *args;
{
int sts;
- if (!PyArg_Parse(args, "i", &sts))
+ if (!PyArg_ParseTuple(args, "i:_exit", &sts))
return NULL;
_exit(sts);
return NULL; /* Make gcc -Wall happy */
/* execv has two arguments: (path, argv), where
argv is a list or tuple of strings. */
- if (!PyArg_Parse(args, "(sO)", &path, &argv))
+ if (!PyArg_ParseTuple(args, "sO:execv", &path, &argv))
return NULL;
if (PyList_Check(argv)) {
argc = PyList_Size(argv);
argv is a list or tuple of strings and env is a dictionary
like posix.environ. */
- if (!PyArg_Parse(args, "(sOO)", &path, &argv, &env))
+ if (!PyArg_ParseTuple(args, "sOO:execve", &path, &argv, &env))
return NULL;
if (PyList_Check(argv)) {
argc = PyList_Size(argv);
/* spawnv has three arguments: (mode, path, argv), where
argv is a list or tuple of strings. */
- if (!PyArg_Parse(args, "(isO)", &mode, &path, &argv))
+ if (!PyArg_ParseTuple(args, "isO:spawnv", &mode, &path, &argv))
return NULL;
if (PyList_Check(argv)) {
argc = PyList_Size(argv);
argv is a list or tuple of strings and env is a dictionary
like posix.environ. */
- if (!PyArg_Parse(args, "(isOO)", &mode, &path, &argv, &env))
+ if (!PyArg_ParseTuple(args, "isOO:spawnve", &mode, &path, &argv, &env))
return NULL;
if (PyList_Check(argv)) {
argc = PyList_Size(argv);
PyObject *args;
{
int pid;
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":fork"))
return NULL;
pid = fork();
if (pid == -1)
PyObject *self;
PyObject *args;
{
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":getegid"))
return NULL;
return PyInt_FromLong((long)getegid());
}
PyObject *self;
PyObject *args;
{
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":geteuid"))
return NULL;
return PyInt_FromLong((long)geteuid());
}
PyObject *self;
PyObject *args;
{
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":getgid"))
return NULL;
return PyInt_FromLong((long)getgid());
}
PyObject *self;
PyObject *args;
{
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":getpid"))
return NULL;
return PyInt_FromLong((long)getpid());
}
PyObject *self;
PyObject *args;
{
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":getpgrp"))
return NULL;
#ifdef GETPGRP_HAVE_ARG
return PyInt_FromLong((long)getpgrp(0));
PyObject *self;
PyObject *args;
{
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":setpgrp"))
return NULL;
#ifdef SETPGRP_HAVE_ARG
if (setpgrp(0, 0) < 0)
PyObject *self;
PyObject *args;
{
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":getppid"))
return NULL;
return PyInt_FromLong((long)getppid());
}
PyObject *self;
PyObject *args;
{
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":getuid"))
return NULL;
return PyInt_FromLong((long)getuid());
}
PyObject *args;
{
int pid, sig;
- if (!PyArg_Parse(args, "(ii)", &pid, &sig))
+ if (!PyArg_ParseTuple(args, "ii:kill", &pid, &sig))
return NULL;
#if defined(PYOS_OS2)
if (sig == XCPT_SIGNAL_INTR || sig == XCPT_SIGNAL_BREAK) {
PyObject *args;
{
int op;
- if (!PyArg_Parse(args, "i", &op))
+ if (!PyArg_ParseTuple(args, "i:plock", &op))
return NULL;
if (plock(op) == -1)
return posix_error();
int err, bufsize = -1;
FILE *fp;
PyObject *f;
- if (!PyArg_ParseTuple(args, "s|si", &name, &mode, &bufsize))
+ if (!PyArg_ParseTuple(args, "s|si:popen", &name, &mode, &bufsize))
return NULL;
Py_BEGIN_ALLOW_THREADS
fp = popen(name, mode, (bufsize > 0) ? bufsize : 4096, &err);
int bufsize = -1;
FILE *fp;
PyObject *f;
- if (!PyArg_ParseTuple(args, "s|si", &name, &mode, &bufsize))
+ if (!PyArg_ParseTuple(args, "s|si:popen", &name, &mode, &bufsize))
return NULL;
Py_BEGIN_ALLOW_THREADS
fp = popen(name, mode);
PyObject *args;
{
int uid;
- if (!PyArg_Parse(args, "i", &uid))
+ if (!PyArg_ParseTuple(args, "i:setuid", &uid))
return NULL;
if (setuid(uid) < 0)
return posix_error();
PyObject *args;
{
int gid;
- if (!PyArg_Parse(args, "i", &gid))
+ if (!PyArg_ParseTuple(args, "i:setgid", &gid))
return NULL;
if (setgid(gid) < 0)
return posix_error();
#endif
status_i = 0;
- if (!PyArg_Parse(args, "(ii)", &pid, &options))
+ if (!PyArg_ParseTuple(args, "ii:waitpid", &pid, &options))
return NULL;
Py_BEGIN_ALLOW_THREADS
#ifdef NeXT
PyObject *self;
PyObject *args;
{
- int pid, sts;
+ int pid;
#ifdef UNION_WAIT
union wait status;
#define status_i (status.w_status)
int status;
#define status_i status
#endif
+ if (!PyArg_ParseTuple(args, ":wait"))
+ return NULL;
status_i = 0;
Py_BEGIN_ALLOW_THREADS
pid = wait(&status);
return posix_error();
else
return Py_BuildValue("ii", pid, status_i);
+#undef status_i
}
#endif
PyObject *args;
{
#ifdef HAVE_LSTAT
- return posix_do_stat(self, args, lstat);
+ return posix_do_stat(self, args, "s:lstat", lstat);
#else /* !HAVE_LSTAT */
- return posix_do_stat(self, args, stat);
+ return posix_do_stat(self, args, "s:lstat", stat);
#endif /* !HAVE_LSTAT */
}
char buf[MAXPATHLEN];
char *path;
int n;
- if (!PyArg_Parse(args, "s", &path))
+ if (!PyArg_ParseTuple(args, "s:readlink", &path))
return NULL;
Py_BEGIN_ALLOW_THREADS
n = readlink(path, buf, (int) sizeof buf);
PyObject *self;
PyObject *args;
{
- return posix_2str(args, symlink);
+ return posix_2str(args, "ss:symlink", symlink);
}
#endif /* HAVE_SYMLINK */
PyObject *self;
PyObject *args;
{
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":times"))
return NULL;
/* Currently Only Uptime is Provided -- Others Later */
{
struct tms t;
clock_t c;
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":times"))
return NULL;
errno = 0;
c = times(&t);
{
FILETIME create, exit, kernel, user;
HANDLE hProc;
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":times"))
return NULL;
hProc = GetCurrentProcess();
GetProcessTimes(hProc, &create, &exit, &kernel, &user);
PyObject *self;
PyObject *args;
{
- if (!PyArg_NoArgs(args))
+ if (!PyArg_ParseTuple(args, ":setsid"))
return NULL;
if (setsid() < 0)
return posix_error();
PyObject *args;
{
int pid, pgrp;
- if (!PyArg_Parse(args, "(ii)", &pid, &pgrp))
+ if (!PyArg_ParseTuple(args, "ii:setpgid", &pid, &pgrp))
return NULL;
if (setpgid(pid, pgrp) < 0)
return posix_error();
PyObject *args;
{
int fd, pgid;
- if (!PyArg_Parse(args, "i", &fd))
+ if (!PyArg_ParseTuple(args, "i:tcgetpgrp", &fd))
return NULL;
pgid = tcgetpgrp(fd);
if (pgid < 0)
PyObject *args;
{
int fd, pgid;
- if (!PyArg_Parse(args, "(ii)", &fd, &pgid))
+ if (!PyArg_ParseTuple(args, "ii:tcsetpgrp", &fd, &pgid))
return NULL;
if (tcsetpgrp(fd, pgid) < 0)
return posix_error();
PyObject *args;
{
int fd, res;
- if (!PyArg_Parse(args, "i", &fd))
+ if (!PyArg_ParseTuple(args, "i:close", &fd))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = close(fd);
PyObject *args;
{
int fd;
- if (!PyArg_Parse(args, "i", &fd))
+ if (!PyArg_ParseTuple(args, "i:dup", &fd))
return NULL;
Py_BEGIN_ALLOW_THREADS
fd = dup(fd);
PyObject *args;
{
int fd, fd2, res;
- if (!PyArg_Parse(args, "(ii)", &fd, &fd2))
+ if (!PyArg_ParseTuple(args, "ii:dup2", &fd, &fd2))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = dup2(fd, fd2);
int fd, how;
off_t pos, res;
PyObject *posobj;
- if (!PyArg_Parse(args, "(iOi)", &fd, &posobj, &how))
+ if (!PyArg_ParseTuple(args, "iOi:lseek", &fd, &posobj, &how))
return NULL;
#ifdef SEEK_SET
/* Turn 0, 1, 2 into SEEK_{SET,CUR,END} */
{
int fd, size, n;
PyObject *buffer;
- if (!PyArg_Parse(args, "(ii)", &fd, &size))
+ if (!PyArg_ParseTuple(args, "ii:read", &fd, &size))
return NULL;
buffer = PyString_FromStringAndSize((char *)NULL, size);
if (buffer == NULL)
{
int fd, size;
char *buffer;
- if (!PyArg_Parse(args, "(is#)", &fd, &buffer, &size))
+ if (!PyArg_ParseTuple(args, "is#:write", &fd, &buffer, &size))
return NULL;
Py_BEGIN_ALLOW_THREADS
size = write(fd, buffer, size);
int fd;
struct stat st;
int res;
- if (!PyArg_Parse(args, "i", &fd))
+ if (!PyArg_ParseTuple(args, "i:fstat", &fd))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = fstat(fd, &st);
HFILE read, write;
APIRET rc;
- if (!PyArg_Parse(args, ""))
+ if (!PyArg_ParseTuple(args, ":pipe"))
return NULL;
Py_BEGIN_ALLOW_THREADS
#if !defined(MS_WIN32)
int fds[2];
int res;
- if (!PyArg_Parse(args, ""))
+ if (!PyArg_ParseTuple(args, ":pipe"))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = pipe(fds);
HANDLE read, write;
int read_fd, write_fd;
BOOL ok;
- if (!PyArg_Parse(args, ""))
+ if (!PyArg_ParseTuple(args, ":pipe"))
return NULL;
Py_BEGIN_ALLOW_THREADS
ok = CreatePipe(&read, &write, NULL, 0);
char *file;
int mode = 0666;
int res;
- if (!PyArg_ParseTuple(args, "s|i", &file, &mode))
+ if (!PyArg_ParseTuple(args, "s|i:mkfifo", &file, &mode))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = mkfifo(file, mode);
int res;
PyObject *lenobj;
- if (!PyArg_Parse(args, "(iO)", &fd, &lenobj))
+ if (!PyArg_ParseTuple(args, "iO:ftruncate", &fd, &lenobj))
return NULL;
#if !defined(HAVE_LARGEFILE_SUPPORT)
char *new;
PyObject *newstr;
- if (!PyArg_ParseTuple(args, "ss", &s1, &s2))
+ if (!PyArg_ParseTuple(args, "ss:putenv", &s1, &s2))
return NULL;
#if defined(PYOS_OS2)
{
int code;
char *message;
- if (!PyArg_ParseTuple(args, "i", &code))
+ if (!PyArg_ParseTuple(args, "i:strerror", &code))
return NULL;
message = strerror(code);
if (message == NULL) {
#endif
status_i = 0;
- if (!PyArg_Parse(args, "i", &status_i))
+ if (!PyArg_ParseTuple(args, "i:WIFSTOPPED", &status_i))
{
return NULL;
}
return Py_BuildValue("i", WIFSTOPPED(status));
+#undef status_i
}
#endif /* WIFSTOPPED */
#endif
status_i = 0;
- if (!PyArg_Parse(args, "i", &status_i))
+ if (!PyArg_ParseTuple(args, "i:WIFSIGNALED", &status_i))
{
return NULL;
}
return Py_BuildValue("i", WIFSIGNALED(status));
+#undef status_i
}
#endif /* WIFSIGNALED */
#endif
status_i = 0;
- if (!PyArg_Parse(args, "i", &status_i))
+ if (!PyArg_ParseTuple(args, "i:WIFEXITED", &status_i))
{
return NULL;
}
return Py_BuildValue("i", WIFEXITED(status));
+#undef status_i
}
#endif /* WIFEXITED */
#endif
status_i = 0;
- if (!PyArg_Parse(args, "i", &status_i))
+ if (!PyArg_ParseTuple(args, "i:WEXITSTATUS", &status_i))
{
return NULL;
}
return Py_BuildValue("i", WEXITSTATUS(status));
+#undef status_i
}
#endif /* WEXITSTATUS */
#endif
status_i = 0;
- if (!PyArg_Parse(args, "i", &status_i))
+ if (!PyArg_ParseTuple(args, "i:WTERMSIG", &status_i))
{
return NULL;
}
return Py_BuildValue("i", WTERMSIG(status));
+#undef status_i
}
#endif /* WTERMSIG */
#endif
status_i = 0;
- if (!PyArg_Parse(args, "i", &status_i))
+ if (!PyArg_ParseTuple(args, "i:WSTOPSIG", &status_i))
{
return NULL;
}
return Py_BuildValue("i", WSTOPSIG(status));
+#undef status_i
}
#endif /* WSTOPSIG */
{
int fd, res;
struct statvfs st;
- if (!PyArg_ParseTuple(args, "i", &fd))
+ if (!PyArg_ParseTuple(args, "i:fstatvfs", &fd))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = fstatvfs(fd, &st);
char *path;
int res;
struct statvfs st;
- if (!PyArg_ParseTuple(args, "s", &path))
+ if (!PyArg_ParseTuple(args, "s:statvfs", &path))
return NULL;
Py_BEGIN_ALLOW_THREADS
res = statvfs(path, &st);
#endif /* HAVE_STATVFS */
+#ifdef HAVE_TEMPNAM
+static char posix_tempnam__doc__[] = "\
+tempnam([dir[, prefix]]) -> string\n\
+Return a unique name for a temporary file.\n\
+The directory and a short may be specified as strings; they may be omitted\n\
+or None if not needed.";
+
+static PyObject *
+posix_tempnam(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ PyObject *result = NULL;
+ char *dir = NULL;
+ char *pfx = NULL;
+ char *name;
+
+ if (!PyArg_ParseTuple(args, "|zz:tempnam", &dir, &pfx))
+ return NULL;
+ name = tempnam(dir, pfx);
+ if (name == NULL)
+ return PyErr_NoMemory();
+ result = PyString_FromString(name);
+ free(name);
+ return result;
+}
+#endif
+
+
+#ifdef HAVE_TMPFILE
+static char posix_tmpfile__doc__[] = "\
+tmpfile() -> file object\n\
+Create a temporary file with no directory entries.";
+
+static PyObject *
+posix_tmpfile(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ FILE *fp;
+
+ if (!PyArg_ParseTuple(args, ":tmpfile"))
+ return NULL;
+ fp = tmpfile();
+ if (fp == NULL)
+ return posix_error();
+ return PyFile_FromFile(fp, "<tmpfile>", "w+", fclose);
+}
+#endif
+
+
+#ifdef HAVE_TMPNAM
+static char posix_tmpnam__doc__[] = "\
+tmpnam() -> string\n\
+Return a unique name for a temporary file.";
+
+static PyObject *
+posix_tmpnam(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char buffer[L_tmpnam];
+ char *name;
+
+ if (!PyArg_ParseTuple(args, ":tmpnam"))
+ return NULL;
+#ifdef HAVE_TMPNAM_R
+ name = tmpnam_r(buffer);
+#else
+ name = tmpnam(buffer);
+#endif
+ if (name == NULL) {
+ PyErr_SetObject(PyExc_OSError,
+ Py_BuildValue("is", 0,
+#ifdef HAVE_TMPNAM_R
+ "unexpected NULL from tmpnam_r"
+#else
+ "unexpected NULL from tmpnam"
+#endif
+ ));
+ return NULL;
+ }
+ return PyString_FromString(buffer);
+}
+#endif
+
+
+static char posix_abort__doc__[] = "\
+abort() -> does not return!\n\
+Abort the interpreter immediately. This 'dumps core' or otherwise fails\n\
+in the hardest way possible on the hosting operating system.";
+
+static PyObject *
+posix_abort(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ if (!PyArg_ParseTuple(args, ":abort"))
+ return NULL;
+ abort();
+ /*NOTREACHED*/
+ Py_FatalError("abort() called from Python code didn't abort!");
+ return NULL;
+}
+
+
static PyMethodDef posix_methods[] = {
- {"access", posix_access, 0, posix_access__doc__},
+ {"access", posix_access, METH_VARARGS, posix_access__doc__},
#ifdef HAVE_TTYNAME
- {"ttyname", posix_ttyname, 0, posix_ttyname__doc__},
+ {"ttyname", posix_ttyname, METH_VARARGS, posix_ttyname__doc__},
#endif
- {"chdir", posix_chdir, 0, posix_chdir__doc__},
- {"chmod", posix_chmod, 0, posix_chmod__doc__},
+ {"chdir", posix_chdir, METH_VARARGS, posix_chdir__doc__},
+ {"chmod", posix_chmod, METH_VARARGS, posix_chmod__doc__},
#ifdef HAVE_CHOWN
- {"chown", posix_chown, 0, posix_chown__doc__},
+ {"chown", posix_chown, METH_VARARGS, posix_chown__doc__},
#endif /* HAVE_CHOWN */
+#ifdef HAVE_CTERMID
+ {"ctermid", posix_ctermid, METH_VARARGS, posix_ctermid__doc__},
+#endif
#ifdef HAVE_GETCWD
- {"getcwd", posix_getcwd, 0, posix_getcwd__doc__},
+ {"getcwd", posix_getcwd, METH_VARARGS, posix_getcwd__doc__},
#endif
#ifdef HAVE_LINK
- {"link", posix_link, 0, posix_link__doc__},
+ {"link", posix_link, METH_VARARGS, posix_link__doc__},
#endif /* HAVE_LINK */
- {"listdir", posix_listdir, 0, posix_listdir__doc__},
- {"lstat", posix_lstat, 0, posix_lstat__doc__},
- {"mkdir", posix_mkdir, 1, 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, 0, posix_nice__doc__},
+ {"nice", posix_nice, METH_VARARGS, posix_nice__doc__},
#endif /* HAVE_NICE */
#ifdef HAVE_READLINK
- {"readlink", posix_readlink, 0, posix_readlink__doc__},
+ {"readlink", posix_readlink, METH_VARARGS, posix_readlink__doc__},
#endif /* HAVE_READLINK */
- {"rename", posix_rename, 0, posix_rename__doc__},
- {"rmdir", posix_rmdir, 0, posix_rmdir__doc__},
- {"stat", posix_stat, 0, posix_stat__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__},
#ifdef HAVE_SYMLINK
- {"symlink", posix_symlink, 0, posix_symlink__doc__},
+ {"symlink", posix_symlink, METH_VARARGS, posix_symlink__doc__},
#endif /* HAVE_SYMLINK */
#ifdef HAVE_SYSTEM
- {"system", posix_system, 0, posix_system__doc__},
+ {"system", posix_system, METH_VARARGS, posix_system__doc__},
#endif
- {"umask", posix_umask, 0, posix_umask__doc__},
+ {"umask", posix_umask, METH_VARARGS, posix_umask__doc__},
#ifdef HAVE_UNAME
- {"uname", posix_uname, 0, posix_uname__doc__},
+ {"uname", posix_uname, METH_VARARGS, posix_uname__doc__},
#endif /* HAVE_UNAME */
- {"unlink", posix_unlink, 0, posix_unlink__doc__},
- {"remove", posix_unlink, 0, posix_remove__doc__},
- {"utime", posix_utime, 0, 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, 0, posix_times__doc__},
+ {"times", posix_times, METH_VARARGS, posix_times__doc__},
#endif /* HAVE_TIMES */
- {"_exit", posix__exit, 0, posix__exit__doc__},
+ {"_exit", posix__exit, METH_VARARGS, posix__exit__doc__},
#ifdef HAVE_EXECV
- {"execv", posix_execv, 0, posix_execv__doc__},
- {"execve", posix_execve, 0, 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, 0, posix_spawnv__doc__},
- {"spawnve", posix_spawnve, 0, posix_spawnve__doc__},
+ {"spawnv", posix_spawnv, METH_VARARGS, posix_spawnv__doc__},
+ {"spawnve", posix_spawnve, METH_VARARGS, posix_spawnve__doc__},
#endif /* HAVE_SPAWNV */
#ifdef HAVE_FORK
- {"fork", posix_fork, 0, posix_fork__doc__},
+ {"fork", posix_fork, METH_VARARGS, posix_fork__doc__},
#endif /* HAVE_FORK */
#ifdef HAVE_GETEGID
- {"getegid", posix_getegid, 0, posix_getegid__doc__},
+ {"getegid", posix_getegid, METH_VARARGS, posix_getegid__doc__},
#endif /* HAVE_GETEGID */
#ifdef HAVE_GETEUID
- {"geteuid", posix_geteuid, 0, posix_geteuid__doc__},
+ {"geteuid", posix_geteuid, METH_VARARGS, posix_geteuid__doc__},
#endif /* HAVE_GETEUID */
#ifdef HAVE_GETGID
- {"getgid", posix_getgid, 0, posix_getgid__doc__},
+ {"getgid", posix_getgid, METH_VARARGS, posix_getgid__doc__},
#endif /* HAVE_GETGID */
- {"getpid", posix_getpid, 0, posix_getpid__doc__},
+ {"getpid", posix_getpid, METH_VARARGS, posix_getpid__doc__},
#ifdef HAVE_GETPGRP
- {"getpgrp", posix_getpgrp, 0, posix_getpgrp__doc__},
+ {"getpgrp", posix_getpgrp, METH_VARARGS, posix_getpgrp__doc__},
#endif /* HAVE_GETPGRP */
#ifdef HAVE_GETPPID
- {"getppid", posix_getppid, 0, posix_getppid__doc__},
+ {"getppid", posix_getppid, METH_VARARGS, posix_getppid__doc__},
#endif /* HAVE_GETPPID */
#ifdef HAVE_GETUID
- {"getuid", posix_getuid, 0, posix_getuid__doc__},
+ {"getuid", posix_getuid, METH_VARARGS, posix_getuid__doc__},
#endif /* HAVE_GETUID */
#ifdef HAVE_KILL
- {"kill", posix_kill, 0, posix_kill__doc__},
+ {"kill", posix_kill, METH_VARARGS, posix_kill__doc__},
#endif /* HAVE_KILL */
#ifdef HAVE_PLOCK
- {"plock", posix_plock, 0, posix_plock__doc__},
+ {"plock", posix_plock, METH_VARARGS, posix_plock__doc__},
#endif /* HAVE_PLOCK */
#ifdef HAVE_POPEN
- {"popen", posix_popen, 1, posix_popen__doc__},
+ {"popen", posix_popen, METH_VARARGS, posix_popen__doc__},
#endif /* HAVE_POPEN */
#ifdef HAVE_SETUID
- {"setuid", posix_setuid, 0, posix_setuid__doc__},
+ {"setuid", posix_setuid, METH_VARARGS, posix_setuid__doc__},
#endif /* HAVE_SETUID */
#ifdef HAVE_SETGID
- {"setgid", posix_setgid, 0, posix_setgid__doc__},
+ {"setgid", posix_setgid, METH_VARARGS, posix_setgid__doc__},
#endif /* HAVE_SETGID */
#ifdef HAVE_SETPGRP
- {"setpgrp", posix_setpgrp, 0, posix_setpgrp__doc__},
+ {"setpgrp", posix_setpgrp, METH_VARARGS, posix_setpgrp__doc__},
#endif /* HAVE_SETPGRP */
#ifdef HAVE_WAIT
- {"wait", posix_wait, 0, posix_wait__doc__},
+ {"wait", posix_wait, METH_VARARGS, posix_wait__doc__},
#endif /* HAVE_WAIT */
#ifdef HAVE_WAITPID
- {"waitpid", posix_waitpid, 0, posix_waitpid__doc__},
+ {"waitpid", posix_waitpid, METH_VARARGS, posix_waitpid__doc__},
#endif /* HAVE_WAITPID */
#ifdef HAVE_SETSID
- {"setsid", posix_setsid, 0, posix_setsid__doc__},
+ {"setsid", posix_setsid, METH_VARARGS, posix_setsid__doc__},
#endif /* HAVE_SETSID */
#ifdef HAVE_SETPGID
- {"setpgid", posix_setpgid, 0, posix_setpgid__doc__},
+ {"setpgid", posix_setpgid, METH_VARARGS, posix_setpgid__doc__},
#endif /* HAVE_SETPGID */
#ifdef HAVE_TCGETPGRP
- {"tcgetpgrp", posix_tcgetpgrp, 0, posix_tcgetpgrp__doc__},
+ {"tcgetpgrp", posix_tcgetpgrp, METH_VARARGS, posix_tcgetpgrp__doc__},
#endif /* HAVE_TCGETPGRP */
#ifdef HAVE_TCSETPGRP
- {"tcsetpgrp", posix_tcsetpgrp, 0, posix_tcsetpgrp__doc__},
+ {"tcsetpgrp", posix_tcsetpgrp, METH_VARARGS, posix_tcsetpgrp__doc__},
#endif /* HAVE_TCSETPGRP */
- {"open", posix_open, 1, posix_open__doc__},
- {"close", posix_close, 0, posix_close__doc__},
- {"dup", posix_dup, 0, posix_dup__doc__},
- {"dup2", posix_dup2, 0, posix_dup2__doc__},
- {"lseek", posix_lseek, 0, posix_lseek__doc__},
- {"read", posix_read, 0, posix_read__doc__},
- {"write", posix_write, 0, posix_write__doc__},
- {"fstat", posix_fstat, 0, posix_fstat__doc__},
- {"fdopen", posix_fdopen, 1, posix_fdopen__doc__},
+ {"open", posix_open, METH_VARARGS, posix_open__doc__},
+ {"close", posix_close, METH_VARARGS, posix_close__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__},
+ {"fdopen", posix_fdopen, METH_VARARGS, posix_fdopen__doc__},
#ifdef HAVE_PIPE
- {"pipe", posix_pipe, 0, posix_pipe__doc__},
+ {"pipe", posix_pipe, METH_VARARGS, posix_pipe__doc__},
#endif
#ifdef HAVE_MKFIFO
- {"mkfifo", posix_mkfifo, 1, posix_mkfifo__doc__},
+ {"mkfifo", posix_mkfifo, METH_VARARGS, posix_mkfifo__doc__},
#endif
#ifdef HAVE_FTRUNCATE
- {"ftruncate", posix_ftruncate, 1, posix_ftruncate__doc__},
+ {"ftruncate", posix_ftruncate, METH_VARARGS, posix_ftruncate__doc__},
#endif
#ifdef HAVE_PUTENV
- {"putenv", posix_putenv, 1, posix_putenv__doc__},
+ {"putenv", posix_putenv, METH_VARARGS, posix_putenv__doc__},
#endif
#ifdef HAVE_STRERROR
- {"strerror", posix_strerror, 1, posix_strerror__doc__},
+ {"strerror", posix_strerror, METH_VARARGS, posix_strerror__doc__},
#endif
#ifdef HAVE_FSYNC
- {"fsync", posix_fsync, 0, posix_fsync__doc__},
+ {"fsync", posix_fsync, METH_VARARGS, posix_fsync__doc__},
#endif
#ifdef HAVE_FDATASYNC
- {"fdatasync", posix_fdatasync, 0, posix_fdatasync__doc__},
+ {"fdatasync", posix_fdatasync, METH_VARARGS, posix_fdatasync__doc__},
#endif
#ifdef HAVE_SYS_WAIT_H
#ifdef WIFSTOPPED
- {"WIFSTOPPED", posix_WIFSTOPPED, 0, posix_WIFSTOPPED__doc__},
+ {"WIFSTOPPED", posix_WIFSTOPPED, METH_VARARGS, posix_WIFSTOPPED__doc__},
#endif /* WIFSTOPPED */
#ifdef WIFSIGNALED
- {"WIFSIGNALED", posix_WIFSIGNALED, 0, posix_WIFSIGNALED__doc__},
+ {"WIFSIGNALED", posix_WIFSIGNALED, METH_VARARGS, posix_WIFSIGNALED__doc__},
#endif /* WIFSIGNALED */
#ifdef WIFEXITED
- {"WIFEXITED", posix_WIFEXITED, 0, posix_WIFEXITED__doc__},
+ {"WIFEXITED", posix_WIFEXITED, METH_VARARGS, posix_WIFEXITED__doc__},
#endif /* WIFEXITED */
#ifdef WEXITSTATUS
- {"WEXITSTATUS", posix_WEXITSTATUS, 0, posix_WEXITSTATUS__doc__},
+ {"WEXITSTATUS", posix_WEXITSTATUS, METH_VARARGS, posix_WEXITSTATUS__doc__},
#endif /* WEXITSTATUS */
#ifdef WTERMSIG
- {"WTERMSIG", posix_WTERMSIG, 0, posix_WTERMSIG__doc__},
+ {"WTERMSIG", posix_WTERMSIG, METH_VARARGS, posix_WTERMSIG__doc__},
#endif /* WTERMSIG */
#ifdef WSTOPSIG
- {"WSTOPSIG", posix_WSTOPSIG, 0, posix_WSTOPSIG__doc__},
+ {"WSTOPSIG", posix_WSTOPSIG, METH_VARARGS, posix_WSTOPSIG__doc__},
#endif /* WSTOPSIG */
#endif /* HAVE_SYS_WAIT_H */
#ifdef HAVE_FSTATVFS
- {"fstatvfs", posix_fstatvfs, 1, posix_fstatvfs__doc__},
+ {"fstatvfs", posix_fstatvfs, METH_VARARGS, posix_fstatvfs__doc__},
#endif
#ifdef HAVE_STATVFS
- {"statvfs", posix_statvfs, 1, posix_statvfs__doc__},
+ {"statvfs", posix_statvfs, METH_VARARGS, posix_statvfs__doc__},
+#endif
+#ifdef HAVE_TMPNAM
+ {"tmpfile", posix_tmpfile, METH_VARARGS, posix_tmpfile__doc__},
#endif
+#ifdef HAVE_TEMPNAM
+ {"tempnam", posix_tempnam, METH_VARARGS, posix_tempnam__doc__},
+#endif
+#ifdef HAVE_TMPNAM
+ {"tmpnam", posix_tmpnam, METH_VARARGS, posix_tmpnam__doc__},
+#endif
+ {"abort", posix_abort, METH_VARARGS, posix_abort__doc__},
{NULL, NULL} /* Sentinel */
};
#ifdef X_OK
if (ins(d, "X_OK", (long)X_OK)) return -1;
#endif
+#ifdef TMP_MAX
+ if (ins(d, "TMP_MAX", (long)TMP_MAX)) return -1;
+#endif
#ifdef WNOHANG
if (ins(d, "WNOHANG", (long)WNOHANG)) return -1;
#endif
projects / python / commitdiff