static char posix__doc__ [] =

corresponding Unix manual entries for more information on calls.";

#include "Python.h"

#if defined(PYOS_OS2)

#define INCL_DOS

#define INCL_DOSERRORS

#define INCL_DOSPROCESS

#define INCL_NOPMAPI

#include <os2.h>

#include <sys/types.h>

#include <sys/stat.h>

#ifdef HAVE_SYS_WAIT_H

#include <sys/wait.h> /* For WNOHANG */

#ifdef HAVE_SIGNAL_H

#include <signal.h>

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#endif /* HAVE_FCNTL_H */

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif /* HAVE_UNISTD_H */

#if defined(PYCC_VACPP) && defined(PYOS_OS2)

#include <process.h>

#if defined(__WATCOMC__) && !defined(__QNX__) /* Watcom compiler */

#define HAVE_GETCWD 1

#define HAVE_OPENDIR 1

#define HAVE_SYSTEM 1

#if defined(__OS2__)

#define HAVE_EXECV 1

#define HAVE_WAIT 1

#include <process.h>

#ifdef __BORLANDC__ /* Borland compiler */

#define HAVE_EXECV 1

#define HAVE_GETCWD 1

#define HAVE_OPENDIR 1

#define HAVE_PIPE 1

#define HAVE_POPEN 1

#define HAVE_SYSTEM 1

#define HAVE_WAIT 1

#ifdef _MSC_VER /* Microsoft compiler */

#define HAVE_GETCWD 1

#ifdef MS_WIN32

#define HAVE_SPAWNV 1

#define HAVE_EXECV 1

#define HAVE_PIPE 1

#define HAVE_POPEN 1

#define HAVE_SYSTEM 1

#else /* 16-bit Windows */

#endif /* !MS_WIN32 */

#else /* all other compilers */

#define HAVE_EXECV 1

#define HAVE_FORK 1

#if defined(__USLC__) && defined(__SCO_VERSION__) /* SCO UDK Compiler */

#define HAVE_FORK1 1

#define HAVE_GETCWD 1

#define HAVE_GETEGID 1

#define HAVE_GETEUID 1

#define HAVE_GETGID 1

#define HAVE_GETPPID 1

#define HAVE_GETUID 1

#define HAVE_KILL 1

#define HAVE_OPENDIR 1

#define HAVE_PIPE 1

#define HAVE_POPEN 1

#define HAVE_SYSTEM 1

#define HAVE_WAIT 1

#define HAVE_TTYNAME 1

#endif /* _MSC_VER */

#endif /* __BORLANDC__ */

#endif /* ! __WATCOMC__ || __QNX__ */

#endif /* ! __IBMC__ */

#ifndef _MSC_VER

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#if defined(sun) && !defined(__SVR4)

extern int rename(const char *, const char *);

extern int pclose(FILE *);

extern int fclose(FILE *);

extern int fsync(int);

extern int lstat(const char *, struct stat *);

extern int symlink(const char *, const char *);

#ifdef NeXT

#undef HAVE_UNISTD_H

#undef HAVE_UTIME_H

#define HAVE_WAITPID

#define UNION_WAIT /* This should really be checked for by autoconf */

#ifndef HAVE_UNISTD_H

#if defined(PYCC_VACPP)

extern int mkdir(char *);

#if ( defined(__WATCOMC__) || defined(_MSC_VER) ) && !defined(__QNX__)

extern int mkdir(const char *);

extern int mkdir(const char *, mode_t);

#if defined(__IBMC__) || defined(__IBMCPP__)

extern int chdir(char *);

extern int rmdir(char *);

extern int chdir(const char *);

extern int rmdir(const char *);

#ifdef __BORLANDC__

extern int chmod(const char *, int);

extern int chmod(const char *, mode_t);

extern int chown(const char *, uid_t, gid_t);

extern char *getcwd(char *, int);

extern char *strerror(int);

extern int link(const char *, const char *);

extern int rename(const char *, const char *);

extern int stat(const char *, struct stat *);

extern int unlink(const char *);

