diff --git a/PC/os2emx/config.c b/PC/os2emx/config.c
index 88ece9d..218aa68 100644
--- a/PC/os2emx/config.c
+++ b/PC/os2emx/config.c
@@ -95,71 +95,71 @@
 
 struct _inittab _PyImport_Inittab[] = {
 
-	{"os2", initos2},
-	{"signal", initsignal},
+    {"os2", initos2},
+    {"signal", initsignal},
 #ifdef WITH_THREAD
-	{"_thread", init_thread},
+    {"_thread", init_thread},
 #endif
-	{"_codecs", init_codecs},
-	{"_csv", init_csv},
-	{"_locale", init_locale},
-	{"_random", init_random},
-	{"_sre", init_sre},
-	{"_symtable", init_symtable},
-	{"_weakref", init_weakref},
-	{"array", initarray},
-	{"binascii", initbinascii},
-	{"collections", initcollections},
-	{"cmath", initcmath},
-	{"datetime", initdatetime},
-	{"dl", initdl},
-	{"errno", initerrno},
-	{"fcntl", initfcntl},
-	{"_functools", init_functools},
-	{"_heapq", init_heapq},
-	{"imageop", initimageop},
-	{"itertools", inititertools},
-	{"math", initmath},
-	{"operator", initoperator},
-	{"_sha256", init_sha256},
-	{"_sha512", init_sha512},
-	{"_struct", init_struct},
-	{"termios", inittermios},
-	{"time", inittime},
-	{"xxsubtype", initxxsubtype},
-	{"zipimport", initzipimport},
+    {"_codecs", init_codecs},
+    {"_csv", init_csv},
+    {"_locale", init_locale},
+    {"_random", init_random},
+    {"_sre", init_sre},
+    {"_symtable", init_symtable},
+    {"_weakref", init_weakref},
+    {"array", initarray},
+    {"binascii", initbinascii},
+    {"collections", initcollections},
+    {"cmath", initcmath},
+    {"datetime", initdatetime},
+    {"dl", initdl},
+    {"errno", initerrno},
+    {"fcntl", initfcntl},
+    {"_functools", init_functools},
+    {"_heapq", init_heapq},
+    {"imageop", initimageop},
+    {"itertools", inititertools},
+    {"math", initmath},
+    {"operator", initoperator},
+    {"_sha256", init_sha256},
+    {"_sha512", init_sha512},
+    {"_struct", init_struct},
+    {"termios", inittermios},
+    {"time", inittime},
+    {"xxsubtype", initxxsubtype},
+    {"zipimport", initzipimport},
 #if !HAVE_DYNAMIC_LOADING
-	{"_curses", init_curses},
-	{"_curses_panel", init_curses_panel},
-	{"_testcapi", init_testcapi},
-	{"bz2", initbz2},
-	{"fpectl", initfpectl},
-	{"fpetest", initfpetest},
-	{"parser", initparser},
-	{"pwd", initpwd},
-	{"unicodedata", initunicodedata},
-	{"zlib", initzlib},
+    {"_curses", init_curses},
+    {"_curses_panel", init_curses_panel},
+    {"_testcapi", init_testcapi},
+    {"bz2", initbz2},
+    {"fpectl", initfpectl},
+    {"fpetest", initfpetest},
+    {"parser", initparser},
+    {"pwd", initpwd},
+    {"unicodedata", initunicodedata},
+    {"zlib", initzlib},
 #ifdef USE_SOCKET
-	{"_socket", init_socket},
-	{"select", initselect},
+    {"_socket", init_socket},
+    {"select", initselect},
 #endif
 #endif
 /* -- ADDMODULE MARKER 2 -- */
 
-	/* This module "lives in" with marshal.c */
-	{"marshal", PyMarshal_Init},
+    /* This module "lives in" with marshal.c */
+    {"marshal", PyMarshal_Init},
 
-	/* This lives it with import.c */
-	{"imp", initimp},
+    /* This lives it with import.c */
+    {"imp", initimp},
 
-	/* These entries are here for sys.builtin_module_names */
-	{"__main__", NULL},
-	{"builtins", NULL},
-	{"sys", NULL},
+    /* These entries are here for sys.builtin_module_names */
+    {"__main__", NULL},
+    {"builtins", NULL},
+    {"sys", NULL},
 
-	/* This lives in gcmodule.c */
-	{"gc", initgc},
+    /* This lives in gcmodule.c */
+    {"gc", initgc},
 
-	/* Sentinel */
-	{0, 0}
+    /* Sentinel */
+    {0, 0}
 };
diff --git a/PC/os2emx/dlfcn.c b/PC/os2emx/dlfcn.c
index 9e88d5e..47c046c 100644
--- a/PC/os2emx/dlfcn.c
+++ b/PC/os2emx/dlfcn.c
@@ -46,178 +46,178 @@
 #include <malloc.h>
 
 typedef struct _track_rec {
-	char *name;
-	HMODULE handle;
-	void *id;
-	struct _track_rec *next;
+    char *name;
+    HMODULE handle;
+    void *id;
+    struct _track_rec *next;
 } tDLLchain, *DLLchain;
 
