mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-09-26 18:29:57 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 10

Revamped path access again, by Mark Hammond, to be more robust in the

Browse source 
light of three different situations: (1) running from build; (2)
running from installed; (3) running without being able to find an
installation (e.g. as a COM object).  The system paths in the
repository are only used for (3); the path deduced from the
installation location are used otherwise.  PYTHONHOME overrides in all
cases.

Read the comments for more details.
This commit is contained in:
Guido van Rossum 2000-03-30 19:45:39 +00:00
parent d30dedca27
commit 88716bba55
1 changed files with 194 additions and 92 deletions
Download patch file Download diff file Expand all files Collapse all files

286
PC/getpathp.c
View file

@ -32,12 +32,64 @@ PERFORMANCE OF THIS SOFTWARE.
/* Return the initial module search path. */ /* Return the initial module search path. */
/* Used by DOS, OS/2, Windows 3.1, Windows 95/98, Windows NT. */ /* Used by DOS, OS/2, Windows 3.1, Windows 95/98, Windows NT. */
/* ----------------------------------------------------------------
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
are actually fetched is different)
* Python always adds an empty entry at the start, which corresponds
to the current directory.
* If the PYTHONPATH env. var. exists, it's entries are added next.
* We look in the registry for "application paths" - that is, sub-keys
under the main PythonPath registry key. These are added next (the
order of sub-key processing is undefined).
HKEY_CURRENT_USER is searched and added first.
HKEY_LOCAL_MACHINE is searched and added next.
(Note that all known installers only use HKLM, so HKCU is typically
empty)
* 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\\string.py) and deduce our home.
- 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,
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
used (eg. .\Lib;.\plat-win, etc)
The end result of all this is:
* When running python.exe, or any other .exe in the main Python directory
(either an installed version, or directly from the PCbuild directory),
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
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
always read.
* If Python can't find its home and there is no registry (eg, frozen
exe, some very strange installation setup) you get a path with
some default, but relative, paths.
---------------------------------------------------------------- */
#include "Python.h" #include "Python.h"
#include "osdefs.h" #include "osdefs.h"
#ifdef MS_WIN32 #ifdef MS_WIN32
#include <windows.h> #include <windows.h>
extern BOOL PyWin_IsWin32s(); #include <tchar.h>
#endif #endif
#include <sys/types.h> #include <sys/types.h>
@ -168,107 +220,146 @@ search_for_prefix(argv0_path, landmark)
#ifdef MS_WIN32 #ifdef MS_WIN32
#ifndef BUILD_LANDMARK /* a string loaded from the DLL at startup.*/
#define BUILD_LANDMARK "PC\\getpathp.c" extern const char *PyWin_DLLVersionString;
#endif
#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 a PYTHONPATH value from the registry.
Load from either HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER. Load from either HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER.
Works in both Unicode and 8bit environments. Only uses the
Ex family of functions so it also works with Windows CE.
Returns NULL, or a pointer that should be freed. Returns NULL, or a pointer that should be freed.
*/ */
static char * static char *
getpythonregpath(HKEY keyBase) getpythonregpath(HKEY keyBase, int skipcore)
{ {
HKEY newKey = 0; HKEY newKey = 0;
DWORD nameSize = 0;
DWORD dataSize = 0; DWORD dataSize = 0;
DWORD numEntries = 0; DWORD numKeys = 0;
LONG rc; LONG rc;
char *retval = NULL; char *retval = NULL;
char *dataBuf; TCHAR *dataBuf = NULL;
const char keyPrefix[] = "Software\\Python\\PythonCore\\"; static const TCHAR keyPrefix[] = _T("Software\\Python\\PythonCore\\");
const char keySuffix[] = "\\PythonPath"; static const TCHAR keySuffix[] = _T("\\PythonPath");
int versionLen; int versionLen;
char *keyBuf; DWORD index;
TCHAR *keyBuf = NULL;
TCHAR *keyBufPtr;
TCHAR **ppPaths = NULL;
// Tried to use sysget("winver") but here is too early :-( /* Tried to use sysget("winver") but here is too early :-( */
versionLen = strlen(PyWin_DLLVersionString); versionLen = _tcslen(PyWin_DLLVersionString);
// alloca == no free required, but memory only local to fn. /* Space for all the chars, plus one \0 */
// also no heap fragmentation! Am I being silly? keyBuf = keyBufPtr = malloc(sizeof(keyPrefix) +
keyBuf = alloca(sizeof(keyPrefix)-1 + versionLen + sizeof(keySuffix)); // chars only, plus 1 NULL. sizeof(TCHAR)*(versionLen-1) +
// lots of constants here for the compiler to optimize away :-) sizeof(keySuffix));
memcpy(keyBuf, keyPrefix, sizeof(keyPrefix)-1); if (keyBuf==NULL) goto done;
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, memcpy(keyBufPtr, keyPrefix, sizeof(keyPrefix)-sizeof(TCHAR));
keyBuf, keyBufPtr += sizeof(keyPrefix)/sizeof(TCHAR) - 1;
&newKey); memcpy(keyBufPtr, PyWin_DLLVersionString, versionLen * sizeof(TCHAR));
if (rc==ERROR_SUCCESS) { keyBufPtr += versionLen;
RegQueryInfoKey(newKey, NULL, NULL, NULL, NULL, NULL, NULL, /* NULL comes with this one! */
&numEntries, &nameSize, &dataSize, NULL, NULL); memcpy(keyBufPtr, keySuffix, sizeof(keySuffix));
} /* Open the root Python key */
if (numEntries) { rc=RegOpenKeyEx(keyBase,
/* Loop over all subkeys. */ keyBuf, /* subkey */
/* Win32s doesnt know how many subkeys, so we do 0, /* reserved */
it twice */ KEY_READ,
char keyBuf[MAX_PATH+1]; &newKey);
int index = 0; if (rc!=ERROR_SUCCESS) goto done;
int off = 0; /* Find out how big our core buffer is, and how many subkeys we have */
for(index=0;;index++) { rc = RegQueryInfoKey(newKey, NULL, NULL, NULL, &numKeys, NULL, NULL,
long reqdSize = 0; NULL, NULL, &dataSize, NULL, NULL);
DWORD rc = RegEnumKey(newKey, if (rc!=ERROR_SUCCESS) goto done;
index, keyBuf, MAX_PATH+1); if (skipcore) dataSize = 0; /* Only count core ones if we want them! */
if (rc) break; /* Allocate a temp array of char buffers, so we only need to loop
rc = RegQueryValue(newKey, keyBuf, NULL, &reqdSize); reading the registry once
if (rc) break; */
dataSize += reqdSize + 1; /* 1 for the ";" */ ppPaths = malloc( sizeof(TCHAR *) * numKeys );
} if (ppPaths==NULL) goto done;
dataBuf = malloc(dataSize+1); memset(ppPaths, 0, sizeof(TCHAR *) * numKeys);
if (dataBuf==NULL) /* Loop over all subkeys, allocating a temp sub-buffer. */
return NULL; /* pretty serious? Raise error? */ for(index=0;index<numKeys;index++) {
/* Now loop over, grabbing the paths. TCHAR keyBuf[MAX_PATH+1];
Subkeys before main library */ HKEY subKey = 0;
for(index=0;;index++) { DWORD reqdSize = MAX_PATH+1;
int adjust; /* Get the sub-key name */
long reqdSize = dataSize; DWORD rc = RegEnumKeyEx(newKey, index, keyBuf, &reqdSize,
DWORD rc = RegEnumKey(newKey, NULL, NULL, NULL, NULL );
index, keyBuf,MAX_PATH+1); if (rc!=ERROR_SUCCESS) goto done;
if (rc) break; /* Open the sub-key */
rc = RegQueryValue(newKey, rc=RegOpenKeyEx(newKey,
keyBuf, dataBuf+off, &reqdSize); keyBuf, /* subkey */
if (rc) break; 0, /* reserved */
if (reqdSize>1) { KEY_READ,
/* If Nothing, or only '\0' copied. */ &subKey);
adjust = strlen(dataBuf+off); if (rc!=ERROR_SUCCESS) goto done;
dataSize -= adjust; /* Find the value of the buffer size, malloc, then read it */
off += adjust; RegQueryValueEx(subKey, NULL, 0, NULL, NULL, &reqdSize);
dataBuf[off++] = ';'; if (reqdSize) {
dataBuf[off] = '\0'; ppPaths[index] = malloc(reqdSize);
dataSize--; if (ppPaths[index]) {
RegQueryValueEx(subKey, NULL, 0, NULL, (LPBYTE)ppPaths[index], &reqdSize);
dataSize += reqdSize + 1; /* 1 for the ";" */
} }
} }
/* Additionally, win32s doesnt work as expected, so RegCloseKey(subKey);
the specific strlen() is required for 3.1. */ }
rc = RegQueryValue(newKey, "", dataBuf+off, &dataSize); dataBuf = malloc((dataSize+1) * sizeof(TCHAR));
if (rc==ERROR_SUCCESS) { if (dataBuf) {
if (strlen(dataBuf)==0) TCHAR *szCur = dataBuf;
free(dataBuf); DWORD reqdSize = dataSize;
else /* Copy our collected strings */
retval = dataBuf; /* caller will free */ for (index=0;index<numKeys;index++) {
} int len;
else if (index > 0) {
free(dataBuf); *(szCur++) = _T(';');
dataSize--;
}
len = _tcslen(ppPaths[index]);
_tcsncpy(szCur, ppPaths[index], len);
szCur += len;
dataSize -= len;
}
if (skipcore)
*szCur = '\0';
else {
*(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, dataSize+1, /* dest */
NULL, NULL);
free(dataBuf);
#else
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) if (newKey)
RegCloseKey(newKey); RegCloseKey(newKey);
if (keyBuf)
free(keyBuf);
return retval; return retval;
} }
#endif /* MS_WIN32 */ #endif /* MS_WIN32 */
@ -281,8 +372,16 @@ get_progpath()
char *prog = Py_GetProgramName(); char *prog = Py_GetProgramName();
#ifdef MS_WIN32 #ifdef MS_WIN32
#ifdef UNICODE
WCHAR wprogpath[MAXPATHLEN+1];
if (GetModuleFileName(NULL, wprogpath, MAXPATHLEN)) {
WideCharToMultiByte(CP_ACP, 0, wprogpath, -1, progpath, MAXPATHLEN+1, NULL, NULL);
return;
}
#else
if (GetModuleFileName(NULL, progpath, MAXPATHLEN)) if (GetModuleFileName(NULL, progpath, MAXPATHLEN))
return; return;
#endif
#endif #endif
if (prog == NULL || *prog == '\0') if (prog == NULL || *prog == '\0')
prog = "python"; prog = "python";
@ -335,7 +434,7 @@ calculate_path()
char *envpath = getenv("PYTHONPATH"); char *envpath = getenv("PYTHONPATH");
#ifdef MS_WIN32 #ifdef MS_WIN32
int skiphome = 0; int skiphome, skipdefault;
char *machinepath = NULL; char *machinepath = NULL;
char *userpath = NULL; char *userpath = NULL;
#endif #endif
@ -357,10 +456,13 @@ calculate_path()
#ifdef MS_WIN32 #ifdef MS_WIN32
if (!gotlandmark(BUILD_LANDMARK)) { skiphome = pythonhome==NULL ? 0 : 1;
machinepath = getpythonregpath(HKEY_LOCAL_MACHINE); machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, skiphome);
userpath = getpythonregpath(HKEY_CURRENT_USER); userpath = getpythonregpath(HKEY_CURRENT_USER, skiphome);
} /* We only use the default relative PYTHONPATH if we havent
anything better to use! */
skipdefault = envpath!=NULL || pythonhome!=NULL || \
machinepath!=NULL || userpath!=NULL;
#endif #endif
/* We need to construct a path from the following parts. /* We need to construct a path from the following parts.
@ -430,24 +532,25 @@ calculate_path()
buf = strchr(buf, '\0'); buf = strchr(buf, '\0');
*buf++ = DELIM; *buf++ = DELIM;
free(userpath); free(userpath);
skiphome = 1;
} }
if (machinepath) { if (machinepath) {
strcpy(buf, machinepath); strcpy(buf, machinepath);
buf = strchr(buf, '\0'); buf = strchr(buf, '\0');
*buf++ = DELIM; *buf++ = DELIM;
free(machinepath); free(machinepath);
skiphome = 1;
} }
if (skiphome) { if (pythonhome == NULL) {
*buf = 0; if (!skipdefault) {
return; strcpy(buf, PYTHONPATH);
buf = strchr(buf, '\0');
}
} }
#endif #else
if (pythonhome == NULL) { if (pythonhome == NULL) {
strcpy(buf, PYTHONPATH); strcpy(buf, PYTHONPATH);
buf = strchr(buf, '\0'); buf = strchr(buf, '\0');
} }
#endif /* MS_WIN32 */
else { else {
char *p = PYTHONPATH; char *p = PYTHONPATH;
char *q; char *q;
@ -512,4 +615,3 @@ Py_GetProgramFullPath()
calculate_path(); calculate_path();
return progpath; return progpath;
} }