Untabify C files. Will watch buildbots.

1 files changed, 476 insertions, 476 deletions

diff --git a/PC/getpathp.c b/PC/getpathp.c
index 78f4465..461f9fc 100644
--- a/PC/getpathp.c
+++ b/PC/getpathp.c
@@ -4,8 +4,8 @@
 
 /* ----------------------------------------------------------------
    PATH RULES FOR WINDOWS:
-   This describes how sys.path is formed on Windows.  It describes the 
-   functionality, not the implementation (ie, the order in which these 
+   This describes how sys.path is formed on Windows.  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
@@ -24,15 +24,15 @@
    * 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, lib-tk, 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, have not had a PYTHONPATH
      specified, and can't locate any Registry entries (ie, we have _nothing_
-     we can assume is a good path), a default path with relative entries is 
+     we can assume is a good path), a default path with relative entries is
      used (eg. .\Lib;.\plat-win, etc)
 
 
@@ -42,9 +42,9 @@
     the core path is deduced, and the core paths in the registry are
     ignored.  Other "application paths" in the registry are always read.
 
-  * 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
@@ -92,12 +92,12 @@ static char *module_search_path = NULL;
 
 
 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
 }
 
@@ -107,36 +107,36 @@ is_sep(char ch)	/* determine if "ch" is a separator character */
 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;
 }
 
-/* Assumes 'filename' MAXPATHLEN+1 bytes long - 
+/* Assumes 'filename' MAXPATHLEN+1 bytes long -
    may extend 'filename' by one character.
 */
 static int
-ismodule(char *filename)	/* Is module -- check for .pyc/.pyo too */
+ismodule(char *filename)        /* Is module -- check for .pyc/.pyo too */
 {
-	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;
+    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;
 }
 
 /* Add a path component, by appending stuff to buffer.
@@ -151,21 +151,21 @@ ismodule(char *filename)	/* Is module -- check for .pyc/.pyo too */
 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
@@ -175,29 +175,29 @@ join(char *buffer, char *stuff)
 static int
 gotlandmark(char *landmark)
 {
-	int ok;
-	Py_ssize_t n;
-
-	n = strlen(prefix);
-	join(prefix, landmark);
-	ok = ismodule(prefix);
-	prefix[n] = '\0';
-	return ok;
+    int ok;
+    Py_ssize_t n;
+
+    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;
 }
 
 #ifdef MS_WINDOWS