-static DLLchain dlload = NULL;	/* A simple chained list of DLL names */
-static char dlerr [256];	/* last error text string */
+static DLLchain dlload = NULL;  /* A simple chained list of DLL names */
+static char dlerr [256];        /* last error text string */
 static void *last_id;
 
 static DLLchain find_id(void *id)
 {
-	DLLchain tmp;
+    DLLchain tmp;
 
-	for (tmp = dlload; tmp; tmp = tmp->next)
-		if (id == tmp->id)
-			return tmp;
+    for (tmp = dlload; tmp; tmp = tmp->next)
+        if (id == tmp->id)
+            return tmp;
 
-	return NULL;
+    return NULL;
 }
 
 /* load a dynamic-link library and return handle */
 void *dlopen(char *filename, int flags)
 {
-	HMODULE hm;
-	DLLchain tmp;
-	char err[256];
-	char *errtxt;
-	int rc = 0, set_chain = 0;
+    HMODULE hm;
+    DLLchain tmp;
+    char err[256];
+    char *errtxt;
+    int rc = 0, set_chain = 0;
 
-	for (tmp = dlload; tmp; tmp = tmp->next)
-		if (strnicmp(tmp->name, filename, 999) == 0)
-			break;
+    for (tmp = dlload; tmp; tmp = tmp->next)
+        if (strnicmp(tmp->name, filename, 999) == 0)
+            break;
 
-	if (!tmp)
-	{
-		tmp = (DLLchain) malloc(sizeof(tDLLchain));
-		if (!tmp)
-			goto nomem;
-		tmp->name = strdup(filename);
-		tmp->next = dlload;
-		set_chain = 1;
-	}
+    if (!tmp)
+    {
+        tmp = (DLLchain) malloc(sizeof(tDLLchain));
+        if (!tmp)
+            goto nomem;
+        tmp->name = strdup(filename);
+        tmp->next = dlload;
+        set_chain = 1;
+    }
 
-	switch (rc = DosLoadModule((PSZ)&err, sizeof(err), filename, &hm))
-	{
-		case NO_ERROR:
-			tmp->handle = hm;
-			if (set_chain)
-			{
-				do
-					last_id++;
-				while ((last_id == 0) || (find_id(last_id)));
-				tmp->id = last_id;
-				dlload = tmp;
-			}
-			return tmp->id;
-		case ERROR_FILE_NOT_FOUND:
-		case ERROR_PATH_NOT_FOUND:
-			errtxt = "module `%s' not found";
-			break;
-		case ERROR_TOO_MANY_OPEN_FILES:
-		case ERROR_NOT_ENOUGH_MEMORY:
-		case ERROR_SHARING_BUFFER_EXCEEDED:
+    switch (rc = DosLoadModule((PSZ)&err, sizeof(err), filename, &hm))
+    {
+        case NO_ERROR:
+            tmp->handle = hm;
+            if (set_chain)
+            {
+                do
+                    last_id++;
+                while ((last_id == 0) || (find_id(last_id)));
+                tmp->id = last_id;
+                dlload = tmp;
+            }
+            return tmp->id;
+        case ERROR_FILE_NOT_FOUND:
+        case ERROR_PATH_NOT_FOUND:
+            errtxt = "module `%s' not found";
+            break;
+        case ERROR_TOO_MANY_OPEN_FILES:
+        case ERROR_NOT_ENOUGH_MEMORY:
+        case ERROR_SHARING_BUFFER_EXCEEDED:
 nomem:
-			errtxt = "out of system resources";
-			break;
-		case ERROR_ACCESS_DENIED:
-			errtxt = "access denied";
-			break;
-		case ERROR_BAD_FORMAT:
-		case ERROR_INVALID_SEGMENT_NUMBER:
-		case ERROR_INVALID_ORDINAL:
-		case ERROR_INVALID_MODULETYPE:
-		case ERROR_INVALID_EXE_SIGNATURE:
-		case ERROR_EXE_MARKED_INVALID:
-		case ERROR_ITERATED_DATA_EXCEEDS_64K:
-		case ERROR_INVALID_MINALLOCSIZE:
-		case ERROR_INVALID_SEGDPL:
-		case ERROR_AUTODATASEG_EXCEEDS_64K:
-		case ERROR_RELOCSRC_CHAIN_EXCEEDS_SEGLIMIT:
-			errtxt = "invalid module format";
-			break;
-		case ERROR_INVALID_NAME:
-			errtxt = "filename doesn't match module name";
-			break;
-		case ERROR_SHARING_VIOLATION:
-		case ERROR_LOCK_VIOLATION:
-			errtxt = "sharing violation";
-			break;
-		case ERROR_INIT_ROUTINE_FAILED:
-			errtxt = "module initialization failed";
-			break;
-		default:
-			errtxt = "cause `%s', error code = %d";
-			break;
-	}
-	snprintf(dlerr, sizeof(dlerr), errtxt, &err, rc);
-	if (tmp)
-	{
-		if (tmp->name)
-			free(tmp->name);
-		free(tmp);
-	}
-	return 0;
+            errtxt = "out of system resources";
+            break;
+        case ERROR_ACCESS_DENIED:
+            errtxt = "access denied";
+            break;
+        case ERROR_BAD_FORMAT:
+        case ERROR_INVALID_SEGMENT_NUMBER:
+        case ERROR_INVALID_ORDINAL:
+        case ERROR_INVALID_MODULETYPE:
+        case ERROR_INVALID_EXE_SIGNATURE:
+        case ERROR_EXE_MARKED_INVALID:
+        case ERROR_ITERATED_DATA_EXCEEDS_64K:
+        case ERROR_INVALID_MINALLOCSIZE:
+        case ERROR_INVALID_SEGDPL:
+        case ERROR_AUTODATASEG_EXCEEDS_64K:
+        case ERROR_RELOCSRC_CHAIN_EXCEEDS_SEGLIMIT:
+            errtxt = "invalid module format";
+            break;
+        case ERROR_INVALID_NAME:
+            errtxt = "filename doesn't match module name";
+            break;
+        case ERROR_SHARING_VIOLATION:
+        case ERROR_LOCK_VIOLATION:
+            errtxt = "sharing violation";
+            break;
+        case ERROR_INIT_ROUTINE_FAILED:
+            errtxt = "module initialization failed";
+            break;
+        default:
+            errtxt = "cause `%s', error code = %d";
+            break;
+    }
+    snprintf(dlerr, sizeof(dlerr), errtxt, &err, rc);
+    if (tmp)
+    {
+        if (tmp->name)
+            free(tmp->name);
+        free(tmp);
+    }
+    return 0;
 }
 
 /* return a pointer to the `symbol' in DLL */
 void *dlsym(void *handle, char *symbol)
 {
-	int rc = 0;
-	PFN addr;
-	char *errtxt;
-	int symord = 0;
-	DLLchain tmp = find_id(handle);
+    int rc = 0;
+    PFN addr;
+    char *errtxt;
+    int symord = 0;
+    DLLchain tmp = find_id(handle);
 
-	if (!tmp)
-		goto inv_handle;
+    if (!tmp)
+        goto inv_handle;
 
-	if (*symbol == '#')
-		symord = atoi(symbol + 1);
+    if (*symbol == '#')
+        symord = atoi(symbol + 1);
 
-	switch (rc = DosQueryProcAddr(tmp->handle, symord, symbol, &addr))
-	{
-		case NO_ERROR:
-			return (void *)addr;
-		case ERROR_INVALID_HANDLE:
+    switch (rc = DosQueryProcAddr(tmp->handle, symord, symbol, &addr))
+    {
+        case NO_ERROR:
+            return (void *)addr;
+        case ERROR_INVALID_HANDLE:
 inv_handle:
-			errtxt = "invalid module handle";
-			break;
-		case ERROR_PROC_NOT_FOUND:
-		case ERROR_INVALID_NAME:
-			errtxt = "no symbol `%s' in module";
-			break;
-		default:
-			errtxt = "symbol `%s', error code = %d";
-			break;
-	}
-	snprintf(dlerr, sizeof(dlerr), errtxt, symbol, rc);
-	return NULL;
+            errtxt = "invalid module handle";
+            break;
+        case ERROR_PROC_NOT_FOUND:
+        case ERROR_INVALID_NAME:
+            errtxt = "no symbol `%s' in module";
+            break;
+        default:
+            errtxt = "symbol `%s', error code = %d";
+            break;
+    }
+    snprintf(dlerr, sizeof(dlerr), errtxt, symbol, rc);
+    return NULL;
 }
 
 /* free dynamicaly-linked library */
 int dlclose(void *handle)
 {
-	int rc;
-	DLLchain tmp = find_id(handle);
+    int rc;
+    DLLchain tmp = find_id(handle);
 
-	if (!tmp)
-		goto inv_handle;
+    if (!tmp)
+        goto inv_handle;
 
-	switch (rc = DosFreeModule(tmp->handle))
-	{
-		case NO_ERROR:
-			free(tmp->name);
-			dlload = tmp->next;
-			free(tmp);
-			return 0;
-		case ERROR_INVALID_HANDLE:
+    switch (rc = DosFreeModule(tmp->handle))
+    {
+        case NO_ERROR:
+            free(tmp->name);
+            dlload = tmp->next;
+            free(tmp);
+            return 0;
+        case ERROR_INVALID_HANDLE:
 inv_handle:
-			strcpy(dlerr, "invalid module handle");
-			return -1;
-		case ERROR_INVALID_ACCESS:
-			strcpy(dlerr, "access denied");
-			return -1;
-		default:
-			return -1;
-	}
+            strcpy(dlerr, "invalid module handle");
+            return -1;
+        case ERROR_INVALID_ACCESS:
+            strcpy(dlerr, "access denied");
+            return -1;
+        default:
+            return -1;
+    }
 }
 
 /* return a string describing last occurred dl error */
 char *dlerror()
 {
-	return dlerr;
+    return dlerr;
 }