extern int pclose(FILE *);

#ifdef HAVE_SYMLINK

extern int symlink(const char *, const char *);

#endif /* HAVE_SYMLINK */

#ifdef HAVE_LSTAT

extern int lstat(const char *, struct stat *);

#endif /* HAVE_LSTAT */

#endif /* !HAVE_UNISTD_H */

#endif /* !_MSC_VER */

#ifdef HAVE_UTIME_H

#include <utime.h>

#endif /* HAVE_UTIME_H */

#ifdef HAVE_SYS_UTIME_H

#include <sys/utime.h>

#define HAVE_UTIME_H /* pretend we do for the rest of this file */

#endif /* HAVE_SYS_UTIME_H */

#ifdef HAVE_SYS_TIMES_H

#include <sys/times.h>

#endif /* HAVE_SYS_TIMES_H */

#ifdef HAVE_SYS_PARAM_H

#include <sys/param.h>

#endif /* HAVE_SYS_PARAM_H */

#ifdef HAVE_SYS_UTSNAME_H

#include <sys/utsname.h>

#endif /* HAVE_SYS_UTSNAME_H */

#ifndef MAXPATHLEN

#define MAXPATHLEN 1024

#endif /* MAXPATHLEN */

#ifdef HAVE_DIRENT_H

#include <dirent.h>

#define NAMLEN(dirent) strlen((dirent)->d_name)

#if defined(__WATCOMC__) && !defined(__QNX__)

#include <direct.h>

#define NAMLEN(dirent) strlen((dirent)->d_name)

#define dirent direct

#define NAMLEN(dirent) (dirent)->d_namlen

#ifdef HAVE_SYS_NDIR_H

#include <sys/ndir.h>

#ifdef HAVE_SYS_DIR_H

#include <sys/dir.h>

#ifdef HAVE_NDIR_H

#include <ndir.h>

#ifdef _MSC_VER

#include <direct.h>

#include <io.h>

#include <process.h>

#define WINDOWS_LEAN_AND_MEAN

#include <windows.h>

#ifdef MS_WIN32

#define popen _popen

#define pclose _pclose

#else /* 16-bit Windows */

#include <dos.h>

#include <ctype.h>

#endif /* MS_WIN32 */

#endif /* _MSC_VER */

#if defined(PYCC_VACPP) && defined(PYOS_OS2)

#include <io.h>

#endif /* OS2 */

#ifdef UNION_WAIT

#ifndef WIFEXITED

#define WIFEXITED(u_wait) (!(u_wait).w_termsig && !(u_wait).w_coredump)

#ifndef WEXITSTATUS

#define WEXITSTATUS(u_wait) (WIFEXITED(u_wait)?((u_wait).w_retcode):-1)

#ifndef WTERMSIG

#define WTERMSIG(u_wait) ((u_wait).w_termsig)

#endif /* UNION_WAIT */

#if defined(HAVE_CTERMID_R) && defined(WITH_THREAD)

#define USE_CTERMID_R

#if defined(HAVE_TMPNAM_R) && defined(WITH_THREAD)

#define USE_TMPNAM_R

#undef STAT

#ifdef MS_WIN64

# define STAT _stati64

# define FSTAT _fstati64

# define STRUCT_STAT struct _stati64

# define STAT stat

# define FSTAT fstat

# define STRUCT_STAT struct stat

#if !defined(_MSC_VER) && ( !defined(__WATCOMC__) || defined(__QNX__) )

extern char **environ;

#endif /* !_MSC_VER */

static PyObject *

convertenviron(void)

{

PyObject *d;

char **e;

d = PyDict_New();

if (d == NULL)

return NULL;

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 = PyString_FromStringAndSize(*e, (int)(p-*e));

if (k == NULL) {

PyErr_Clear();

continue;

}

v = PyString_FromString(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);

}

#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 = PyString_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 = PyString_FromString(buffer);

PyDict_SetItemString(d, "ENDLIBPATH", v);

Py_DECREF(v);

}

}

return d;

}

static PyObject *