@@ -223,146 +223,146 @@ extern const char *PyWin_DLLVersionString;
 static char *
 getpythonregpath(HKEY keyBase, int skipcore)
 {
-	HKEY newKey = 0;
-	DWORD dataSize = 0;
-	DWORD numKeys = 0;
-	LONG rc;
-	char *retval = NULL;
-	TCHAR *dataBuf = NULL;
-	static const TCHAR keyPrefix[] = _T("Software\\Python\\PythonCore\\");
-	static const TCHAR keySuffix[] = _T("\\PythonPath");
-	size_t versionLen;
-	DWORD index;
-	TCHAR *keyBuf = NULL;
-	TCHAR *keyBufPtr;
-	TCHAR **ppPaths = NULL;
-
-	/* Tried to use sysget("winver") but here is too early :-( */
-	versionLen = _tcslen(PyWin_DLLVersionString);
-	/* Space for all the chars, plus one \0 */
-	keyBuf = keyBufPtr = malloc(sizeof(keyPrefix) + 
-		                    sizeof(TCHAR)*(versionLen-1) + 
-				    sizeof(keySuffix));
-	if (keyBuf==NULL) goto done;
-
-	memcpy(keyBufPtr, keyPrefix, sizeof(keyPrefix)-sizeof(TCHAR));
-	keyBufPtr += sizeof(keyPrefix)/sizeof(TCHAR) - 1;
-	memcpy(keyBufPtr, PyWin_DLLVersionString, versionLen * sizeof(TCHAR));
-	keyBufPtr += versionLen;
-	/* NULL comes with this one! */
-	memcpy(keyBufPtr, keySuffix, sizeof(keySuffix));
-	/* Open the root Python key */
-	rc=RegOpenKeyEx(keyBase,
-	                keyBuf, /* subkey */
-	                0, /* reserved */
-	                KEY_READ,
-	                &newKey);
-	if (rc!=ERROR_SUCCESS) goto done;
-	/* Find out how big our core buffer is, and how many subkeys we have */
-	rc = RegQueryInfoKey(newKey, NULL, NULL, NULL, &numKeys, NULL, NULL, 
-	                NULL, NULL, &dataSize, NULL, NULL);
-	if (rc!=ERROR_SUCCESS) goto done;
-	if (skipcore) dataSize = 0; /* Only count core ones if we want them! */
-	/* Allocate a temp array of char buffers, so we only need to loop 
-	   reading the registry once
-	*/
-	ppPaths = malloc( sizeof(TCHAR *) * numKeys );
-	if (ppPaths==NULL) goto done;
-	memset(ppPaths, 0, sizeof(TCHAR *) * numKeys);
-	/* Loop over all subkeys, allocating a temp sub-buffer. */
-	for(index=0;index<numKeys;index++) {
-		TCHAR keyBuf[MAX_PATH+1];
-		HKEY subKey = 0;
-		DWORD reqdSize = MAX_PATH+1;
-		/* Get the sub-key name */
-		DWORD rc = RegEnumKeyEx(newKey, index, keyBuf, &reqdSize,
-		                        NULL, NULL, NULL, NULL );
-		if (rc!=ERROR_SUCCESS) goto done;
-		/* Open the sub-key */
-		rc=RegOpenKeyEx(newKey,
-						keyBuf, /* subkey */
-						0, /* reserved */
-						KEY_READ,
-						&subKey);
-		if (rc!=ERROR_SUCCESS) goto done;
-		/* Find the value of the buffer size, malloc, then read it */
-		RegQueryValueEx(subKey, NULL, 0, NULL, NULL, &reqdSize);
-		if (reqdSize) {
-			ppPaths[index] = malloc(reqdSize);
-			if (ppPaths[index]) {
-				RegQueryValueEx(subKey, NULL, 0, NULL, 
-				                (LPBYTE)ppPaths[index], 
-				                &reqdSize);
-				dataSize += reqdSize + 1; /* 1 for the ";" */
-			}
-		}
-		RegCloseKey(subKey);
-	}
-
-	/* return null if no path to return */
-	if (dataSize == 0) goto done;
-
-	/* original datasize from RegQueryInfo doesn't include the \0 */
-	dataBuf = malloc((dataSize+1) * sizeof(TCHAR));
-	if (dataBuf) {
-		TCHAR *szCur = dataBuf;
-		DWORD reqdSize = dataSize;
-		/* Copy our collected strings */
-		for (index=0;index<numKeys;index++) {
-			if (index > 0) {
-				*(szCur++) = _T(';');
-				dataSize--;
-			}
-			if (ppPaths[index]) {
-				Py_ssize_t len = _tcslen(ppPaths[index]);
-				_tcsncpy(szCur, ppPaths[index], len);
-				szCur += len;
-				assert(dataSize > (DWORD)len);
-				dataSize -= (DWORD)len;
-			}
-		}
-		if (skipcore)
-			*szCur = '\0';
-		else {
-			/* If we have no values, we dont need a ';' */
-			if (numKeys) {
-				*(szCur++) = _T(';');
-				dataSize--;
-			}
-			/* Now append the core path entries - 
-			   this will include the NULL 
-			*/
-			rc = RegQueryValueEx(newKey, NULL, 0, NULL, 
-			                     (LPBYTE)szCur, &dataSize);
-		}
-		/* And set the result - caller must free 
-		   If MBCS, it is fine as is.  If Unicode, allocate new
-		   buffer and convert.
-		*/
+    HKEY newKey = 0;
+    DWORD dataSize = 0;
+    DWORD numKeys = 0;
+    LONG rc;
+    char *retval = NULL;
+    TCHAR *dataBuf = NULL;
+    static const TCHAR keyPrefix[] = _T("Software\\Python\\PythonCore\\");
+    static const TCHAR keySuffix[] = _T("\\PythonPath");
+    size_t versionLen;
+    DWORD index;
+    TCHAR *keyBuf = NULL;
+    TCHAR *keyBufPtr;
+    TCHAR **ppPaths = NULL;
+
+    /* Tried to use sysget("winver") but here is too early :-( */
+    versionLen = _tcslen(PyWin_DLLVersionString);
+    /* Space for all the chars, plus one \0 */
+    keyBuf = keyBufPtr = malloc(sizeof(keyPrefix) +
+                                sizeof(TCHAR)*(versionLen-1) +
+                                sizeof(keySuffix));
+    if (keyBuf==NULL) goto done;
+
+    memcpy(keyBufPtr, keyPrefix, sizeof(keyPrefix)-sizeof(TCHAR));
+    keyBufPtr += sizeof(keyPrefix)/sizeof(TCHAR) - 1;
+    memcpy(keyBufPtr, PyWin_DLLVersionString, versionLen * sizeof(TCHAR));
+    keyBufPtr += versionLen;
+    /* NULL comes with this one! */
+    memcpy(keyBufPtr, keySuffix, sizeof(keySuffix));
+    /* Open the root Python key */
+    rc=RegOpenKeyEx(keyBase,
+                    keyBuf, /* subkey */
+            0, /* reserved */
+            KEY_READ,
+            &newKey);
+    if (rc!=ERROR_SUCCESS) goto done;
+    /* Find out how big our core buffer is, and how many subkeys we have */
+    rc = RegQueryInfoKey(newKey, NULL, NULL, NULL, &numKeys, NULL, NULL,
+                    NULL, NULL, &dataSize, NULL, NULL);
+    if (rc!=ERROR_SUCCESS) goto done;
+    if (skipcore) dataSize = 0; /* Only count core ones if we want them! */
+    /* Allocate a temp array of char buffers, so we only need to loop
+       reading the registry once
+    */
+    ppPaths = malloc( sizeof(TCHAR *) * numKeys );
+    if (ppPaths==NULL) goto done;
+    memset(ppPaths, 0, sizeof(TCHAR *) * numKeys);
+    /* Loop over all subkeys, allocating a temp sub-buffer. */
+    for(index=0;index<numKeys;index++) {
+        TCHAR keyBuf[MAX_PATH+1];
+        HKEY subKey = 0;
+        DWORD reqdSize = MAX_PATH+1;
+        /* Get the sub-key name */
+        DWORD rc = RegEnumKeyEx(newKey, index, keyBuf, &reqdSize,
+                                NULL, NULL, NULL, NULL );
+        if (rc!=ERROR_SUCCESS) goto done;
+        /* Open the sub-key */
+        rc=RegOpenKeyEx(newKey,
+                                        keyBuf, /* subkey */
+                        0, /* reserved */
+                        KEY_READ,
+                        &subKey);
+        if (rc!=ERROR_SUCCESS) goto done;
+        /* Find the value of the buffer size, malloc, then read it */
+        RegQueryValueEx(subKey, NULL, 0, NULL, NULL, &reqdSize);
+        if (reqdSize) {
+            ppPaths[index] = malloc(reqdSize);
+            if (ppPaths[index]) {
+                RegQueryValueEx(subKey, NULL, 0, NULL,
+                                (LPBYTE)ppPaths[index],
+                                &reqdSize);
+                dataSize += reqdSize + 1; /* 1 for the ";" */
+            }
+        }
+        RegCloseKey(subKey);
+    }
+
+    /* return null if no path to return */
+    if (dataSize == 0) goto done;
+
+    /* original datasize from RegQueryInfo doesn't include the \0 */
+    dataBuf = malloc((dataSize+1) * sizeof(TCHAR));
+    if (dataBuf) {
+        TCHAR *szCur = dataBuf;
+        DWORD reqdSize = dataSize;
+        /* Copy our collected strings */
+        for (index=0;index<numKeys;index++) {
+            if (index > 0) {
+                *(szCur++) = _T(';');
+                dataSize--;
+            }
+            if (ppPaths[index]) {
+                Py_ssize_t len = _tcslen(ppPaths[index]);
+                _tcsncpy(szCur, ppPaths[index], len);
+                szCur += len;
+                assert(dataSize > (DWORD)len);
+                dataSize -= (DWORD)len;
+            }
+        }
+        if (skipcore)
+            *szCur = '\0';
+        else {
+            /* If we have no values, we dont need a ';' */
+            if (numKeys) {
+                *(szCur++) = _T(';');
+                dataSize--;
+            }
+            /* Now append the core path entries -
+               this will include the NULL
+            */
+            rc = RegQueryValueEx(newKey, NULL, 0, NULL,
+                                 (LPBYTE)szCur, &dataSize);
+        }
+        /* And set the result - caller must free
+           If MBCS, it is fine as is.  If Unicode, allocate new
+           buffer and convert.
+        */
 #ifdef UNICODE
-		retval = (char *)malloc(reqdSize+1);
-		if (retval)
-			WideCharToMultiByte(CP_ACP, 0, 
-					dataBuf, -1, /* source */ 
-					retval, reqdSize+1, /* dest */
-					NULL, NULL);
-		free(dataBuf);
+        retval = (char *)malloc(reqdSize+1);
+        if (retval)
+            WideCharToMultiByte(CP_ACP, 0,
+                            dataBuf, -1, /* source */
+                    retval, reqdSize+1, /* dest */
+                    NULL, NULL);
+        free(dataBuf);
 #else
-		retval = dataBuf;
+        retval = dataBuf;
 #endif
-	}
+    }
 done:
-	/* Loop freeing my temp buffers */
-	if (ppPaths) {
-		for(index=0;index<numKeys;index++)
-			if (ppPaths[index]) free(ppPaths[index]);
-		free(ppPaths);
-	}
-	if (newKey)
-		RegCloseKey(newKey);
-	if (keyBuf)
-		free(keyBuf);
-	return retval;
+    /* Loop freeing my temp buffers */
+    if (ppPaths) {
+        for(index=0;index<numKeys;index++)
+            if (ppPaths[index]) free(ppPaths[index]);
+        free(ppPaths);
+    }
+    if (newKey)
+        RegCloseKey(newKey);
+    if (keyBuf)
+        free(keyBuf);
+    return retval;
 }
 #endif /* Py_ENABLE_SHARED */
 #endif /* MS_WINDOWS */