diff --git a/PC/os2emx/dllentry.c b/PC/os2emx/dllentry.c
index dbf9c98..9ccca1c 100644
--- a/PC/os2emx/dllentry.c
+++ b/PC/os2emx/dllentry.c
@@ -4,7 +4,7 @@
 
 #define NULL 0
 
-#define REF(s)	extern void s(); void *____ref_##s = &s;
+#define REF(s)  extern void s(); void *____ref_##s = &s;
 
 /* Make references to imported symbols to pull them from static library */
 REF(Py_Main);
@@ -18,25 +18,25 @@
 
 unsigned long _DLL_InitTerm(unsigned long mod_handle, unsigned long flag)
 {
-	switch (flag)
-	{
-		case 0:
-			if (_CRT_init())
-				return 0;
-			__ctordtorInit();
+    switch (flag)
+    {
+        case 0:
+            if (_CRT_init())
+                return 0;
+            __ctordtorInit();
 
-			/* Ignore fatal signals */
-			signal(SIGSEGV, SIG_IGN);
-			signal(SIGFPE, SIG_IGN);
+            /* Ignore fatal signals */
+            signal(SIGSEGV, SIG_IGN);
+            signal(SIGFPE, SIG_IGN);
 
-			return 1;
+            return 1;
 
-		case 1:
-			__ctordtorTerm();
-			_CRT_term();
-			return 1;
+        case 1:
+            __ctordtorTerm();
+            _CRT_term();
+            return 1;
 
-		default:
-			return 0;
-	}
+        default:
+            return 0;
+    }
 }
