Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Merged revisions 73603 via svnmerge from 

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r73603 | hirokazu.yamamoto | 2009-06-28 19:23:00 +0900 | 1 line

  Issue #4856: Remove checks for win NT.
........
This commit is contained in:
Hirokazu Yamamoto 2009-06-28 11:07:03 +00:00
parent 95c4601870
commit 892a37aff1
4 changed files with 254 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Misc/NEWS
View File

@ -12,6 +12,8 @@ What's New in Python 3.2 Alpha 1?
Core and Builtins Core and Builtins
----------------- -----------------
- Issue #4856: Remove checks for win NT.
Library Library
------- -------

7
Modules/_io/fileio.c
View File

@ -224,11 +224,8 @@ fileio_init(PyObject *oself, PyObject *args, PyObject *kwds)
} }
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
if (GetVersion() < 0x80000000) { if (PyUnicode_Check(nameobj))
/* On NT, so wide API available */ widename = PyUnicode_AS_UNICODE(nameobj);
if (PyUnicode_Check(nameobj))
widename = PyUnicode_AS_UNICODE(nameobj);
}
if (widename == NULL) if (widename == NULL)
#endif #endif
if (fd < 0) if (fd < 0)

559
Modules/posixmodule.c
View File

@ -759,20 +759,6 @@ posix_fildes(PyObject *fdobj, int (*func)(int))
return Py_None; return Py_None;
} }
#ifdef MS_WINDOWS
static int
unicode_file_names(void)
{
static int canusewide = -1;
if (canusewide == -1) {
/* As per doc for ::GetVersion(), this is the correct test for
the Windows NT family. */
canusewide = (GetVersion() < 0x80000000) ? 1 : 0;
}
return canusewide;
}
#endif
static PyObject * static PyObject *
posix_1str(PyObject *args, char *format, int (*func)(const char*)) posix_1str(PyObject *args, char *format, int (*func)(const char*))
{ {
@ -829,18 +815,17 @@ win32_1str(PyObject* args, char* func,
PyObject *uni; PyObject *uni;
char *ansi; char *ansi;
BOOL result; BOOL result;
if (unicode_file_names()) {
if (!PyArg_ParseTuple(args, wformat, &uni)) if (!PyArg_ParseTuple(args, wformat, &uni))
PyErr_Clear(); PyErr_Clear();
else { else {
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
result = funcW(PyUnicode_AsUnicode(uni)); result = funcW(PyUnicode_AsUnicode(uni));
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (!result) if (!result)
return win32_error_unicode(func, PyUnicode_AsUnicode(uni)); return win32_error_unicode(func, PyUnicode_AsUnicode(uni));
Py_INCREF(Py_None); Py_INCREF(Py_None);
return Py_None; return Py_None;
}
} }
if (!PyArg_ParseTuple(args, format, &ansi)) if (!PyArg_ParseTuple(args, format, &ansi))
return NULL; return NULL;
@ -1003,22 +988,6 @@ attribute_data_to_stat(WIN32_FILE_ATTRIBUTE_DATA *info, struct win32_stat *resul
return 0; return 0;
} }
/* Emulate GetFileAttributesEx[AW] on Windows 95 */
static int checked = 0;
static BOOL (CALLBACK *gfaxa)(LPCSTR, GET_FILEEX_INFO_LEVELS, LPVOID);
static BOOL (CALLBACK *gfaxw)(LPCWSTR, GET_FILEEX_INFO_LEVELS, LPVOID);
static void
check_gfax()
{
HINSTANCE hKernel32;
if (checked)
return;
checked = 1;
hKernel32 = GetModuleHandle("KERNEL32");
*(FARPROC*)&gfaxa = GetProcAddress(hKernel32, "GetFileAttributesExA");
*(FARPROC*)&gfaxw = GetProcAddress(hKernel32, "GetFileAttributesExW");
}
static BOOL static BOOL
attributes_from_dir(LPCSTR pszFile, LPWIN32_FILE_ATTRIBUTE_DATA pfad) attributes_from_dir(LPCSTR pszFile, LPWIN32_FILE_ATTRIBUTE_DATA pfad)
{ {
@ -1065,12 +1034,9 @@ Py_GetFileAttributesExA(LPCSTR pszFile,
/* First try to use the system's implementation, if that is /* First try to use the system's implementation, if that is
available and either succeeds to gives an error other than available and either succeeds to gives an error other than
that it isn't implemented. */ that it isn't implemented. */
check_gfax(); result = GetFileAttributesExA(pszFile, level, pv);
if (gfaxa) { if (result || GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
result = gfaxa(pszFile, level, pv); return result;
if (result || GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
return result;
}
/* It's either not present, or not implemented. /* It's either not present, or not implemented.
Emulate using FindFirstFile. */ Emulate using FindFirstFile. */
if (level != GetFileExInfoStandard) { if (level != GetFileExInfoStandard) {
@ -1095,12 +1061,9 @@ Py_GetFileAttributesExW(LPCWSTR pszFile,
/* First try to use the system's implementation, if that is /* First try to use the system's implementation, if that is
available and either succeeds to gives an error other than available and either succeeds to gives an error other than
that it isn't implemented. */ that it isn't implemented. */
check_gfax(); result = GetFileAttributesExW(pszFile, level, pv);
if (gfaxa) { if (result || GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
result = gfaxw(pszFile, level, pv); return result;
if (result || GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
return result;
}
/* It's either not present, or not implemented. /* It's either not present, or not implemented.
Emulate using FindFirstFile. */ Emulate using FindFirstFile. */
if (level != GetFileExInfoStandard) { if (level != GetFileExInfoStandard) {
@ -1618,27 +1581,23 @@ posix_do_stat(PyObject *self, PyObject *args,
PyObject *result; PyObject *result;
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
/* If on wide-character-capable OS see if argument PyUnicodeObject *po;
is Unicode and if so use wide API. */ if (PyArg_ParseTuple(args, wformat, &po)) {
if (unicode_file_names()) { Py_UNICODE *wpath = PyUnicode_AS_UNICODE(po);
PyUnicodeObject *po;
if (PyArg_ParseTuple(args, wformat, &po)) {
Py_UNICODE *wpath = PyUnicode_AS_UNICODE(po);
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
/* PyUnicode_AS_UNICODE result OK without /* PyUnicode_AS_UNICODE result OK without
thread lock as it is a simple dereference. */ thread lock as it is a simple dereference. */
res = wstatfunc(wpath, &st); res = wstatfunc(wpath, &st);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (res != 0) if (res != 0)
return win32_error_unicode("stat", wpath); return win32_error_unicode("stat", wpath);
return _pystat_fromstructstat(&st); return _pystat_fromstructstat(&st);
}
/* Drop the argument parsing error as narrow strings
are also valid. */
PyErr_Clear();
} }
/* Drop the argument parsing error as narrow strings
are also valid. */
PyErr_Clear();
#endif #endif
if (!PyArg_ParseTuple(args, format, if (!PyArg_ParseTuple(args, format,
@ -1682,23 +1641,21 @@ posix_access(PyObject *self, PyObject *args)
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
DWORD attr; DWORD attr;
if (unicode_file_names()) { PyUnicodeObject *po;
PyUnicodeObject *po; if (PyArg_ParseTuple(args, "Ui:access", &po, &mode)) {
if (PyArg_ParseTuple(args, "Ui:access", &po, &mode)) { Py_BEGIN_ALLOW_THREADS
Py_BEGIN_ALLOW_THREADS /* PyUnicode_AS_UNICODE OK without thread lock as
/* PyUnicode_AS_UNICODE OK without thread lock as it is a simple dereference. */
it is a simple dereference. */ attr = GetFileAttributesW(PyUnicode_AS_UNICODE(po));
attr = GetFileAttributesW(PyUnicode_AS_UNICODE(po)); Py_END_ALLOW_THREADS
Py_END_ALLOW_THREADS goto finish;
goto finish;
}
/* Drop the argument parsing error as narrow strings
are also valid. */
PyErr_Clear();
} }
/* Drop the argument parsing error as narrow strings
are also valid. */
PyErr_Clear();
if (!PyArg_ParseTuple(args, "O&i:access", if (!PyArg_ParseTuple(args, "O&i:access",
PyUnicode_FSConverter, &opath, &mode)) PyUnicode_FSConverter, &opath, &mode))
return 0; return NULL;
path = bytes2str(opath, 1); path = bytes2str(opath, 1);
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
attr = GetFileAttributesA(path); attr = GetFileAttributesA(path);
@ -1839,31 +1796,30 @@ posix_chmod(PyObject *self, PyObject *args)
int res; int res;
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
DWORD attr; DWORD attr;
if (unicode_file_names()) { PyUnicodeObject *po;
PyUnicodeObject *po; if (PyArg_ParseTuple(args, "Ui|:chmod", &po, &i)) {
if (PyArg_ParseTuple(args, "Ui|:chmod", &po, &i)) { Py_BEGIN_ALLOW_THREADS
Py_BEGIN_ALLOW_THREADS attr = GetFileAttributesW(PyUnicode_AS_UNICODE(po));
attr = GetFileAttributesW(PyUnicode_AS_UNICODE(po)); if (attr != 0xFFFFFFFF) {
if (attr != 0xFFFFFFFF) { if (i & _S_IWRITE)
if (i & _S_IWRITE) attr &= ~FILE_ATTRIBUTE_READONLY;
attr &= ~FILE_ATTRIBUTE_READONLY;
else
attr |= FILE_ATTRIBUTE_READONLY;
res = SetFileAttributesW(PyUnicode_AS_UNICODE(po), attr);
}
else else
res = 0; attr |= FILE_ATTRIBUTE_READONLY;
Py_END_ALLOW_THREADS res = SetFileAttributesW(PyUnicode_AS_UNICODE(po), attr);
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 else
are also valid. */ res = 0;
PyErr_Clear(); 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, if (!PyArg_ParseTuple(args, "O&i:chmod", PyUnicode_FSConverter,
&opath, &i)) &opath, &i))
return NULL; return NULL;
@ -2139,7 +2095,7 @@ posix_getcwd(int use_bytes)
char *res; char *res;
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
if (!use_bytes && unicode_file_names()) { if (!use_bytes) {
wchar_t wbuf[1026]; wchar_t wbuf[1026];
wchar_t *wbuf2 = wbuf; wchar_t *wbuf2 = wbuf;
PyObject *resobj; PyObject *resobj;
@ -2243,88 +2199,84 @@ posix_listdir(PyObject *self, PyObject *args)
char *bufptr = namebuf; char *bufptr = namebuf;
Py_ssize_t len = sizeof(namebuf)-5; /* only claim to have space for MAX_PATH */ Py_ssize_t len = sizeof(namebuf)-5; /* only claim to have space for MAX_PATH */
/* If on wide-character-capable OS see if argument PyObject *po;
is Unicode and if so use wide API. */ if (PyArg_ParseTuple(args, "U:listdir", &po)) {
if (unicode_file_names()) { WIN32_FIND_DATAW wFileData;
PyObject *po; Py_UNICODE *wnamebuf;
if (PyArg_ParseTuple(args, "U:listdir", &po)) { /* Overallocate for \\*.*\0 */
WIN32_FIND_DATAW wFileData; len = PyUnicode_GET_SIZE(po);
Py_UNICODE *wnamebuf; wnamebuf = malloc((len + 5) * sizeof(wchar_t));
/* Overallocate for \\*.*\0 */ if (!wnamebuf) {
len = PyUnicode_GET_SIZE(po); PyErr_NoMemory();
wnamebuf = malloc((len + 5) * sizeof(wchar_t)); return NULL;
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 wcscpy(wnamebuf, PyUnicode_AS_UNICODE(po));
are also valid. */ if (len > 0) {
PyErr_Clear(); 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", if (!PyArg_ParseTuple(args, "O&:listdir",
PyUnicode_FSConverter, &opath)) PyUnicode_FSConverter, &opath))
@ -2562,35 +2514,34 @@ posix__getfullpathname(PyObject *self, PyObject *args)
char outbuf[MAX_PATH*2]; char outbuf[MAX_PATH*2];
char *temp; char *temp;
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
if (unicode_file_names()) { PyUnicodeObject *po;
PyUnicodeObject *po; if (PyArg_ParseTuple(args, "U|:_getfullpathname", &po)) {
if (PyArg_ParseTuple(args, "U|:_getfullpathname", &po)) { Py_UNICODE *wpath = PyUnicode_AS_UNICODE(po);
Py_UNICODE *wpath = PyUnicode_AS_UNICODE(po); Py_UNICODE woutbuf[MAX_PATH*2], *woutbufp = woutbuf;
Py_UNICODE woutbuf[MAX_PATH*2], *woutbufp = woutbuf; Py_UNICODE *wtemp;
Py_UNICODE *wtemp; DWORD result;
DWORD result; PyObject *v;
PyObject *v; result = GetFullPathNameW(wpath,
result = GetFullPathNameW(wpath, sizeof(woutbuf)/sizeof(woutbuf[0]),
sizeof(woutbuf)/sizeof(woutbuf[0]), woutbuf, &wtemp);
woutbuf, &wtemp); if (result > sizeof(woutbuf)/sizeof(woutbuf[0])) {
if (result > sizeof(woutbuf)/sizeof(woutbuf[0])) { woutbufp = malloc(result * sizeof(Py_UNICODE));
woutbufp = malloc(result * sizeof(Py_UNICODE)); if (!woutbufp)
if (!woutbufp) return PyErr_NoMemory();
return PyErr_NoMemory(); result = GetFullPathNameW(wpath, result, woutbufp, &wtemp);
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 if (result)
are also valid. */ v = PyUnicode_FromUnicode(woutbufp, wcslen(woutbufp));
PyErr_Clear(); 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 #endif
if (!PyArg_ParseTuple (args, "O&:_getfullpathname", if (!PyArg_ParseTuple (args, "O&:_getfullpathname",
PyUnicode_FSConverter, &opath)) PyUnicode_FSConverter, &opath))
@ -2624,23 +2575,21 @@ posix_mkdir(PyObject *self, PyObject *args)
int mode = 0777; int mode = 0777;
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
if (unicode_file_names()) { PyUnicodeObject *po;
PyUnicodeObject *po; if (PyArg_ParseTuple(args, "U|i:mkdir", &po, &mode)) {
if (PyArg_ParseTuple(args, "U|i:mkdir", &po, &mode)) { Py_BEGIN_ALLOW_THREADS
Py_BEGIN_ALLOW_THREADS /* PyUnicode_AS_UNICODE OK without thread lock as
/* PyUnicode_AS_UNICODE OK without thread lock as it is a simple dereference. */
it is a simple dereference. */ res = CreateDirectoryW(PyUnicode_AS_UNICODE(po), NULL);
res = CreateDirectoryW(PyUnicode_AS_UNICODE(po), NULL); Py_END_ALLOW_THREADS
Py_END_ALLOW_THREADS if (!res)
if (!res) return win32_error_unicode("mkdir", PyUnicode_AS_UNICODE(po));
return win32_error_unicode("mkdir", PyUnicode_AS_UNICODE(po)); Py_INCREF(Py_None);
Py_INCREF(Py_None); return Py_None;
return Py_None;
}
/* Drop the argument parsing error as narrow strings
are also valid. */
PyErr_Clear();
} }
/* Drop the argument parsing error as narrow strings
are also valid. */
PyErr_Clear();
if (!PyArg_ParseTuple(args, "O&|i:mkdir", if (!PyArg_ParseTuple(args, "O&|i:mkdir",
PyUnicode_FSConverter, &opath, &mode)) PyUnicode_FSConverter, &opath, &mode))
return NULL; return NULL;
@ -2733,28 +2682,26 @@ posix_rename(PyObject *self, PyObject *args)
PyObject *o1, *o2; PyObject *o1, *o2;
char *p1, *p2; char *p1, *p2;
BOOL result; BOOL result;
if (unicode_file_names()) { if (!PyArg_ParseTuple(args, "OO:rename", &o1, &o2))
if (!PyArg_ParseTuple(args, "OO:rename", &o1, &o2))
goto error; goto error;
if (!convert_to_unicode(&o1)) if (!convert_to_unicode(&o1))
goto error; goto error;
if (!convert_to_unicode(&o2)) { if (!convert_to_unicode(&o2)) {
Py_DECREF(o1); Py_DECREF(o1);
goto error; 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();
} }
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)) if (!PyArg_ParseTuple(args, "ss:rename", &p1, &p2))
return NULL; return NULL;
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
@ -2940,21 +2887,20 @@ posix_utime(PyObject *self, PyObject *args)
FILETIME atime, mtime; FILETIME atime, mtime;
PyObject *result = NULL; PyObject *result = NULL;
if (unicode_file_names()) { if (PyArg_ParseTuple(args, "UO|:utime", &obwpath, &arg)) {
if (PyArg_ParseTuple(args, "UO|:utime", &obwpath, &arg)) { wpath = PyUnicode_AS_UNICODE(obwpath);
wpath = PyUnicode_AS_UNICODE(obwpath); Py_BEGIN_ALLOW_THREADS
Py_BEGIN_ALLOW_THREADS hFile = CreateFileW(wpath, FILE_WRITE_ATTRIBUTES, 0,
hFile = CreateFileW(wpath, FILE_WRITE_ATTRIBUTES, 0, NULL, OPEN_EXISTING,
NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
FILE_FLAG_BACKUP_SEMANTICS, NULL); Py_END_ALLOW_THREADS
Py_END_ALLOW_THREADS if (hFile == INVALID_HANDLE_VALUE)
if (hFile == INVALID_HANDLE_VALUE) return win32_error_unicode("utime", wpath);
return win32_error_unicode("utime", wpath); } else
} else /* Drop the argument parsing error as narrow strings
/* Drop the argument parsing error as narrow strings are also valid. */
are also valid. */ PyErr_Clear();
PyErr_Clear();
}
if (!wpath) { if (!wpath) {
if (!PyArg_ParseTuple(args, "O&O:utime", if (!PyArg_ParseTuple(args, "O&O:utime",
PyUnicode_FSConverter, &oapath, &arg)) PyUnicode_FSConverter, &oapath, &arg))
@ -4927,22 +4873,20 @@ posix_open(PyObject *self, PyObject *args)
int fd; int fd;
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
if (unicode_file_names()) { PyUnicodeObject *po;
PyUnicodeObject *po; if (PyArg_ParseTuple(args, "Ui|i:mkdir", &po, &flag, &mode)) {
if (PyArg_ParseTuple(args, "Ui|i:mkdir", &po, &flag, &mode)) { Py_BEGIN_ALLOW_THREADS
Py_BEGIN_ALLOW_THREADS /* PyUnicode_AS_UNICODE OK without thread
/* PyUnicode_AS_UNICODE OK without thread lock as it is a simple dereference. */
lock as it is a simple dereference. */ fd = _wopen(PyUnicode_AS_UNICODE(po), flag, mode);
fd = _wopen(PyUnicode_AS_UNICODE(po), flag, mode); Py_END_ALLOW_THREADS
Py_END_ALLOW_THREADS if (fd < 0)
if (fd < 0) return posix_error();
return posix_error(); return PyLong_FromLong((long)fd);
return PyLong_FromLong((long)fd);
}
/* Drop the argument parsing error as narrow strings
are also valid. */
PyErr_Clear();
} }
/* Drop the argument parsing error as narrow strings
are also valid. */
PyErr_Clear();
#endif #endif
if (!PyArg_ParseTuple(args, "O&i|i", if (!PyArg_ParseTuple(args, "O&i|i",
@ -6816,40 +6760,37 @@ win32_startfile(PyObject *self, PyObject *args)
char *operation = NULL; char *operation = NULL;
HINSTANCE rc; HINSTANCE rc;
if (unicode_file_names()) { PyObject *unipath, *woperation = NULL;
PyObject *unipath, *woperation = NULL; if (!PyArg_ParseTuple(args, "U|s:startfile",
if (!PyArg_ParseTuple(args, "U|s:startfile", &unipath, &operation)) {
&unipath, &operation)) { PyErr_Clear();
goto normal;
}
if (operation) {
woperation = PyUnicode_DecodeASCII(operation,
strlen(operation), NULL);
if (!woperation) {
PyErr_Clear(); PyErr_Clear();
operation = NULL;
goto normal; 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;
} }
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: normal:
if (!PyArg_ParseTuple(args, "O&|s:startfile", if (!PyArg_ParseTuple(args, "O&|s:startfile",

6
PC/pyconfig.h
View File

@ -95,12 +95,6 @@ WIN32 is still required for the locale module.
#endif #endif
#ifdef MS_WINCE #ifdef MS_WINCE
/* Python uses GetVersion() to distinguish between
* Windows NT and 9x/ME where OS Unicode support is concerned.
* Windows CE supports Unicode in the same way as NT so we
* define the missing GetVersion() accordingly.
*/
#define GetVersion() (4)
/* Windows CE does not support environment variables */ /* Windows CE does not support environment variables */
#define getenv(v) (NULL) #define getenv(v) (NULL)
#define environ (NULL) #define environ (NULL)