@@ -370,314 +370,314 @@ done:
 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();
 
 #ifdef MS_WINDOWS
-	extern HANDLE PyWin_DLLhModule;
+    extern HANDLE PyWin_DLLhModule;
 #ifdef UNICODE
-	WCHAR wprogpath[MAXPATHLEN+1];
-	/* Windows documents that GetModuleFileName() will "truncate",
-	   but makes no mention of the null terminator.  Play it safe.
-	   PLUS Windows itself defines MAX_PATH as the same, but anyway...
-	*/
+    WCHAR wprogpath[MAXPATHLEN+1];
+    /* Windows documents that GetModuleFileName() will "truncate",
+       but makes no mention of the null terminator.  Play it safe.
+       PLUS Windows itself defines MAX_PATH as the same, but anyway...
+    */
 #ifdef Py_ENABLE_SHARED
-	wprogpath[MAXPATHLEN]=_T('\0');
-	if (PyWin_DLLhModule &&
-	    GetModuleFileName(PyWin_DLLhModule, wprogpath, MAXPATHLEN)) {
-		WideCharToMultiByte(CP_ACP, 0, 
-		                    wprogpath, -1, 
-		                    dllpath, MAXPATHLEN+1, 
-		                    NULL, NULL);
-	}
+    wprogpath[MAXPATHLEN]=_T('\0');
+    if (PyWin_DLLhModule &&
+        GetModuleFileName(PyWin_DLLhModule, wprogpath, MAXPATHLEN)) {
+        WideCharToMultiByte(CP_ACP, 0,
+                            wprogpath, -1,
+                            dllpath, MAXPATHLEN+1,
+                            NULL, NULL);
+    }
 #else