diff --git a/PC/os2emx/getpathp.c b/PC/os2emx/getpathp.c
index 9e37f63..0d73774 100644
--- a/PC/os2emx/getpathp.c
+++ b/PC/os2emx/getpathp.c
@@ -4,8 +4,8 @@
 
 /* ----------------------------------------------------------------
    PATH RULES FOR OS/2+EMX:
-   This describes how sys.path is formed on OS/2+EMX.  It describes the 
-   functionality, not the implementation (ie, the order in which these 
+   This describes how sys.path is formed on OS/2+EMX.  It describes the
+   functionality, not the implementation (ie, the order in which these
    are actually fetched is different)
 
    * Python always adds an empty entry at the start, which corresponds
@@ -16,10 +16,10 @@
    * We attempt to locate the "Python Home" - if the PYTHONHOME env var
      is set, we believe it.  Otherwise, we use the path of our host .EXE's
      to try and locate our "landmark" (lib\\os.py) and deduce our home.
-     - If we DO have a Python Home: The relevant sub-directories (Lib, 
+     - If we DO have a Python Home: The relevant sub-directories (Lib,
        plat-win, etc) are based on the Python Home
      - If we DO NOT have a Python Home, the core Python Path is
-       loaded from the registry.  This is the main PythonPath key, 
+       loaded from the registry.  This is the main PythonPath key,
        and both HKLM and HKCU are combined to form the path)
 
    * Iff - we can not locate the Python Home, and have not had a PYTHONPATH
@@ -32,9 +32,9 @@
     (either an installed version, or directly from the PCbuild directory),
     the core path is deduced.
 
-  * When Python is hosted in another exe (different directory, embedded via 
+  * When Python is hosted in another exe (different directory, embedded via
     COM, etc), the Python Home will not be deduced, so the core path from
-    the registry is used.  Other "application paths "in the registry are 
+    the registry is used.  Other "application paths "in the registry are
     always read.
 
   * If Python can't find its home and there is no registry (eg, frozen
@@ -85,12 +85,12 @@
 
 
 static int
-is_sep(char ch)	/* determine if "ch" is a separator character */
+is_sep(char ch) /* determine if "ch" is a separator character */
 {
 #ifdef ALTSEP
-	return ch == SEP || ch == ALTSEP;
+    return ch == SEP || ch == ALTSEP;
 #else
-	return ch == SEP;
+    return ch == SEP;
 #endif
 }
 
@@ -100,36 +100,36 @@
 static void
 reduce(char *dir)
 {
-	size_t i = strlen(dir);
-	while (i > 0 && !is_sep(dir[i]))
-		--i;
-	dir[i] = '\0';
+    size_t i = strlen(dir);
+    while (i > 0 && !is_sep(dir[i]))
+        --i;
+    dir[i] = '\0';
 }
