Rename all occurrences of MS_WIN32 to MS_WINDOWS.
size);
}
-#if defined(MS_WIN32) && defined(HAVE_USABLE_WCHAR_T)
+#if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
static PyObject *
mbcs_decode(PyObject *self,
size);
}
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
/* --- Encoder ------------------------------------------------------------ */
return v;
}
-#if defined(MS_WIN32) && defined(HAVE_USABLE_WCHAR_T)
+#if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
static PyObject *
mbcs_encode(PyObject *self,
return v;
}
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
#endif /* Py_USING_UNICODE */
/* --- Module API --------------------------------------------------------- */
{"charmap_decode", charmap_decode, METH_VARARGS},
{"readbuffer_encode", readbuffer_encode, METH_VARARGS},
{"charbuffer_encode", charbuffer_encode, METH_VARARGS},
-#if defined(MS_WIN32) && defined(HAVE_USABLE_WCHAR_T)
+#if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
{"mbcs_encode", mbcs_encode, METH_VARARGS},
{"mbcs_decode", mbcs_decode, METH_VARARGS},
#endif
* Which timer to use should be made more configurable, but that should not
* be difficult. This will do for now.
*/
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
#include <windows.h>
#include <direct.h> /* for getcwd() */
typedef __int64 hs_time;
static PyObject * ProfilerError = NULL;
-#ifndef MS_WIN32
+#ifndef MS_WINDOWS
#ifdef GETTIMEOFDAY_NO_TZ
#define GETTIMEOFDAY(ptv) gettimeofday((ptv))
#else
get_tdelta(ProfilerObject *self)
{
int tdelta;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
hs_time tv;
hs_time diff;
/* A couple of useful helper functions. */
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
static LARGE_INTEGER frequency = {0, 0};
#endif
{
hs_time tv1, tv2;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
hs_time diff;
QueryPerformanceFrequency(&frequency);
#endif
GETTIMEOFDAY(&tv1);
while (1) {
GETTIMEOFDAY(&tv2);
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
diff = tv2 - tv1;
if (diff != 0) {
timeofday_diff = (unsigned long)diff;
}
#endif
}
-#if defined(MS_WIN32) || defined(macintosh) || defined(PYOS_OS2)
+#if defined(MS_WINDOWS) || defined(macintosh) || defined(PYOS_OS2)
rusage_diff = -1;
#else
{
else
pack_add_info(self, "executable-version", buffer);
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
PyOS_snprintf(cwdbuffer, sizeof(cwdbuffer), "%I64d", frequency.QuadPart);
pack_add_info(self, "reported-performance-frequency", cwdbuffer);
#else
}
PyDoc_VAR(resolution__doc__) =
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
PyDoc_STR(
"resolution() -> (performance-counter-ticks, update-frequency)\n"
"Return the resolution of the timer provided by the QueryPerformanceCounter()\n"
calibrate();
calibrate();
}
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
result = Py_BuildValue("ii", timeofday_diff, frequency.LowPart);
#else
result = Py_BuildValue("ii", timeofday_diff, rusage_diff);
#include <libintl.h>
#endif
-#if defined(MS_WIN32)
+#if defined(MS_WINDOWS)
#define WINDOWS_LEAN_AND_MEAN
#include <windows.h>
#endif
return result;
}
-#if defined(MS_WIN32)
+#if defined(MS_WINDOWS)
static PyObject*
PyLocale_getdefaultlocale(PyObject* self)
{
METH_VARARGS, strcoll__doc__},
{"strxfrm", (PyCFunction) PyLocale_strxfrm,
METH_VARARGS, strxfrm__doc__},
-#if defined(MS_WIN32) || defined(macintosh)
+#if defined(MS_WINDOWS) || defined(macintosh)
{"_getdefaultlocale", (PyCFunction) PyLocale_getdefaultlocale, METH_NOARGS},
#endif
#ifdef HAVE_LANGINFO_H
#include <Python.h>
-#ifndef MS_WIN32
+#ifndef MS_WINDOWS
#define UNIX
#endif
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
#include <windows.h>
static int
my_getpagesize(void)
size_t size;
size_t pos;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
HANDLE map_handle;
HANDLE file_handle;
char * tagname;
static void
mmap_object_dealloc(mmap_object *m_obj)
{
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
if (m_obj->data != NULL)
UnmapViewOfFile (m_obj->data);
if (m_obj->map_handle != INVALID_HANDLE_VALUE)
CloseHandle (m_obj->file_handle);
if (m_obj->tagname)
PyMem_Free(m_obj->tagname);
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
#ifdef UNIX
if (m_obj->data!=NULL) {
{
if (!PyArg_ParseTuple(args, ":close"))
return NULL;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
/* For each resource we maintain, we need to check
the value is valid, and if so, free the resource
and set the member value to an invalid value so
CloseHandle (self->file_handle);
self->file_handle = INVALID_HANDLE_VALUE;
}
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
#ifdef UNIX
munmap(self->data, self->size);
return (Py_None);
}
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
#define CHECK_VALID(err) \
do { \
if (!self->map_handle) { \
return err; \
} \
} while (0)
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
#ifdef UNIX
#define CHECK_VALID(err) \
if (!PyArg_ParseTuple(args, ":size"))
return NULL;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
if (self->file_handle != INVALID_HANDLE_VALUE) {
return (Py_BuildValue (
"l", (long)
} else {
return (Py_BuildValue ("l", (long) self->size) );
}
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
#ifdef UNIX
{
if (!PyArg_ParseTuple (args, "l:resize", &new_size) ||
!is_resizeable(self)) {
return NULL;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
} else {
DWORD dwErrCode = 0;
/* First, unmap the file view */
}
PyErr_SetFromWindowsErr(dwErrCode);
return (NULL);
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
#ifdef UNIX
#ifndef HAVE_MREMAP
"flush values out of range");
return NULL;
} else {
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
return (Py_BuildValue("l", (long)
FlushViewOfFile(self->data+offset, size)));
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
#ifdef UNIX
/* XXX semantics of return value? */
/* XXX flags for msync? */
}
#endif /* UNIX */
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
static PyObject *
new_mmap_object(PyObject *self, PyObject *args, PyObject *kwdict)
{
PyErr_SetFromWindowsErr(dwErr);
return (NULL);
}
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
/* List of functions exported by this module */
static struct PyMethodDef mmap_functions[] = {
/* This file is also used for Windows NT/MS-Win and OS/2. In that case the
module actually calls itself 'nt' or 'os2', not 'posix', and a few
functions are either unimplemented or implemented differently. The source
- assumes that for Windows NT, the macro 'MS_WIN32' is defined independent
+ assumes that for Windows NT, the macro 'MS_WINDOWS' is defined independent
of the compiler used. Different compilers define their own feature
test macro, e.g. '__BORLANDC__' or '_MSC_VER'. For OS/2, the compiler
independent macro PYOS_OS2 should be defined. On OS/2 the default
#else
#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
#define HAVE_CWAIT 1
-#else /* 16-bit Windows */
-#endif /* !MS_WIN32 */
#else
#if defined(PYOS_OS2) && defined(PYCC_GCC)
/* Everything needed is defined in PC/os2emx/pyconfig.h */
#include "osdefs.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)
/* choose the appropriate stat and fstat functions and return structs */
#undef STAT
-#if defined(MS_WIN64) || defined(MS_WIN32)
+#if defined(MS_WIN64) || defined(MS_WINDOWS)
# define STAT _stati64
# define FSTAT _fstati64
# define STRUCT_STAT struct _stati64
return rc;
}
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
static PyObject *
win32_error(char* function, char* filename)
{
char *pathfree = NULL; /* this memory must be free'd */
int res;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
int pathlen;
char pathcopy[MAX_PATH];
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
if (!PyArg_ParseTuple(args, format,
Py_FileSystemDefaultEncoding, &path))
return NULL;
pathfree = path;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
pathlen = strlen(path);
/* the library call can blow up if the file name is too long! */
if (pathlen > MAX_PATH) {
path = pathcopy;
}
}
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
Py_BEGIN_ALLOW_THREADS
res = (*statfunc)(path, &st);
{
/* XXX Should redo this putting the (now four) versions of opendir
in separate files instead of having them all here... */
-#if defined(MS_WIN32) && !defined(HAVE_OPENDIR)
+#if defined(MS_WINDOWS) && !defined(HAVE_OPENDIR)
PyObject *d, *v;
HANDLE hFindFile;
return d;
-#elif defined(_MSC_VER) /* 16-bit Windows */
-
-#ifndef MAX_PATH
-#define MAX_PATH 250
-#endif
- 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 == ALTSEP)
- *pt = SEP;
- if (namebuf[len-1] != SEP)
- namebuf[len++] = SEP;
- 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
#endif /* which OS */
} /* end of posix_listdir */
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
/* A helper function for abspath on win32 */
static PyObject *
posix__getfullpathname(PyObject *self, PyObject *args)
return win32_error("GetFullPathName", inbuf);
return PyString_FromString(outbuf);
} /* end of posix__getfullpathname */
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
PyDoc_STRVAR(posix_mkdir__doc__,
"mkdir(path [, mode=0777])\n\n\
#endif /* PYCC_??? */
-#elif defined(MS_WIN32)
+#elif defined(MS_WINDOWS)
/*
* Portable 'popen' replacement for Win32.
#endif /* HAVE_TIMES */
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
#define HAVE_TIMES /* so the method table will pick it up */
static PyObject *
posix_times(PyObject *self, PyObject *args)
(double)0,
(double)0);
}
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
#ifdef HAVE_TIMES
PyDoc_STRVAR(posix_times__doc__,
posix_lseek(PyObject *self, PyObject *args)
{
int fd, how;
-#if defined(MS_WIN64) || defined(MS_WIN32)
+#if defined(MS_WIN64) || defined(MS_WINDOWS)
LONG_LONG pos, res;
#else
off_t pos, res;
return NULL;
Py_BEGIN_ALLOW_THREADS
-#if defined(MS_WIN64) || defined(MS_WIN32)
+#if defined(MS_WIN64) || defined(MS_WINDOWS)
res = _lseeki64(fd, pos, how);
#else
res = lseek(fd, pos, how);
return Py_BuildValue("(ii)", read, write);
#else
-#if !defined(MS_WIN32)
+#if !defined(MS_WINDOWS)
int fds[2];
int res;
if (!PyArg_ParseTuple(args, ":pipe"))
if (res != 0)
return posix_error();
return Py_BuildValue("(ii)", fds[0], fds[1]);
-#else /* MS_WIN32 */
+#else /* MS_WINDOWS */
HANDLE read, write;
int read_fd, write_fd;
BOOL ok;
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_WIN32 */
+#endif /* MS_WINDOWS */
#endif
}
#endif /* HAVE_PIPE */
"tempnam is a potential security risk to your program") < 0)
return NULL;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
name = _tempnam(dir, pfx);
#else
name = tempnam(dir, pfx);
return NULL;
}
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
PyDoc_STRVAR(win32_startfile__doc__,
"startfile(filepath) - Start a file with its associated application.\n\
\n\
#endif /* HAVE_PLOCK */
#ifdef HAVE_POPEN
{"popen", posix_popen, METH_VARARGS, posix_popen__doc__},
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
{"popen2", win32_popen2, METH_VARARGS},
{"popen3", win32_popen3, METH_VARARGS},
{"popen4", win32_popen4, METH_VARARGS},
{"pathconf", posix_pathconf, METH_VARARGS, posix_pathconf__doc__},
#endif
{"abort", posix_abort, METH_VARARGS, posix_abort__doc__},
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
{"_getfullpathname", posix__getfullpathname, METH_VARARGS, NULL},
#endif
{NULL, NULL} /* Sentinel */
#include "Python.h"
#include "intrcheck.h"
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
#include <process.h>
#endif
#else
#ifdef MS_WINDOWS
#include <windows.h>
-#if defined(MS_WIN16) || defined(__BORLANDC__)
+#if defined(__BORLANDC__)
/* These overrides not needed for Win32 */
#define timezone _timezone
#define tzname _tzname
#define daylight _daylight
-#endif /* MS_WIN16 || __BORLANDC__ */
-#ifdef MS_WIN16
-#define altzone _altzone
-#endif /* MS_WIN16 */
+#endif /* __BORLANDC__ */
#endif /* MS_WINDOWS */
#endif /* !__WATCOMC__ || __QNX__ */
-#if defined(MS_WIN32) && !defined(MS_WIN64) && !defined(__BORLANDC__)
+#if defined(MS_WINDOWS) && !defined(MS_WIN64) && !defined(__BORLANDC__)
/* Win32 has better clock replacement
XXX Win64 does not yet, but might when the platform matures. */
#undef HAVE_CLOCK /* We have our own version down below */
-#endif /* MS_WIN32 && !MS_WIN64 */
+#endif /* MS_WINDOWS && !MS_WIN64 */
#if defined(PYOS_OS2)
#define INCL_DOS
}
#endif /* HAVE_CLOCK */
-#if defined(MS_WIN32) && !defined(MS_WIN64) && !defined(__BORLANDC__)
+#if defined(MS_WINDOWS) && !defined(MS_WIN64) && !defined(__BORLANDC__)
/* Due to Mark Hammond and Tim Peters */
static PyObject *
time_clock(PyObject *self, PyObject *args)
}
#define HAVE_CLOCK /* So it gets included in the methods */
-#endif /* MS_WIN32 && !MS_WIN64 */
+#endif /* MS_WINDOWS && !MS_WIN64 */
#ifdef HAVE_CLOCK
PyDoc_STRVAR(clock_doc,
static int
floatsleep(double secs)
{
-/* XXX Should test for MS_WIN32 first! */
+/* XXX Should test for MS_WINDOWS first! */
#if defined(HAVE_SELECT) && !defined(__BEOS__) && !defined(__EMX__)
struct timeval t;
double frac;
Py_BEGIN_ALLOW_THREADS
delay((int)(secs * 1000 + 0.5)); /* delay() uses milliseconds */
Py_END_ALLOW_THREADS
-#elif defined(MSDOS)
- struct timeb t1, t2;
- double frac;
- extern double fmod(double, double);
- extern double floor(double);
- if (secs <= 0.0)
- return;
- frac = fmod(secs, 1.0);
- secs = floor(secs);
- ftime(&t1);
- t2.time = t1.time + (int)secs;
- t2.millitm = t1.millitm + (int)(frac*1000.0);
- while (t2.millitm >= 1000) {
- t2.time++;
- t2.millitm -= 1000;
- }
- for (;;) {
-#ifdef QUICKWIN
- Py_BEGIN_ALLOW_THREADS
- _wyield();
- Py_END_ALLOW_THREADS
-#endif
- if (PyErr_CheckSignals())
- return -1;
- ftime(&t1);
- if (t1.time > t2.time ||
- t1.time == t2.time && t1.millitm >= t2.millitm)
- break;
- }
-#elif defined(MS_WIN32)
+#elif defined(MS_WINDOWS)
{
double millisecs = secs * 1000.0;
if (millisecs > (double)ULONG_MAX) {
#include <sys/types.h>
#endif /* DONT_HAVE_SYS_TYPES_H */
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
#define fileno _fileno
/* can simulate truncate with Win32 API functions; see file_truncate */
#define HAVE_FTRUNCATE
if (ret != 0)
goto onioerror;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
/* MS _chsize doesn't work if newsize doesn't fit in 32 bits,
so don't even try using it. */
{
ret = ftruncate(fileno(f->f_fp), newsize);
Py_END_ALLOW_THREADS
if (ret != 0) goto onioerror;
-#endif /* !MS_WIN32 */
+#endif /* !MS_WINDOWS */
Py_INCREF(Py_None);
return Py_None;
#include "unicodeobject.h"
#include "ucnhash.h"
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
#include <windows.h>
#endif
NULL);
}
-#if defined(MS_WIN32) && defined(HAVE_USABLE_WCHAR_T)
+#if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
/* --- MBCS codecs for Windows -------------------------------------------- */
return repr;
}
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
/* --- Character Mapping Codec -------------------------------------------- */
#include "Python.h"
#include "osdefs.h"
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
#include <windows.h>
#include <tchar.h>
#endif
return 0;
}
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
/* a string loaded from the DLL at startup.*/
extern const char *PyWin_DLLVersionString;
free(keyBuf);
return retval;
}
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
static void
get_progpath(void)
char *path = getenv("PATH");
char *prog = Py_GetProgramName();
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
#ifdef UNICODE
WCHAR wprogpath[MAXPATHLEN+1];
/* Windows documents that GetModuleFileName() will "truncate",
char *pythonhome = Py_GetPythonHome();
char *envpath = Py_GETENV("PYTHONPATH");
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
int skiphome, skipdefault;
char *machinepath = NULL;
char *userpath = NULL;
envpath = NULL;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
skiphome = pythonhome==NULL ? 0 : 1;
machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, skiphome);
userpath = getpythonregpath(HKEY_CURRENT_USER, skiphome);
bufsz = 0;
bufsz += strlen(PYTHONPATH) + 1;
bufsz += strlen(argv0_path) + 1;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
if (userpath)
bufsz += strlen(userpath) + 1;
if (machinepath)
fprintf(stderr, "Using default static path.\n");
module_search_path = PYTHONPATH;
}
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
if (machinepath)
free(machinepath);
if (userpath)
free(userpath);
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
return;
}
buf = strchr(buf, '\0');
*buf++ = DELIM;
}
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
if (userpath) {
strcpy(buf, userpath);
buf = strchr(buf, '\0');
strcpy(buf, PYTHONPATH);
buf = strchr(buf, '\0');
}
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
else {
char *p = PYTHONPATH;
char *q;
the following #defines
MS_WIN64 - Code specific to the MS Win64 API
-MS_WIN32 - Code specific to the MS Win32 (and Win64) API
-MS_WIN16 - Code specific to the old 16 bit Windows API.
+MS_WIN32 - Code specific to the MS Win32 (and Win64) API (obsolete, this covers all supported APIs)
MS_WINDOWS - Code specific to Windows, but all versions.
MS_COREDLL - Code if the Python core is built as a DLL.
#define NT /* NT is obsolete - please use MS_WIN32 instead */
#define MS_WIN32
#endif
-#ifdef _WIN16
-#define MS_WIN16
-#endif
#define MS_WINDOWS
/* set the COMPILER */
/* #define HAVE_ALTZONE */
/* Define if you have the putenv function. */
-#ifdef MS_WIN32
-/* Does this exist on Win16? */
#define HAVE_PUTENV
-#endif
/* Define if your compiler supports function prototypes */
#define HAVE_PROTOTYPES
/* The default encoding used by the platform file system APIs
Can remain NULL for all platforms that don't have such a concept
*/
-#if defined(MS_WIN32) && defined(HAVE_USABLE_WCHAR_T)
+#if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
const char *Py_FileSystemDefaultEncoding = "mbcs";
#else
const char *Py_FileSystemDefaultEncoding = NULL; /* use default */
};
-#ifdef MS_WIN32
-
/* Case insensitive string compare, to avoid any dependencies on particular
C RTL implementations */
return NULL;
}
-#endif /* MS_WIN32 */
dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
-#ifdef MS_WIN32
{
HINSTANCE hDLL = NULL;
char pathbuf[260];
}
p = GetProcAddress(hDLL, funcname);
}
-#endif /* MS_WIN32 */
-#ifdef MS_WIN16
- {
- HINSTANCE hDLL;
- char pathbuf[16];
- if (strchr(pathname, '\\') == NULL &&
- strchr(pathname, '/') == NULL)
- {
- /* Prefix bare filename with ".\" */
- PyOS_snprintf(pathbuf, sizeof(pathbuf),
- ".\\%-.13s", pathname);
- pathname = pathbuf;
- }
- hDLL = LoadLibrary(pathname);
- if (hDLL < HINSTANCE_ERROR){
- char errBuf[256];
- PyOS_snprintf(errBuf, sizeof(errBuf),
- "DLL load failed with error code %d",
- hDLL);
- PyErr_SetString(PyExc_ImportError, errBuf);
- return NULL;
- }
- p = GetProcAddress(hDLL, funcname);
- }
-#endif /* MS_WIN16 */
return p;
}
#endif
#endif
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
#include "windows.h"
#include "winbase.h"
#endif
#ifdef PLAN9
char errbuf[ERRMAX];
#endif
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
char *s_buf = NULL;
#endif
#ifdef EINTR
if (i == 0)
s = "Error"; /* Sometimes errno didn't get set */
else
-#ifndef MS_WIN32
+#ifndef MS_WINDOWS
s = strerror(i);
#else
{
PyErr_SetObject(exc, v);
Py_DECREF(v);
}
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
LocalFree(s_buf);
#endif
return NULL;
#include "Python.h"
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
extern void PyWinFreeze_ExeInit(void);
extern void PyWinFreeze_ExeTerm(void);
extern int PyInitFrozenExtensions(void);
setbuf(stderr, (char *)NULL);
}
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
PyInitFrozenExtensions();
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
Py_SetProgramName(argv[0]);
Py_Initialize();
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
PyWinFreeze_ExeInit();
#endif
if (inspect && isatty((int)fileno(stdin)))
sts = PyRun_AnyFile(stdin, "<stdin>") != 0;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
PyWinFreeze_ExeTerm();
#endif
Py_Finalize();
#else
static const struct filedescr _PyImport_StandardFiletab[] = {
{".py", "U", PY_SOURCE},
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
{".pyw", "U", PY_SOURCE},
#endif
{".pyc", "rb", PY_COMPILED},
if (len+2 > buflen)
return NULL;
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
/* Treat .pyw as if it were .py. The case of ".pyw" must match
that used in _PyImport_StandardFiletab. */
if (len >= 4 && strcmp(&pathname[len-4], ".pyw") == 0)
/* First we may need a pile of platform-specific header files; the sequence
* of #if's here should match the sequence in the body of case_ok().
*/
-#if defined(MS_WIN32) || defined(__CYGWIN__)
+#if defined(MS_WINDOWS) || defined(__CYGWIN__)
#include <windows.h>
#ifdef __CYGWIN__
#include <sys/cygwin.h>
* match the sequence just above.
*/
-/* MS_WIN32 || __CYGWIN__ */
-#if defined(MS_WIN32) || defined(__CYGWIN__)
+/* MS_WINDOWS || __CYGWIN__ */
+#if defined(MS_WINDOWS) || defined(__CYGWIN__)
WIN32_FIND_DATA data;
HANDLE h;
#ifdef __CYGWIN__
#include <signal.h>
#endif
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
#undef BYTE
#include "windows.h"
#endif
#ifdef macintosh
for (;;);
#endif
-#ifdef MS_WIN32
+#ifdef MS_WINDOWS
OutputDebugString("Fatal Python error: ");
OutputDebugString(msg);
OutputDebugString("\n");
#ifdef _DEBUG
DebugBreak();
#endif
-#endif /* MS_WIN32 */
+#endif /* MS_WINDOWS */
abort();
}
because it is thread-safe.\n\
"
)
-#ifndef MS_WIN16
/* concatenating string here */
PyDoc_STR(
"\n\
settrace() -- set the global debug tracing function\n\
"
)
-#endif /* MS_WIN16 */
/* end of sys_doc */ ;
PyObject *