-	dllpath[0] = 0;
+    dllpath[0] = 0;
 #endif
-	wprogpath[MAXPATHLEN]=_T('\0');
-	if (GetModuleFileName(NULL, wprogpath, MAXPATHLEN)) {
-		WideCharToMultiByte(CP_ACP, 0, 
-		                    wprogpath, -1, 
-		                    progpath, MAXPATHLEN+1, 
-		                    NULL, NULL);
-		return;
-	}
+    wprogpath[MAXPATHLEN]=_T('\0');
+    if (GetModuleFileName(NULL, wprogpath, MAXPATHLEN)) {
+        WideCharToMultiByte(CP_ACP, 0,
+                            wprogpath, -1,
+                            progpath, MAXPATHLEN+1,
+                            NULL, NULL);
+        return;
+    }
 #else
-	/* static init of progpath ensures final char remains \0 */
+    /* static init of progpath ensures final char remains \0 */
 #ifdef Py_ENABLE_SHARED
-	if (PyWin_DLLhModule)
-		if (!GetModuleFileName(PyWin_DLLhModule, dllpath, MAXPATHLEN))
-			dllpath[0] = 0;
+    if (PyWin_DLLhModule)
+        if (!GetModuleFileName(PyWin_DLLhModule, dllpath, MAXPATHLEN))
+            dllpath[0] = 0;
 #else