-	
+
 static int
 exists(char *filename)
 {
-	struct stat buf;
-	return stat(filename, &buf) == 0;
+    struct stat buf;
+    return stat(filename, &buf) == 0;
 }
 
 /* Is module  (check for .pyc/.pyo too)
- * Assumes 'filename' MAXPATHLEN+1 bytes long - 
+ * Assumes 'filename' MAXPATHLEN+1 bytes long -
  * may extend 'filename' by one character.
  */
 static int
 ismodule(char *filename)
 {
-	if (exists(filename))
-		return 1;
+    if (exists(filename))
+        return 1;
 
-	/* Check for the compiled version of prefix. */
-	if (strlen(filename) < MAXPATHLEN) {
-		strcat(filename, Py_OptimizeFlag ? "o" : "c");
-		if (exists(filename))
-			return 1;
-	}
-	return 0;
+    /* Check for the compiled version of prefix. */
+    if (strlen(filename) < MAXPATHLEN) {
+        strcat(filename, Py_OptimizeFlag ? "o" : "c");
+        if (exists(filename))
+            return 1;
+    }
+    return 0;
 }
 
 /* Add a path component, by appending stuff to buffer.
@@ -145,21 +145,21 @@
 static void
 join(char *buffer, char *stuff)
 {
-	size_t n, k;
-	if (is_sep(stuff[0]))
-		n = 0;
-	else {
-		n = strlen(buffer);
-		if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN)
-			buffer[n++] = SEP;
-	}
-	if (n > MAXPATHLEN)
-		Py_FatalError("buffer overflow in getpathp.c's joinpath()");
-	k = strlen(stuff);
-	if (n + k > MAXPATHLEN)
-		k = MAXPATHLEN - n;
-	strncpy(buffer+n, stuff, k);
-	buffer[n+k] = '\0';
+    size_t n, k;
+    if (is_sep(stuff[0]))
+        n = 0;
+    else {
+        n = strlen(buffer);
+        if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN)
+            buffer[n++] = SEP;
+    }
+    if (n > MAXPATHLEN)
+        Py_FatalError("buffer overflow in getpathp.c's joinpath()");
+    k = strlen(stuff);
+    if (n + k > MAXPATHLEN)
+        k = MAXPATHLEN - n;
+    strncpy(buffer+n, stuff, k);
+    buffer[n+k] = '\0';
 }
 
 /* gotlandmark only called by search_for_prefix, which ensures
@@ -169,219 +169,219 @@
 static int
 gotlandmark(char *landmark)
 {
-	int n, ok;
+    int n, ok;
 
-	n = strlen(prefix);
-	join(prefix, landmark);
-	ok = ismodule(prefix);
-	prefix[n] = '\0';
-	return ok;
+    n = strlen(prefix);
+    join(prefix, landmark);
+    ok = ismodule(prefix);
+    prefix[n] = '\0';
+    return ok;
 }
 
-/* assumes argv0_path is MAXPATHLEN+1 bytes long, already \0 term'd. 
+/* assumes argv0_path is MAXPATHLEN+1 bytes long, already \0 term'd.
  * assumption provided by only caller, calculate_path()
  */
 static int
 search_for_prefix(char *argv0_path, char *landmark)
 {
-	/* Search from argv0_path, until landmark is found */
-	strcpy(prefix, argv0_path);
-	do {
-		if (gotlandmark(landmark))
-			return 1;
-		reduce(prefix);
-	} while (prefix[0]);
-	return 0;
+    /* Search from argv0_path, until landmark is found */
+    strcpy(prefix, argv0_path);
+    do {
+        if (gotlandmark(landmark))
+            return 1;
+        reduce(prefix);
+    } while (prefix[0]);
+    return 0;
 }
 
 
 static void
 get_progpath(void)
 {
-	extern char *Py_GetProgramName(void);
-	char *path = getenv("PATH");
-	char *prog = Py_GetProgramName();
+    extern char *Py_GetProgramName(void);
+    char *path = getenv("PATH");
+    char *prog = Py_GetProgramName();
 
-	PPIB pib;
-	if ((DosGetInfoBlocks(NULL, &pib) == 0) &&
-	    (DosQueryModuleName(pib->pib_hmte, sizeof(progpath), progpath) == 0))
-		return;
+    PPIB pib;
+    if ((DosGetInfoBlocks(NULL, &pib) == 0) &&
+        (DosQueryModuleName(pib->pib_hmte, sizeof(progpath), progpath) == 0))
+        return;
 
-	if (prog == NULL || *prog == '\0')
-		prog = "python";
+    if (prog == NULL || *prog == '\0')
+        prog = "python";
 
-	/* If there is no slash in the argv0 path, then we have to
-	 * assume python is on the user's $PATH, since there's no
-	 * other way to find a directory to start the search from.  If
-	 * $PATH isn't exported, you lose.
-	 */
+    /* If there is no slash in the argv0 path, then we have to
+     * assume python is on the user's $PATH, since there's no
+     * other way to find a directory to start the search from.  If
+     * $PATH isn't exported, you lose.
+     */
 #ifdef ALTSEP
-	if (strchr(prog, SEP) || strchr(prog, ALTSEP))
+    if (strchr(prog, SEP) || strchr(prog, ALTSEP))
 #else
-	if (strchr(prog, SEP))
+    if (strchr(prog, SEP))
 #endif
-		strncpy(progpath, prog, MAXPATHLEN);
-	else if (path) {
-		while (1) {
-			char *delim = strchr(path, DELIM);
+        strncpy(progpath, prog, MAXPATHLEN);
+    else if (path) {
+        while (1) {
+            char *delim = strchr(path, DELIM);
 
-			if (delim) {
-				size_t len = delim - path;
-				/* ensure we can't overwrite buffer */
+            if (delim) {
+                size_t len = delim - path;
+                /* ensure we can't overwrite buffer */
 #if !defined(PYCC_GCC)
-				len = min(MAXPATHLEN,len);
+                len = min(MAXPATHLEN,len);
 #else
-				len = MAXPATHLEN < len ? MAXPATHLEN : len;
+                len = MAXPATHLEN < len ? MAXPATHLEN : len;
 #endif
-				strncpy(progpath, path, len);
-				*(progpath + len) = '\0';
-			}
-			else
-				strncpy(progpath, path, MAXPATHLEN);
+                strncpy(progpath, path, len);
+                *(progpath + len) = '\0';
+            }
+            else
+                strncpy(progpath, path, MAXPATHLEN);
 
-			/* join() is safe for MAXPATHLEN+1 size buffer */
-			join(progpath, prog);
-			if (exists(progpath))
-				break;
+            /* join() is safe for MAXPATHLEN+1 size buffer */
+            join(progpath, prog);
+            if (exists(progpath))
+                break;
 
-			if (!delim) {
-				progpath[0] = '\0';
-				break;
-			}
-			path = delim + 1;
-		}
-	}
-	else
-		progpath[0] = '\0';
+            if (!delim) {
+                progpath[0] = '\0';
+                break;
+            }
+            path = delim + 1;
+        }
+    }
+    else
+        progpath[0] = '\0';
 }
 
 static void
 calculate_path(void)
 {
-	char argv0_path[MAXPATHLEN+1];
-	char *buf;
-	size_t bufsz;
-	char *pythonhome = Py_GetPythonHome();
-	char *envpath = getenv("PYTHONPATH");
-	char zip_path[MAXPATHLEN+1];
-	size_t len;
+    char argv0_path[MAXPATHLEN+1];
+    char *buf;
+    size_t bufsz;
+    char *pythonhome = Py_GetPythonHome();
+    char *envpath = getenv("PYTHONPATH");
+    char zip_path[MAXPATHLEN+1];
+    size_t len;
 
-	get_progpath();
-	/* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
-	strcpy(argv0_path, progpath);
-	reduce(argv0_path);
-	if (pythonhome == NULL || *pythonhome == '\0') {
-		if (search_for_prefix(argv0_path, LANDMARK))
-			pythonhome = prefix;
-		else
-			pythonhome = NULL;
-	}
-	else
-		strncpy(prefix, pythonhome, MAXPATHLEN);
+    get_progpath();
+    /* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
+    strcpy(argv0_path, progpath);
+    reduce(argv0_path);
+    if (pythonhome == NULL || *pythonhome == '\0') {
+        if (search_for_prefix(argv0_path, LANDMARK))
+            pythonhome = prefix;
+        else
+            pythonhome = NULL;
+    }
+    else
+        strncpy(prefix, pythonhome, MAXPATHLEN);
 
-	if (envpath && *envpath == '\0')
-		envpath = NULL;
+    if (envpath && *envpath == '\0')
+        envpath = NULL;
 
-	/* Calculate zip archive path */
-	strncpy(zip_path, progpath, MAXPATHLEN);
-	zip_path[MAXPATHLEN] = '\0';
-	len = strlen(zip_path);
-	if (len > 4) {
-		zip_path[len-3] = 'z';  /* change ending to "zip" */
-		zip_path[len-2] = 'i';
-		zip_path[len-1] = 'p';
-	}
-	else {
-		zip_path[0] = 0;
-	}
+    /* Calculate zip archive path */
+    strncpy(zip_path, progpath, MAXPATHLEN);
+    zip_path[MAXPATHLEN] = '\0';
+    len = strlen(zip_path);
+    if (len > 4) {
+        zip_path[len-3] = 'z';  /* change ending to "zip" */
+        zip_path[len-2] = 'i';
+        zip_path[len-1] = 'p';
+    }
+    else {
+        zip_path[0] = 0;
+    }
 
-	/* We need to construct a path from the following parts.
-	 * (1) the PYTHONPATH environment variable, if set;
-	 * (2) the zip archive file path;
-	 * (3) the PYTHONPATH config macro, with the leading "."
-	 *     of each component replaced with pythonhome, if set;
-	 * (4) the directory containing the executable (argv0_path).
-	 * The length calculation calculates #3 first.
-	 */
+    /* We need to construct a path from the following parts.
+     * (1) the PYTHONPATH environment variable, if set;
+     * (2) the zip archive file path;
+     * (3) the PYTHONPATH config macro, with the leading "."
+     *     of each component replaced with pythonhome, if set;
+     * (4) the directory containing the executable (argv0_path).
+     * The length calculation calculates #3 first.
+     */
 
-	/* Calculate size of return buffer */
-	if (pythonhome != NULL) {
-		char *p;
-		bufsz = 1;	
-		for (p = PYTHONPATH; *p; p++) {
-			if (*p == DELIM)
-				bufsz++; /* number of DELIM plus one */
-		}
-		bufsz *= strlen(pythonhome);
-	}
-	else
-		bufsz = 0;
-	bufsz += strlen(PYTHONPATH) + 1;
-	bufsz += strlen(argv0_path) + 1;
-	bufsz += strlen(zip_path) + 1;
-	if (envpath != NULL)
-		bufsz += strlen(envpath) + 1;
+    /* Calculate size of return buffer */
+    if (pythonhome != NULL) {
+        char *p;
+        bufsz = 1;
+        for (p = PYTHONPATH; *p; p++) {
+            if (*p == DELIM)
+                bufsz++; /* number of DELIM plus one */
+        }
+        bufsz *= strlen(pythonhome);
+    }
+    else
+        bufsz = 0;
+    bufsz += strlen(PYTHONPATH) + 1;
+    bufsz += strlen(argv0_path) + 1;
+    bufsz += strlen(zip_path) + 1;
+    if (envpath != NULL)
+        bufsz += strlen(envpath) + 1;
 
-	module_search_path = buf = malloc(bufsz);
-	if (buf == NULL) {
-		/* We can't exit, so print a warning and limp along */
-		fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
-		if (envpath) {
-			fprintf(stderr, "Using environment $PYTHONPATH.\n");
-			module_search_path = envpath;
-		}
-		else {
-			fprintf(stderr, "Using default static path.\n");
-			module_search_path = PYTHONPATH;
-		}
-		return;
-	}
+    module_search_path = buf = malloc(bufsz);
+    if (buf == NULL) {
+        /* We can't exit, so print a warning and limp along */
+        fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
+        if (envpath) {
+            fprintf(stderr, "Using environment $PYTHONPATH.\n");
+            module_search_path = envpath;
+        }
+        else {
+            fprintf(stderr, "Using default static path.\n");
+            module_search_path = PYTHONPATH;
+        }
+        return;
+    }
 
-	if (envpath) {
-		strcpy(buf, envpath);
-		buf = strchr(buf, '\0');
-		*buf++ = DELIM;
-	}
-	if (zip_path[0]) {
-		strcpy(buf, zip_path);
-		buf = strchr(buf, '\0');
-		*buf++ = DELIM;
-	}
+    if (envpath) {
+        strcpy(buf, envpath);
+        buf = strchr(buf, '\0');
+        *buf++ = DELIM;
+    }
+    if (zip_path[0]) {
+        strcpy(buf, zip_path);
+        buf = strchr(buf, '\0');
+        *buf++ = DELIM;
+    }
 
-	if (pythonhome == NULL) {
-		strcpy(buf, PYTHONPATH);
-		buf = strchr(buf, '\0');
-	}
-	else {
-		char *p = PYTHONPATH;
-		char *q;
-		size_t n;
-		for (;;) {
-			q = strchr(p, DELIM);
-			if (q == NULL)
-				n = strlen(p);
-			else
-				n = q-p;
-			if (p[0] == '.' && is_sep(p[1])) {
-				strcpy(buf, pythonhome);
-				buf = strchr(buf, '\0');
-				p++;
-				n--;
-			}
-			strncpy(buf, p, n);
-			buf += n;
-			if (q == NULL)
-				break;
-			*buf++ = DELIM;
-			p = q+1;
-		}
-	}
-	if (argv0_path) {
-		*buf++ = DELIM;
-		strcpy(buf, argv0_path);
-		buf = strchr(buf, '\0');
-	}
-	*buf = '\0';
+    if (pythonhome == NULL) {
+        strcpy(buf, PYTHONPATH);
+        buf = strchr(buf, '\0');
+    }
+    else {
+        char *p = PYTHONPATH;
+        char *q;
+        size_t n;
+        for (;;) {
+            q = strchr(p, DELIM);
+            if (q == NULL)
+                n = strlen(p);
+            else
+                n = q-p;
+            if (p[0] == '.' && is_sep(p[1])) {
+                strcpy(buf, pythonhome);
+                buf = strchr(buf, '\0');
+                p++;
+                n--;
+            }
+            strncpy(buf, p, n);
+            buf += n;
+            if (q == NULL)
+                break;
+            *buf++ = DELIM;
+            p = q+1;
+        }
+    }
+    if (argv0_path) {
+        *buf++ = DELIM;
+        strcpy(buf, argv0_path);
+        buf = strchr(buf, '\0');
+    }
+    *buf = '\0';
 }
 
 