posix_error(void)

{

return PyErr_SetFromErrno(PyExc_OSError);

}

static PyObject *

posix_error_with_filename(char* name)

{

return PyErr_SetFromErrnoWithFilename(PyExc_OSError, name);

}

#ifdef MS_WIN32

static PyObject *

win32_error(char* function, char* filename)

{

/* XXX We should pass the function name along in the future.

errno = GetLastError();

if (filename)

return PyErr_SetFromWindowsErrWithFilename(errno, filename);

else

return PyErr_SetFromWindowsErr(errno);

}

#if defined(PYOS_OS2)

static void

os2_formatmsg(char *msgbuf, int msglen, char *reason)

{

msgbuf[msglen] = '\0'; /* OS/2 Doesn't Guarantee a Terminator */

if (strlen(msgbuf) > 0) { /* If Non-Empty Msg, Trim CRLF */

char *lastc = &msgbuf[ strlen(msgbuf)-1 ];

while (lastc > msgbuf && isspace(*lastc))

*lastc-- = '\0'; /* Trim Trailing Whitespace (CRLF) */

}

/* Add Optional Reason Text */

if (reason) {

strcat(msgbuf, " : ");

strcat(msgbuf, reason);

}

}

static char *

os2_strerror(char *msgbuf, int msgbuflen, int errorcode, char *reason)

{

APIRET rc;

ULONG msglen;

/* Retrieve Kernel-Related Error Message from OSO001.MSG File */

Py_BEGIN_ALLOW_THREADS

rc = DosGetMessage(NULL, 0, msgbuf, msgbuflen,

errorcode, "oso001.msg", &msglen);

Py_END_ALLOW_THREADS

if (rc == NO_ERROR)

os2_formatmsg(msgbuf, msglen, reason);

else

sprintf(msgbuf, "unknown OS error #%d", errorcode);

return msgbuf;

}

static PyObject * os2_error(int code)

{

char text[1024];

PyObject *v;

os2_strerror(text, sizeof(text), code, "");

v = Py_BuildValue("(is)", code, text);

if (v != NULL) {

PyErr_SetObject(PyExc_OSError, v);

Py_DECREF(v);

}

return NULL; /* Signal to Python that an Exception is Pending */

}

#endif /* OS2 */

static PyObject *

posix_int(PyObject *args, char *format, int (*func)(int))

{

int fd;

int res;

if (!PyArg_ParseTuple(args, format, &fd))

return NULL;

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*))