-	dllpath[0] = 0;
+    dllpath[0] = 0;
 #endif
-	if (GetModuleFileName(NULL, progpath, MAXPATHLEN))
-		return;
+    if (GetModuleFileName(NULL, progpath, MAXPATHLEN))
+        return;
 #endif
 #endif
-	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 (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.
+     */
 #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);
-
-			if (delim) {
-				size_t len = delim - path;
-				/* ensure we can't overwrite buffer */
-				len = min(MAXPATHLEN,len);
-				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;
-
-			if (!delim) {
-				progpath[0] = '\0';
-				break;
-			}
-			path = delim + 1;
-		}
-	}
-	else
-		progpath[0] = '\0';
+        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 */
+                len = min(MAXPATHLEN,len);
+                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;
+
+            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 = Py_GETENV("PYTHONPATH");
+    char argv0_path[MAXPATHLEN+1];
+    char *buf;
+    size_t bufsz;
+    char *pythonhome = Py_GetPythonHome();
+    char *envpath = Py_GETENV("PYTHONPATH");
 
 #ifdef MS_WINDOWS
-	int skiphome, skipdefault;
-	char *machinepath = NULL;
-	char *userpath = NULL;
-	char zip_path[MAXPATHLEN+1];
-	size_t len;
+    int skiphome, skipdefault;
+    char *machinepath = NULL;
+    char *userpath = NULL;
+    char zip_path[MAXPATHLEN+1];
+    size_t len;
 #endif
 
-	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;
 
 
 #ifdef MS_WINDOWS