@@ -390,29 +390,29 @@
 char *
 Py_GetPath(void)
 {
-	if (!module_search_path)
-		calculate_path();
-	return module_search_path;
+    if (!module_search_path)
+        calculate_path();
+    return module_search_path;
 }
 
 char *
 Py_GetPrefix(void)
 {
-	if (!module_search_path)
-		calculate_path();
-	return prefix;
+    if (!module_search_path)
+        calculate_path();
+    return prefix;
 }
 
 char *
 Py_GetExecPrefix(void)
 {
-	return Py_GetPrefix();
+    return Py_GetPrefix();
 }
 
 char *
 Py_GetProgramFullPath(void)
 {
-	if (!module_search_path)
-		calculate_path();
-	return progpath;
+    if (!module_search_path)
+        calculate_path();
+    return progpath;
 }
diff --git a/PC/os2emx/pythonpm.c b/PC/os2emx/pythonpm.c
index 5accbbd..ba47f4b 100644
--- a/PC/os2emx/pythonpm.c
+++ b/PC/os2emx/pythonpm.c
@@ -27,10 +27,10 @@
 /* use structure to pass command line to Python thread */
 typedef struct
 {
-	int argc;
-	char **argv;
-	HWND Frame;
-	int running;
+    int argc;
+    char **argv;
+    HWND Frame;
+    int running;
 } arglist;
 
 /* make this a global to simplify access.
@@ -45,80 +45,80 @@
 int
 main(int argc, char **argv)
 {
-	ULONG FrameFlags = FCF_TITLEBAR |
-			   FCF_SYSMENU |
-			   FCF_SIZEBORDER |
-			   FCF_HIDEBUTTON |
-			   FCF_SHELLPOSITION |
-			   FCF_TASKLIST;
-	HAB hab;
-	HMQ hmq;
-	HWND Client;
-	QMSG qmsg;
-	arglist args;
-	int python_tid;
+    ULONG FrameFlags = FCF_TITLEBAR |
+                       FCF_SYSMENU |
+                       FCF_SIZEBORDER |
+                       FCF_HIDEBUTTON |
+                       FCF_SHELLPOSITION |
+                       FCF_TASKLIST;
+    HAB hab;
+    HMQ hmq;
+    HWND Client;
+    QMSG qmsg;
+    arglist args;
+    int python_tid;
 
-	/* init PM and create message queue */
-	hab = WinInitialize(0);
-	hmq = WinCreateMsgQueue(hab, 0);
+    /* init PM and create message queue */
+    hab = WinInitialize(0);
+    hmq = WinCreateMsgQueue(hab, 0);
 