{

char *path1;

int res;

if (!PyArg_ParseTuple(args, format, &path1))

return NULL;

Py_BEGIN_ALLOW_THREADS

res = (*func)(path1);

Py_END_ALLOW_THREADS

if (res < 0)

return posix_error_with_filename(path1);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

posix_2str(PyObject *args, char *format,

int (*func)(const char *, const char *))

{

char *path1, *path2;

int res;

if (!PyArg_ParseTuple(args, format, &path1, &path2))

return NULL;

Py_BEGIN_ALLOW_THREADS

res = (*func)(path1, path2);

Py_END_ALLOW_THREADS

if (res != 0)

/* XXX how to report both path1 and path2??? */

return posix_error();

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

_pystat_fromstructstat(STRUCT_STAT st)

{

PyObject *v = PyTuple_New(10);

if (v == NULL)

return NULL;

PyTuple_SetItem(v, 0, PyInt_FromLong((long)st.st_mode));

#ifdef HAVE_LARGEFILE_SUPPORT

PyTuple_SetItem(v, 1, PyLong_FromLongLong((LONG_LONG)st.st_ino));

PyTuple_SetItem(v, 1, PyInt_FromLong((long)st.st_ino));

#if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS)

PyTuple_SetItem(v, 2, PyLong_FromLongLong((LONG_LONG)st.st_dev));

PyTuple_SetItem(v, 2, PyInt_FromLong((long)st.st_dev));

PyTuple_SetItem(v, 3, PyInt_FromLong((long)st.st_nlink));

PyTuple_SetItem(v, 4, PyInt_FromLong((long)st.st_uid));

PyTuple_SetItem(v, 5, PyInt_FromLong((long)st.st_gid));

#ifdef HAVE_LARGEFILE_SUPPORT

PyTuple_SetItem(v, 6, PyLong_FromLongLong((LONG_LONG)st.st_size));

PyTuple_SetItem(v, 6, PyInt_FromLong(st.st_size));

#if SIZEOF_TIME_T > SIZEOF_LONG

PyTuple_SetItem(v, 7, PyLong_FromLongLong((LONG_LONG)st.st_atime));

PyTuple_SetItem(v, 8, PyLong_FromLongLong((LONG_LONG)st.st_mtime));

PyTuple_SetItem(v, 9, PyLong_FromLongLong((LONG_LONG)st.st_ctime));

PyTuple_SetItem(v, 7, PyInt_FromLong((long)st.st_atime));

PyTuple_SetItem(v, 8, PyInt_FromLong((long)st.st_mtime));

PyTuple_SetItem(v, 9, PyInt_FromLong((long)st.st_ctime));

if (PyErr_Occurred()) {

Py_DECREF(v);

return NULL;

}

return v;

}

static PyObject *

posix_do_stat(PyObject *self, PyObject *args, char *format,

int (*statfunc)(const char *, STRUCT_STAT *))

{

STRUCT_STAT st;

char *path;

int res;

#ifdef MS_WIN32

int pathlen;

char pathcopy[MAX_PATH];

#endif /* MS_WIN32 */

if (!PyArg_ParseTuple(args, format, &path))

return NULL;

#ifdef MS_WIN32

pathlen = strlen(path);

/* the library call can blow up if the file name is too long! */

if (pathlen > MAX_PATH) {

errno = ENAMETOOLONG;

return posix_error();

}

if ((pathlen > 0) && (path[pathlen-1] == '\\' || path[pathlen-1] == '/')) {

/* exception for specific or current drive root */

if (!((pathlen == 1) ||

((pathlen == 3) &&

(path[1] == ':') &&

(path[2] == '\\' || path[2] == '/'))))

{

strncpy(pathcopy, path, pathlen);

pathcopy[pathlen-1] = '\0'; /* nuke the trailing backslash */

path = pathcopy;

}

}

#endif /* MS_WIN32 */

Py_BEGIN_ALLOW_THREADS

res = (*statfunc)(path, &st);

Py_END_ALLOW_THREADS

if (res != 0)

return posix_error_with_filename(path);

return _pystat_fromstructstat(st);

}

static char posix_access__doc__[] =

existence, or the inclusive-OR of R_OK, W_OK, and X_OK.";

static PyObject *

posix_access(PyObject *self, PyObject *args)

{

char *path;

int mode;

int res;

if (!PyArg_ParseTuple(args, "si:access", &path, &mode))

return NULL;

Py_BEGIN_ALLOW_THREADS

res = access(path, mode);

Py_END_ALLOW_THREADS

return(PyInt_FromLong(res == 0 ? 1L : 0L));

}

#ifndef F_OK

#define F_OK 0

#ifndef R_OK

#define R_OK 4

#ifndef W_OK

#define W_OK 2

#ifndef X_OK

#define X_OK 1

#ifdef HAVE_TTYNAME

static char posix_ttyname__doc__[] =

Return the name of the terminal device connected to 'fd'.";

static PyObject *

posix_ttyname(PyObject *self, PyObject *args)

{

int id;

char *ret;

if (!PyArg_ParseTuple(args, "i:ttyname", &id))

return NULL;

ret = ttyname(id);

if (ret == NULL)

return(posix_error());

return(PyString_FromString(ret));

}

#ifdef HAVE_CTERMID

static char posix_ctermid__doc__[] =

Return the name of the controlling terminal for this process.";

static PyObject *

posix_ctermid(PyObject *self, PyObject *args)

{

char *ret;

char buffer[L_ctermid];

if (!PyArg_ParseTuple(args, ":ctermid"))

return NULL;

#ifdef USE_CTERMID_R

ret = ctermid_r(buffer);

ret = ctermid(buffer);

if (ret == NULL)

return(posix_error());

return(PyString_FromString(buffer));

}

static char posix_chdir__doc__[] =

Change the current working directory to the specified path.";

static PyObject *

posix_chdir(PyObject *self, PyObject *args)

{

return posix_1str(args, "s:chdir", chdir);

}

static char posix_chmod__doc__[] =

Change the access permissions of a file.";

static PyObject *

posix_chmod(PyObject *self, PyObject *args)

{

char *path;

int i;

int res;

if (!PyArg_ParseTuple(args, "si", &path, &i))

return NULL;

Py_BEGIN_ALLOW_THREADS

res = chmod(path, i);

Py_END_ALLOW_THREADS

if (res < 0)

return posix_error_with_filename(path);

Py_INCREF(Py_None);

return Py_None;

}

#ifdef HAVE_FSYNC

static char posix_fsync__doc__[] =

force write of file with filedescriptor to disk.";

static PyObject *

posix_fsync(PyObject *self, PyObject *args)

{

return posix_int(args, "i:fsync", fsync);

}

#endif /* HAVE_FSYNC */

#ifdef HAVE_FDATASYNC

#ifdef __hpux

extern int fdatasync(int); /* On HP-UX, in libc but not in unistd.h */

static char posix_fdatasync__doc__[] =

does not force update of metadata.";

static PyObject *

posix_fdatasync(PyObject *self, PyObject *args)

{

return posix_int(args, "i:fdatasync", fdatasync);

}

#endif /* HAVE_FDATASYNC */

#ifdef HAVE_CHOWN

static char posix_chown__doc__[] =

Change the owner and group id of path to the numeric uid and gid.";

static PyObject *

posix_chown(PyObject *self, PyObject *args)

{

char *path;

int uid, gid;

int res;

if (!PyArg_ParseTuple(args, "sii:chown", &path, &uid, &gid))

return NULL;

Py_BEGIN_ALLOW_THREADS

res = chown(path, (uid_t) uid, (gid_t) gid);

Py_END_ALLOW_THREADS

if (res < 0)

return posix_error_with_filename(path);

Py_INCREF(Py_None);

return Py_None;

}

#endif /* HAVE_CHOWN */

#ifdef HAVE_GETCWD

static char posix_getcwd__doc__[] =

Return a string representing the current working directory.";

static PyObject *

posix_getcwd(PyObject *self, PyObject *args)

{

char buf[1026];

char *res;

if (!PyArg_ParseTuple(args, ":getcwd"))

return NULL;

Py_BEGIN_ALLOW_THREADS

res = getcwd(buf, sizeof buf);

Py_END_ALLOW_THREADS

if (res == NULL)

return posix_error();

return PyString_FromString(buf);

}

#ifdef HAVE_LINK

static char posix_link__doc__[] =

Create a hard link to a file.";

static PyObject *

posix_link(PyObject *self, PyObject *args)

{

return posix_2str(args, "ss:link", link);

}

#endif /* HAVE_LINK */

static char posix_listdir__doc__[] =

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

#if defined(MS_WIN32) && !defined(HAVE_OPENDIR)

char *name;

int len;

PyObject *d, *v;

HANDLE hFindFile;

WIN32_FIND_DATA FileData;

char namebuf[MAX_PATH+5];

char ch;

if (!PyArg_ParseTuple(args, "t#:listdir", &name, &len))

return NULL;

if (len >= MAX_PATH) {

PyErr_SetString(PyExc_ValueError, "path too long");

return NULL;

}

strcpy(namebuf, name);

ch = namebuf[len-1];

if (ch != '/' && ch != '\\' && ch != ':')

namebuf[len++] = '/';

strcpy(namebuf + len, "*.*");

if ((d = PyList_New(0)) == NULL)

return NULL;

hFindFile = FindFirstFile(namebuf, &FileData);

if (hFindFile == INVALID_HANDLE_VALUE) {

errno = GetLastError();

if (errno == ERROR_FILE_NOT_FOUND)

return PyList_New(0);

return win32_error("FindFirstFile", name);

}

do {

if (FileData.cFileName[0] == '.' &&

(FileData.cFileName[1] == '\0' ||

FileData.cFileName[1] == '.' &&

FileData.cFileName[2] == '\0'))

continue;

v = PyString_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);

} while (FindNextFile(hFindFile, &FileData) == TRUE);

if (FindClose(hFindFile) == FALSE)

return win32_error("FindClose", name);

return d;

#elif defined(_MSC_VER) /* 16-bit Windows */

#ifndef MAX_PATH

#define MAX_PATH 250

char *name, *pt;

int len;

PyObject *d, *v;

char namebuf[MAX_PATH+5];

struct _find_t ep;

if (!PyArg_ParseTuple(args, "t#:listdir", &name, &len))

return NULL;

if (len >= MAX_PATH) {

PyErr_SetString(PyExc_ValueError, "path too long");

return NULL;

}

strcpy(namebuf, name);

for (pt = namebuf; *pt; pt++)

if (*pt == '/')

*pt = '\\';

if (namebuf[len-1] != '\\')

namebuf[len++] = '\\';

strcpy(namebuf + len, "*.*");

if ((d = PyList_New(0)) == NULL)

return NULL;

if (_dos_findfirst(namebuf, _A_RDONLY |

_A_HIDDEN | _A_SYSTEM | _A_SUBDIR, &ep) != 0)

{

errno = ENOENT;

return posix_error_with_filename(name);

}

do {

if (ep.name[0] == '.' &&

(ep.name[1] == '\0' ||

ep.name[1] == '.' &&

ep.name[2] == '\0'))

continue;

strcpy(namebuf, ep.name);

for (pt = namebuf; *pt; pt++)

if (isupper(*pt))

*pt = tolower(*pt);

v = PyString_FromString(namebuf);

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);

} while (_dos_findnext(&ep) == 0);