-	/* Calculate zip archive path */
-	if (dllpath[0])		/* use name of python DLL */
-		strncpy(zip_path, dllpath, MAXPATHLEN);
-	else			/* use name of executable program */
-		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;
-	}
- 
-	skiphome = pythonhome==NULL ? 0 : 1;
+    /* Calculate zip archive path */
+    if (dllpath[0])             /* use name of python DLL */
+        strncpy(zip_path, dllpath, MAXPATHLEN);
+    else                        /* use name of executable program */
+        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;
+    }
+
+    skiphome = pythonhome==NULL ? 0 : 1;
 #ifdef Py_ENABLE_SHARED
-	machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, skiphome);
-	userpath = getpythonregpath(HKEY_CURRENT_USER, skiphome);
+    machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, skiphome);
+    userpath = getpythonregpath(HKEY_CURRENT_USER, skiphome);
 #endif
-	/* We only use the default relative PYTHONPATH if we havent
-	   anything better to use! */
-	skipdefault = envpath!=NULL || pythonhome!=NULL || \
-		      machinepath!=NULL || userpath!=NULL;
+    /* We only use the default relative PYTHONPATH if we havent
+       anything better to use! */
+    skipdefault = envpath!=NULL || pythonhome!=NULL || \
+                  machinepath!=NULL || userpath!=NULL;
 #endif
 
-	/* We need to construct a path from the following parts.
-	   (1) the PYTHONPATH environment variable, if set;
-	   (2) for Win32, the zip archive file path;
-	   (3) for Win32, the machinepath and userpath, if set;
-	   (4) the PYTHONPATH config macro, with the leading "."
-	       of each component replaced with pythonhome, if set;
-	   (5) the directory containing the executable (argv0_path).
-	   The length calculation calculates #4 first.
-	   Extra rules:
-	   - If PYTHONHOME is set (in any way) item (3) is ignored.
-	   - If registry values are used, (4) and (5) are ignored.
-	*/
-
-	/* 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;
+    /* We need to construct a path from the following parts.
+       (1) the PYTHONPATH environment variable, if set;
+       (2) for Win32, the zip archive file path;
+       (3) for Win32, the machinepath and userpath, if set;
+       (4) the PYTHONPATH config macro, with the leading "."
+           of each component replaced with pythonhome, if set;
+       (5) the directory containing the executable (argv0_path).
+       The length calculation calculates #4 first.
+       Extra rules:
+       - If PYTHONHOME is set (in any way) item (3) is ignored.
+       - If registry values are used, (4) and (5) are ignored.
+    */
+
+    /* 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;
 #ifdef MS_WINDOWS
-	if (userpath)
-		bufsz += strlen(userpath) + 1;
-	if (machinepath)
-		bufsz += strlen(machinepath) + 1;
-	bufsz += strlen(zip_path) + 1;
+    if (userpath)
+        bufsz += strlen(userpath) + 1;
+    if (machinepath)
+        bufsz += strlen(machinepath) + 1;
+    bufsz += strlen(zip_path) + 1;
 #endif
-	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;
-		}
+    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;
+        }
 #ifdef MS_WINDOWS
-		if (machinepath)
-			free(machinepath);
-		if (userpath)
-			free(userpath);
+        if (machinepath)
+            free(machinepath);
+        if (userpath)
+            free(userpath);
 #endif /* MS_WINDOWS */
-		return;
-	}
-
-	if (envpath) {
-		strcpy(buf, envpath);
-		buf = strchr(buf, '\0');
-		*buf++ = DELIM;
-	}
+        return;
+    }
+
+    if (envpath) {
+        strcpy(buf, envpath);
+        buf = strchr(buf, '\0');
+        *buf++ = DELIM;
+    }
 #ifdef MS_WINDOWS