-	/* create a (hidden) Window to house the window procedure */
-	args.Frame = WinCreateStdWindow(HWND_DESKTOP,
-					0,
-					&FrameFlags,
-					NULL,
-					"PythonPM",
-					0L,
-					0,
-					0,
-					&Client);
+    /* create a (hidden) Window to house the window procedure */
+    args.Frame = WinCreateStdWindow(HWND_DESKTOP,
+                                    0,
+                                    &FrameFlags,
+                                    NULL,
+                                    "PythonPM",
+                                    0L,
+                                    0,
+                                    0,
+                                    &Client);
 
-	/* run Python interpreter in a thread */
-	args.argc = argc;
-	args.argv = argv;
-	args.running = 0;
-	if (-1 == (python_tid = _beginthread(PythonThread, NULL, 1024 * 1024, &args)))
-	{
-		/* couldn't start thread */
-		WinAlarm(HWND_DESKTOP, WA_ERROR);
-		PythonRC = 1;
-	}
-	else
-	{
-		/* process PM messages, until Python exits */
-		while (WinGetMsg(hab, &qmsg, NULLHANDLE, 0, 0))
-			WinDispatchMsg(hab, &qmsg);
-		if (args.running > 0)
-			DosKillThread(python_tid);
-	}
-		
-	/* destroy window, shutdown message queue and PM */
-	WinDestroyWindow(args.Frame);
-	WinDestroyMsgQueue(hmq);
-	WinTerminate(hab);
+    /* run Python interpreter in a thread */
+    args.argc = argc;
+    args.argv = argv;
+    args.running = 0;
+    if (-1 == (python_tid = _beginthread(PythonThread, NULL, 1024 * 1024, &args)))
+    {
+        /* couldn't start thread */
+        WinAlarm(HWND_DESKTOP, WA_ERROR);
+        PythonRC = 1;
+    }
+    else
+    {
+        /* process PM messages, until Python exits */
+        while (WinGetMsg(hab, &qmsg, NULLHANDLE, 0, 0))
+            WinDispatchMsg(hab, &qmsg);
+        if (args.running > 0)
+            DosKillThread(python_tid);
+    }
 
