mirror of
https://github.com/python/cpython.git
synced 2025-10-30 01:47:38 +00:00
f95a1b3c53
svn+ssh://pythondev@svn.python.org/python/trunk ........ r81029 | antoine.pitrou | 2010-05-09 16:46:46 +0200 (dim., 09 mai 2010) | 3 lines Untabify C files. Will watch buildbots. ........
482 lines
13 KiB
C
482 lines
13 KiB
C
|
|
/* 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;
|
|
}
|
|
|
|
|
|
/* Add a path component, by appending stuff to buffer.
|
|
buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a
|
|
NUL-terminated string with no more than MAXPATHLEN characters (not counting
|
|
the trailing NUL). It's a fatal error if it contains a string longer than
|
|
that (callers must be careful!). If these requirements are met, it's
|
|
guaranteed that buffer will still be a NUL-terminated string with no more
|
|
than MAXPATHLEN characters at exit. If stuff is too long, only as much of
|
|
stuff as fits will be appended.
|
|
*/
|
|
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;
|
|
}
|
|
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';
|
|
}
|
|
|
|
|
|
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 = Py_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;
|
|
}
|