-	if (zip_path[0]) {
-		strcpy(buf, zip_path);
-		buf = strchr(buf, '\0');
-		*buf++ = DELIM;
-	}
-	if (userpath) {
-		strcpy(buf, userpath);
-		buf = strchr(buf, '\0');
-		*buf++ = DELIM;
-		free(userpath);
-	}
-	if (machinepath) {
-		strcpy(buf, machinepath);
-		buf = strchr(buf, '\0');
-		*buf++ = DELIM;
-		free(machinepath);
-	}
-	if (pythonhome == NULL) {
-		if (!skipdefault) {
-			strcpy(buf, PYTHONPATH);
-			buf = strchr(buf, '\0');
-		}
-	}
+    if (zip_path[0]) {
+        strcpy(buf, zip_path);
+        buf = strchr(buf, '\0');
+        *buf++ = DELIM;
+    }
+    if (userpath) {
+        strcpy(buf, userpath);
+        buf = strchr(buf, '\0');
+        *buf++ = DELIM;
+        free(userpath);
+    }
+    if (machinepath) {
+        strcpy(buf, machinepath);
+        buf = strchr(buf, '\0');
+        *buf++ = DELIM;
+        free(machinepath);
+    }
+    if (pythonhome == NULL) {
+        if (!skipdefault) {
+            strcpy(buf, PYTHONPATH);
+            buf = strchr(buf, '\0');
+        }
+    }
 #else
-	if (pythonhome == NULL) {
-		strcpy(buf, PYTHONPATH);
-		buf = strchr(buf, '\0');
-	}
+    if (pythonhome == NULL) {
+        strcpy(buf, PYTHONPATH);
+        buf = strchr(buf, '\0');
+    }
 #endif /* MS_WINDOWS */
-	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';
-	/* Now to pull one last hack/trick.  If sys.prefix is
-	   empty, then try and find it somewhere on the paths
-	   we calculated.  We scan backwards, as our general policy
-	   is that Python core directories are at the *end* of
-	   sys.path.  We assume that our "lib" directory is
-	   on the path, and that our 'prefix' directory is
-	   the parent of that.
-	*/
-	if (*prefix=='\0') {
-		char lookBuf[MAXPATHLEN+1];
-		char *look = buf - 1; /* 'buf' is at the end of the buffer */
-		while (1) {
-			Py_ssize_t nchars;
-			char *lookEnd = look;
-			/* 'look' will end up one character before the
-			   start of the path in question - even if this
-			   is one character before the start of the buffer
-			*/
-			while (look >= module_search_path && *look != DELIM)
-				look--;
-			nchars = lookEnd-look;
-			strncpy(lookBuf, look+1, nchars);
-			lookBuf[nchars] = '\0';
-			/* Up one level to the parent */
-			reduce(lookBuf);
-			if (search_for_prefix(lookBuf, LANDMARK)) {
-				break;
-			}
-			/* If we are out of paths to search - give up */
-			if (look < module_search_path)
-				break;
-			look--;
-		}
-	}
+    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';
+    /* Now to pull one last hack/trick.  If sys.prefix is
+       empty, then try and find it somewhere on the paths
+       we calculated.  We scan backwards, as our general policy
+       is that Python core directories are at the *end* of
+       sys.path.  We assume that our "lib" directory is
+       on the path, and that our 'prefix' directory is
+       the parent of that.
+    */
+    if (*prefix=='\0') {
+        char lookBuf[MAXPATHLEN+1];
+        char *look = buf - 1; /* 'buf' is at the end of the buffer */
+        while (1) {
+            Py_ssize_t nchars;
+            char *lookEnd = look;
+            /* 'look' will end up one character before the
+               start of the path in question - even if this
+               is one character before the start of the buffer
+            */
+            while (look >= module_search_path && *look != DELIM)
+                look--;
+            nchars = lookEnd-look;
+            strncpy(lookBuf, look+1, nchars);
+            lookBuf[nchars] = '\0';
+            /* Up one level to the parent */
+            reduce(lookBuf);
+            if (search_for_prefix(lookBuf, LANDMARK)) {
+                break;
+            }
+            /* If we are out of paths to search - give up */
+            if (look < module_search_path)
+                break;
+            look--;
+        }
+    }
 }
 
 
@@ -686,29 +686,29 @@ calculate_path(void)
 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;
 }