text: 
  /* Return the initial module search path. */
  /* Used by DOS, OS/2, Windows 3.1.  Works on NT too. */
  
  #include "Python.h"
  #include "osdefs.h"
  
  #ifdef MS_WIN32
  #include <windows.h>
  extern BOOL PyWin_IsWin32s(void);
  #endif
  
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <string.h>
  
  #if HAVE_UNISTD_H
  #include <unistd.h>
  #endif /* HAVE_UNISTD_H */
  
  /* Search in some common locations for the associated Python libraries.
   *
   * Two directories must be found, the platform independent directory
   * (prefix), containing the common .py and .pyc files, and the platform
   * dependent directory (exec_prefix), containing the shared library
   * modules.  Note that prefix and exec_prefix can be the same directory,
   * but for some installations, they are different.
   *
   * Py_GetPath() tries to return a sensible Python module search path.
   *
   * First, we look to see if the executable is in a subdirectory of
   * the Python build directory.  We calculate the full path of the
   * directory containing the executable as progpath.  We work backwards
   * along progpath and look for $dir/Modules/Setup.in, a distinctive
   * landmark.  If found, we use $dir/Lib as $root.  The returned
   * Python path is the compiled #define PYTHONPATH with all the initial
   * "./lib" replaced by $root.
   *
   * Otherwise, if there is a PYTHONPATH environment variable, we return that.
   *
   * Otherwise we try to find $progpath/lib/os.py, and if found, then
   * root is $progpath/lib, and we return Python path as compiled PYTHONPATH
   * with all "./lib" replaced by $root (as above).
   *
   */
  
  #ifndef LANDMARK
  #define LANDMARK "lib\\os.py"
  #endif
  
  static char prefix[MAXPATHLEN+1];
  static char exec_prefix[MAXPATHLEN+1];
  static char progpath[MAXPATHLEN+1];
  static char *module_search_path = NULL;
  
  
  static int
  is_sep(char ch)	/* determine if "ch" is a separator character */
  {
  #ifdef ALTSEP
  	return ch == SEP || ch == ALTSEP;
  #else
  	return ch == SEP;
  #endif
  }
  
  
  static void
  reduce(char *dir)
  {
  	int 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;
  }
  
  
  static void
  join(char *buffer, char *stuff)
  {
  	int 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;
  	}
  	k = strlen(stuff);
  	if (n + k > MAXPATHLEN)
  		k = MAXPATHLEN - n;
  	strncpy(buffer+n, stuff, k);
  	buffer[n+k] = '\0';
  }
  
  
  static int
  search_for_prefix(char *argv0_path, char *landmark)
  {
  	int n;
  
  	/* Search from argv0_path, until root is found */
  	strcpy(prefix, argv0_path);
  	do {
  		n = strlen(prefix);
  		join(prefix, landmark);
  		if (exists(prefix)) {
  			prefix[n] = '\0';
  			return 1;
  		}
  		prefix[n] = '\0';
  		reduce(prefix);
  	} while (prefix[0]);
  	return 0;
  }
  
  #ifdef MS_WIN32
  #include "malloc.h" // for alloca - see comments below!
  extern const char *PyWin_DLLVersionString; // a string loaded from the DLL at startup.
  
  
  /* Load a PYTHONPATH value from the registry.
     Load from either HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER.
  
     Returns NULL, or a pointer that should be freed.
  */
  
  static char *
  getpythonregpath(HKEY keyBase, BOOL bWin32s)
  {
  	HKEY newKey = 0;
  	DWORD nameSize = 0;
  	DWORD dataSize = 0;
  	DWORD numEntries = 0;
  	LONG rc;
  	char *retval = NULL;
  	char *dataBuf;
  	const char keyPrefix[] = "Software\\Python\\PythonCore\\";
  	const char keySuffix[] = "\\PythonPath";
  	int versionLen;
  	char *keyBuf;
  
  	// Tried to use sysget("winver") but here is too early :-(
  	versionLen = strlen(PyWin_DLLVersionString);
  	// alloca == no free required, but memory only local to fn.
  	// also no heap fragmentation!  Am I being silly?
  	keyBuf = alloca(sizeof(keyPrefix)-1 + versionLen + sizeof(keySuffix)); // chars only, plus 1 NULL.
  	// lots of constants here for the compiler to optimize away :-)
  	memcpy(keyBuf, keyPrefix, sizeof(keyPrefix)-1);
  	memcpy(keyBuf+sizeof(keyPrefix)-1, PyWin_DLLVersionString, versionLen);
  	memcpy(keyBuf+sizeof(keyPrefix)-1+versionLen, keySuffix, sizeof(keySuffix)); // NULL comes with this one!
  
  	rc=RegOpenKey(keyBase,
  		      keyBuf,
  		      &newKey);
  	if (rc==ERROR_SUCCESS) {
  		RegQueryInfoKey(newKey, NULL, NULL, NULL, NULL, NULL, NULL, 
  		                &numEntries, &nameSize, &dataSize, NULL, NULL);
  	}
  	if (bWin32s && numEntries==0 && dataSize==0) {
  		/* must hardcode for Win32s */
  		numEntries = 1;
  		dataSize = 511;
  	}
  	if (numEntries) {
  		/* Loop over all subkeys. */
  		/* Win32s doesnt know how many subkeys, so we do
  		   it twice */
  		char keyBuf[MAX_PATH+1];
  		int index = 0;
  		int off = 0;
  		for(index=0;;index++) {
  			long reqdSize = 0;
  			DWORD rc = RegEnumKey(newKey,
  					      index, keyBuf, MAX_PATH+1);
  			if (rc) break;
  			rc = RegQueryValue(newKey, keyBuf, NULL, &reqdSize);
  			if (rc) break;
  			if (bWin32s && reqdSize==0) reqdSize = 512;
  			dataSize += reqdSize + 1; /* 1 for the ";" */
  		}
  		dataBuf = malloc(dataSize+1);
  		if (dataBuf==NULL)
  			return NULL; /* pretty serious?  Raise error? */
  		/* Now loop over, grabbing the paths.
  		   Subkeys before main library */
  		for(index=0;;index++) {
  			int adjust;
  			long reqdSize = dataSize;
  			DWORD rc = RegEnumKey(newKey,
  					      index, keyBuf,MAX_PATH+1);
  			if (rc) break;
  			rc = RegQueryValue(newKey,
  					   keyBuf, dataBuf+off, &reqdSize);
  			if (rc) break;
  			if (reqdSize>1) {
  				/* If Nothing, or only '\0' copied. */
  				adjust = strlen(dataBuf+off);
  				dataSize -= adjust;
  				off += adjust;
  				dataBuf[off++] = ';';
  				dataBuf[off] = '\0';
  				dataSize--;
  			}
  		}
  		/* Additionally, win32s doesnt work as expected, so
  		   the specific strlen() is required for 3.1. */
  		rc = RegQueryValue(newKey, "", dataBuf+off, &dataSize);
  		if (rc==ERROR_SUCCESS) {
  			if (strlen(dataBuf)==0)
  				free(dataBuf);
  			else
  				retval = dataBuf; /* caller will free */
  		}
  		else
  			free(dataBuf);
  	}
  
  	if (newKey)
  		RegCloseKey(newKey);
  	return retval;
  }
  #endif /* MS_WIN32 */
  
  static void
  get_progpath(void)
  {
  	extern char *Py_GetProgramName(void);
  	char *path = getenv("PATH");
  	char *prog = Py_GetProgramName();
  
  #ifdef MS_WIN32
  	if (GetModuleFileName(NULL, progpath, MAXPATHLEN))
  		return;
  #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.
  	 */
  #ifdef ALTSEP
  	if (strchr(prog, SEP) || strchr(prog, ALTSEP))
  #else
  	if (strchr(prog, SEP))
  #endif
  		strcpy(progpath, prog);
  	else if (path) {
  		while (1) {
  			char *delim = strchr(path, DELIM);
  
  			if (delim) {
  				int len = delim - path;
  				strncpy(progpath, path, len);
  				*(progpath + len) = '\0';
  			}
  			else
  				strcpy(progpath, path);
  
  			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;
  	int bufsz;
  	char *pythonhome = Py_GetPythonHome();
  	char *envpath = getenv("PYTHONPATH");
  #ifdef MS_WIN32
  	char *machinepath, *userpath;
  
  	/* Are we running under Windows 3.1(1) Win32s? */
  	if (PyWin_IsWin32s()) {
  		/* Only CLASSES_ROOT is supported */
  		machinepath = getpythonregpath(HKEY_CLASSES_ROOT, TRUE); 
  		userpath = NULL;
  	} else {
  		machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, FALSE);
  		userpath = getpythonregpath(HKEY_CURRENT_USER, FALSE);
  	}
  #endif
  
  	get_progpath();
  	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 {
          char *delim;
  
  		strcpy(prefix, pythonhome);
  
          /* Extract Any Optional Trailing EXEC_PREFIX */
          /* e.g. PYTHONHOME=<prefix>:<exec_prefix>   */
          delim = strchr(prefix, DELIM);
          if (delim) {
              *delim = '\0';
              strcpy(exec_prefix, delim+1);
          } else
              strcpy(exec_prefix, EXEC_PREFIX);
      }
  
  	if (envpath && *envpath == '\0')
  		envpath = NULL;
  
  	/* We need to construct a path from the following parts:
  	   (1) the PYTHONPATH environment variable, if set;
  	   (2) for Win32, the machinepath and userpath, if set;
  	   (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;
  	if (envpath != NULL)
  		bufsz += strlen(envpath) + 1;
  	bufsz += strlen(argv0_path) + 1;
  #ifdef MS_WIN32
  	if (machinepath)
  		bufsz += strlen(machinepath) + 1;
  	if (userpath)
  		bufsz += strlen(userpath) + 1;
  #endif
  
  	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 default static $PYTHONPATH.\n");
  			module_search_path = envpath;
  		}
  		else {
  			fprintf(stderr, "Using environment $PYTHONPATH.\n");
  			module_search_path = PYTHONPATH;
  		}
  		return;
  	}
  
  	if (envpath) {
  		strcpy(buf, envpath);
  		buf = strchr(buf, '\0');
  		*buf++ = DELIM;
  	}
  #ifdef MS_WIN32
  	if (machinepath) {
  		strcpy(buf, machinepath);
  		buf = strchr(buf, '\0');
  		*buf++ = DELIM;
  	}
  	if (userpath) {
  		strcpy(buf, userpath);
  		buf = strchr(buf, '\0');
  		*buf++ = DELIM;
  	}
  #endif
  	if (pythonhome == NULL) {
  		strcpy(buf, PYTHONPATH);
  		buf = strchr(buf, '\0');
  	}
  	else {
  		char *p = PYTHONPATH;
  		char *q;
  		int 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';
  }
  
  
  /* External interface */
  
  char *
  Py_GetPath(void)
  {
  	if (!module_search_path)
  		calculate_path();
  
  	return module_search_path;
  }
  
  char *
  Py_GetPrefix(void)
  {
  	if (!module_search_path)
  		calculate_path();
  
  	return prefix;
  }
  
  char *
  Py_GetExecPrefix(void)
  {
  	if (!module_search_path)
  		calculate_path();
  
  	return exec_prefix;
  }
  
  char *
  Py_GetProgramFullPath(void)
  {
  	if (!module_search_path)
  		calculate_path();
  
  	return progpath;
  }
  