return d;

#elif defined(PYOS_OS2)

#ifndef MAX_PATH

#define MAX_PATH CCHMAXPATH

char *name, *pt;

int len;

PyObject *d, *v;

char namebuf[MAX_PATH+5];

HDIR hdir = 1;

ULONG srchcnt = 1;

FILEFINDBUF3 ep;

APIRET rc;

if (!PyArg_ParseTuple(args, "t#:listdir", &name, &len))

return NULL;

if (len >= MAX_PATH) {

PyErr_SetString(PyExc_ValueError, "path too long");

return NULL;

}

strcpy(namebuf, name);

for (pt = namebuf; *pt; pt++)

if (*pt == '/')

*pt = '\\';

if (namebuf[len-1] != '\\')

namebuf[len++] = '\\';

strcpy(namebuf + len, "*.*");

if ((d = PyList_New(0)) == NULL)

return NULL;

rc = DosFindFirst(namebuf, /* Wildcard Pattern to Match */

&hdir, /* Handle to Use While Search Directory */

FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,

&ep, sizeof(ep), /* Structure to Receive Directory Entry */

&srchcnt, /* Max and Actual Count of Entries Per Iteration */

FIL_STANDARD); /* Format of Entry (EAs or Not) */

if (rc != NO_ERROR) {

errno = ENOENT;

return posix_error_with_filename(name);

}

if (srchcnt > 0) { /* If Directory is NOT Totally Empty, */

do {

if (ep.achName[0] == '.'

&& (ep.achName[1] == '\0' || ep.achName[1] == '.' && ep.achName[2] == '\0'))

continue; /* Skip Over "." and ".." Names */

strcpy(namebuf, ep.achName);

/* Leave Case of Name Alone -- In Native Form */

/* (Removed Forced Lowercasing Code) */

v = PyString_FromString(namebuf);

if (v == NULL) {

Py_DECREF(d);

d = NULL;

break;

}

if (PyList_Append(d, v) != 0) {

Py_DECREF(v);

Py_DECREF(d);

d = NULL;

break;

}