-	return PythonRC;
+    /* destroy window, shutdown message queue and PM */
+    WinDestroyWindow(args.Frame);
+    WinDestroyMsgQueue(hmq);
+    WinTerminate(hab);
+
+    return PythonRC;
 }
 
 void PythonThread(void *argl)
 {
-	HAB hab;
-	arglist *args;
+    HAB hab;
+    arglist *args;
 
-	/* PM initialisation */
-	hab = WinInitialize(0);
+    /* PM initialisation */
+    hab = WinInitialize(0);
 
-	/* start Python */
-	args = (arglist *)argl;
-	args->running = 1;
-	PythonRC = Py_Main(args->argc, args->argv);
+    /* start Python */
+    args = (arglist *)argl;
+    args->running = 1;
+    PythonRC = Py_Main(args->argc, args->argv);
 
-	/* enter a critical section and send the termination message */
-	DosEnterCritSec();
-	args->running = 0;
-	WinPostMsg(args->Frame, WM_QUIT, NULL, NULL);
+    /* enter a critical section and send the termination message */
+    DosEnterCritSec();
+    args->running = 0;
+    WinPostMsg(args->Frame, WM_QUIT, NULL, NULL);
 
-	/* shutdown PM and terminate thread */
-	WinTerminate(hab);
-	_endthread();
+    /* shutdown PM and terminate thread */
+    WinTerminate(hab);
+    _endthread();
 }