+++ /dev/null
-/* Return the initial module search path. */\r
-\r
-#include "Python.h"\r
-#include "osdefs.h"\r
-\r
-#include <sys/types.h>\r
-#include <string.h>\r
-\r
-#ifdef __APPLE__\r
-#include <mach-o/dyld.h>\r
-#endif\r
-\r
-/* Search in some common locations for the associated Python libraries.\r
- *\r
- * Two directories must be found, the platform independent directory\r
- * (prefix), containing the common .py and .pyc files, and the platform\r
- * dependent directory (exec_prefix), containing the shared library\r
- * modules. Note that prefix and exec_prefix can be the same directory,\r
- * but for some installations, they are different.\r
- *\r
- * Py_GetPath() carries out separate searches for prefix and exec_prefix.\r
- * Each search tries a number of different locations until a ``landmark''\r
- * file or directory is found. If no prefix or exec_prefix is found, a\r
- * warning message is issued and the preprocessor defined PREFIX and\r
- * EXEC_PREFIX are used (even though they will not work); python carries on\r
- * as best as is possible, but most imports will fail.\r
- *\r
- * Before any searches are done, the location of the executable is\r
- * determined. If argv[0] has one or more slashes in it, it is used\r
- * unchanged. Otherwise, it must have been invoked from the shell's path,\r
- * so we search $PATH for the named executable and use that. If the\r
- * executable was not found on $PATH (or there was no $PATH environment\r
- * variable), the original argv[0] string is used.\r
- *\r
- * Next, the executable location is examined to see if it is a symbolic\r
- * link. If so, the link is chased (correctly interpreting a relative\r
- * pathname if one is found) and the directory of the link target is used.\r
- *\r
- * Finally, argv0_path is set to the directory containing the executable\r
- * (i.e. the last component is stripped).\r
- *\r
- * With argv0_path in hand, we perform a number of steps. The same steps\r
- * are performed for prefix and for exec_prefix, but with a different\r
- * landmark.\r
- *\r
- * Step 1. Are we running python out of the build directory? This is\r
- * checked by looking for a different kind of landmark relative to\r
- * argv0_path. For prefix, the landmark's path is derived from the VPATH\r
- * preprocessor variable (taking into account that its value is almost, but\r
- * not quite, what we need). For exec_prefix, the landmark is\r
- * Modules/Setup. If the landmark is found, we're done.\r
- *\r
- * For the remaining steps, the prefix landmark will always be\r
- * lib/python$VERSION/os.py and the exec_prefix will always be\r
- * lib/python$VERSION/lib-dynload, where $VERSION is Python's version\r
- * number as supplied by the Makefile. Note that this means that no more\r
- * build directory checking is performed; if the first step did not find\r
- * the landmarks, the assumption is that python is running from an\r
- * installed setup.\r
- *\r
- * Step 2. See if the $PYTHONHOME environment variable points to the\r
- * installed location of the Python libraries. If $PYTHONHOME is set, then\r
- * it points to prefix and exec_prefix. $PYTHONHOME can be a single\r
- * directory, which is used for both, or the prefix and exec_prefix\r
- * directories separated by a colon.\r
- *\r
- * Step 3. Try to find prefix and exec_prefix relative to argv0_path,\r
- * backtracking up the path until it is exhausted. This is the most common\r
- * step to succeed. Note that if prefix and exec_prefix are different,\r
- * exec_prefix is more likely to be found; however if exec_prefix is a\r
- * subdirectory of prefix, both will be found.\r
- *\r
- * Step 4. Search the directories pointed to by the preprocessor variables\r
- * PREFIX and EXEC_PREFIX. These are supplied by the Makefile but can be\r
- * passed in as options to the configure script.\r
- *\r
- * That's it!\r
- *\r
- * Well, almost. Once we have determined prefix and exec_prefix, the\r
- * preprocessor variable PYTHONPATH is used to construct a path. Each\r
- * relative path on PYTHONPATH is prefixed with prefix. Then the directory\r
- * containing the shared library modules is appended. The environment\r
- * variable $PYTHONPATH is inserted in front of it all. Finally, the\r
- * prefix and exec_prefix globals are tweaked so they reflect the values\r
- * expected by other code, by stripping the "lib/python$VERSION/..." stuff\r
- * off. If either points to the build directory, the globals are reset to\r
- * the corresponding preprocessor variables (so sys.prefix will reflect the\r
- * installation location, even though sys.path points into the build\r
- * directory). This seems to make more sense given that currently the only\r
- * known use of sys.prefix and sys.exec_prefix is for the ILU installation\r
- * process to find the installed Python tree.\r
- */\r
-\r
-#ifdef __cplusplus\r
- extern "C" {\r
-#endif\r
-\r
-\r
-#ifndef VERSION\r
-#define VERSION "2.1"\r
-#endif\r
-\r
-#ifndef VPATH\r
-#define VPATH "."\r
-#endif\r
-\r
-#ifndef PREFIX\r
-# ifdef __VMS\r
-# define PREFIX ""\r
-# else\r
-# define PREFIX "/usr/local"\r
-# endif\r
-#endif\r
-\r
-#ifndef EXEC_PREFIX\r
-#define EXEC_PREFIX PREFIX\r
-#endif\r
-\r
-#ifndef PYTHONPATH\r
-#define PYTHONPATH PREFIX "/lib/python" VERSION ":" \\r
- EXEC_PREFIX "/lib/python" VERSION "/lib-dynload"\r
-#endif\r
-\r
-#ifndef LANDMARK\r
-#define LANDMARK "os.py"\r
-#endif\r
-\r
-static char prefix[MAXPATHLEN+1];\r
-static char exec_prefix[MAXPATHLEN+1];\r
-static char progpath[MAXPATHLEN+1];\r
-static char *module_search_path = NULL;\r
-static char lib_python[] = "lib/python" VERSION;\r
-\r
-static void\r
-reduce(char *dir)\r
-{\r
- size_t i = strlen(dir);\r
- while (i > 0 && dir[i] != SEP)\r
- --i;\r
- dir[i] = '\0';\r
-}\r
-\r
-\r
-static int\r
-isfile(char *filename) /* Is file, not directory */\r
-{\r
- struct stat buf;\r
- if (stat(filename, &buf) != 0)\r
- return 0;\r
- if (!S_ISREG(buf.st_mode))\r
- return 0;\r
- return 1;\r
-}\r
-\r
-\r
-static int\r
-ismodule(char *filename) /* Is module -- check for .pyc/.pyo too */\r
-{\r
- if (isfile(filename))\r
- return 1;\r
-\r
- /* Check for the compiled version of prefix. */\r
- if (strlen(filename) < MAXPATHLEN) {\r
- strcat(filename, Py_OptimizeFlag ? "o" : "c");\r
- if (isfile(filename))\r
- return 1;\r
- }\r
- return 0;\r
-}\r
-\r
-\r
-static int\r
-isxfile(char *filename) /* Is executable file */\r
-{\r
- struct stat buf;\r
- if (stat(filename, &buf) != 0)\r
- return 0;\r
- if (!S_ISREG(buf.st_mode))\r
- return 0;\r
- if ((buf.st_mode & 0111) == 0)\r
- return 0;\r
- return 1;\r
-}\r
-\r
-\r
-static int\r
-isdir(char *filename) /* Is directory */\r
-{\r
- struct stat buf;\r
- if (stat(filename, &buf) != 0)\r
- return 0;\r
- if (!S_ISDIR(buf.st_mode))\r
- return 0;\r
- return 1;\r
-}\r
-\r
-\r
-/* Add a path component, by appending stuff to buffer.\r
- buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a\r
- NUL-terminated string with no more than MAXPATHLEN characters (not counting\r
- the trailing NUL). It's a fatal error if it contains a string longer than\r
- that (callers must be careful!). If these requirements are met, it's\r
- guaranteed that buffer will still be a NUL-terminated string with no more\r
- than MAXPATHLEN characters at exit. If stuff is too long, only as much of\r
- stuff as fits will be appended.\r
-*/\r
-static void\r
-joinpath(char *buffer, char *stuff)\r
-{\r
- size_t n, k;\r
- if (stuff[0] == SEP)\r
- n = 0;\r
- else {\r
- n = strlen(buffer);\r
- if (n > 0 && buffer[n-1] != SEP && n < MAXPATHLEN)\r
- buffer[n++] = SEP;\r
- }\r
- if (n > MAXPATHLEN)\r
- Py_FatalError("buffer overflow in getpath.c's joinpath()");\r
- k = strlen(stuff);\r
- if (n + k > MAXPATHLEN)\r
- k = MAXPATHLEN - n;\r
- strncpy(buffer+n, stuff, k);\r
- buffer[n+k] = '\0';\r
-}\r
-\r
-/* copy_absolute requires that path be allocated at least\r
- MAXPATHLEN + 1 bytes and that p be no more than MAXPATHLEN bytes. */\r
-static void\r
-copy_absolute(char *path, char *p)\r
-{\r
- if (p[0] == SEP)\r
- strcpy(path, p);\r
- else {\r
- if (!getcwd(path, MAXPATHLEN)) {\r
- /* unable to get the current directory */\r
- strcpy(path, p);\r
- return;\r
- }\r
- if (p[0] == '.' && p[1] == SEP)\r
- p += 2;\r
- joinpath(path, p);\r
- }\r
-}\r
-\r
-/* absolutize() requires that path be allocated at least MAXPATHLEN+1 bytes. */\r
-static void\r
-absolutize(char *path)\r
-{\r
- char buffer[MAXPATHLEN + 1];\r
-\r
- if (path[0] == SEP)\r
- return;\r
- copy_absolute(buffer, path);\r
- strcpy(path, buffer);\r
-}\r
-\r
-/* search_for_prefix requires that argv0_path be no more than MAXPATHLEN\r
- bytes long.\r
-*/\r
-static int\r
-search_for_prefix(char *argv0_path, char *home)\r
-{\r
- size_t n;\r
- char *vpath;\r
-\r
- /* If PYTHONHOME is set, we believe it unconditionally */\r
- if (home) {\r
- char *delim;\r
- strncpy(prefix, home, MAXPATHLEN);\r
- delim = strchr(prefix, DELIM);\r
- if (delim)\r
- *delim = '\0';\r
- joinpath(prefix, lib_python);\r
- joinpath(prefix, LANDMARK);\r
- return 1;\r
- }\r
-\r
- /* Check to see if argv[0] is in the build directory */\r
- strcpy(prefix, argv0_path);\r
- joinpath(prefix, "Modules/Setup");\r
- if (isfile(prefix)) {\r
- /* Check VPATH to see if argv0_path is in the build directory. */\r
- vpath = VPATH;\r
- strcpy(prefix, argv0_path);\r
- joinpath(prefix, vpath);\r
- joinpath(prefix, "Lib");\r
- joinpath(prefix, LANDMARK);\r
- if (ismodule(prefix))\r
- return -1;\r
- }\r
-\r
- /* Search from argv0_path, until root is found */\r
- copy_absolute(prefix, argv0_path);\r
- do {\r
- n = strlen(prefix);\r
- joinpath(prefix, lib_python);\r
- joinpath(prefix, LANDMARK);\r
- if (ismodule(prefix))\r
- return 1;\r
- prefix[n] = '\0';\r
- reduce(prefix);\r
- } while (prefix[0]);\r
-\r
- /* Look at configure's PREFIX */\r
- strncpy(prefix, PREFIX, MAXPATHLEN);\r
- joinpath(prefix, lib_python);\r
- joinpath(prefix, LANDMARK);\r
- if (ismodule(prefix))\r
- return 1;\r
-\r
- /* Fail */\r
- return 0;\r
-}\r
-\r
-\r
-/* search_for_exec_prefix requires that argv0_path be no more than\r
- MAXPATHLEN bytes long.\r
-*/\r
-static int\r
-search_for_exec_prefix(char *argv0_path, char *home)\r
-{\r
- size_t n;\r
-\r
- /* If PYTHONHOME is set, we believe it unconditionally */\r
- if (home) {\r
- char *delim;\r
- delim = strchr(home, DELIM);\r
- if (delim)\r
- strncpy(exec_prefix, delim+1, MAXPATHLEN);\r
- else\r
- strncpy(exec_prefix, home, MAXPATHLEN);\r
- joinpath(exec_prefix, lib_python);\r
- joinpath(exec_prefix, "lib-dynload");\r
- return 1;\r
- }\r
-\r
- /* Check to see if argv[0] is in the build directory */\r
- strcpy(exec_prefix, argv0_path);\r
- joinpath(exec_prefix, "Modules/Setup");\r
- if (isfile(exec_prefix)) {\r
- reduce(exec_prefix);\r
- return -1;\r
- }\r
-\r
- /* Search from argv0_path, until root is found */\r
- copy_absolute(exec_prefix, argv0_path);\r
- do {\r
- n = strlen(exec_prefix);\r
- joinpath(exec_prefix, lib_python);\r
- joinpath(exec_prefix, "lib-dynload");\r
- if (isdir(exec_prefix))\r
- return 1;\r
- exec_prefix[n] = '\0';\r
- reduce(exec_prefix);\r
- } while (exec_prefix[0]);\r
-\r
- /* Look at configure's EXEC_PREFIX */\r
- strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN);\r
- joinpath(exec_prefix, lib_python);\r
- joinpath(exec_prefix, "lib-dynload");\r
- if (isdir(exec_prefix))\r
- return 1;\r
-\r
- /* Fail */\r
- return 0;\r
-}\r
-\r
-\r
-static void\r
-calculate_path(void)\r
-{\r
- extern char *Py_GetProgramName(void);\r
-\r
- static char delimiter[2] = {DELIM, '\0'};\r
- static char separator[2] = {SEP, '\0'};\r
- char *pythonpath = PYTHONPATH;\r
- char *rtpypath = Py_GETENV("PYTHONPATH");\r
- char *home = Py_GetPythonHome();\r
- char *path = getenv("PATH");\r
- char *prog = Py_GetProgramName();\r
- char argv0_path[MAXPATHLEN+1];\r
- char zip_path[MAXPATHLEN+1];\r
- int pfound, efound; /* 1 if found; -1 if found build directory */\r
- char *buf;\r
- size_t bufsz;\r
- size_t prefixsz;\r
- char *defpath = pythonpath;\r
-#ifdef WITH_NEXT_FRAMEWORK\r
- NSModule pythonModule;\r
-#endif\r
-#ifdef __APPLE__\r
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4\r
- uint32_t nsexeclength = MAXPATHLEN;\r
-#else\r
- unsigned long nsexeclength = MAXPATHLEN;\r
-#endif\r
-#endif\r
-\r
- /* If there is no slash in the argv0 path, then we have to\r
- * assume python is on the user's $PATH, since there's no\r
- * other way to find a directory to start the search from. If\r
- * $PATH isn't exported, you lose.\r
- */\r
- if (strchr(prog, SEP))\r
- strncpy(progpath, prog, MAXPATHLEN);\r
-#ifdef __APPLE__\r
- /* On Mac OS X, if a script uses an interpreter of the form\r
- * "#!/opt/python2.3/bin/python", the kernel only passes "python"\r
- * as argv[0], which falls through to the $PATH search below.\r
- * If /opt/python2.3/bin isn't in your path, or is near the end,\r
- * this algorithm may incorrectly find /usr/bin/python. To work\r
- * around this, we can use _NSGetExecutablePath to get a better\r
- * hint of what the intended interpreter was, although this\r
- * will fail if a relative path was used. but in that case,\r
- * absolutize() should help us out below\r
- */\r
- else if(0 == _NSGetExecutablePath(progpath, &nsexeclength) && progpath[0] == SEP)\r
- ;\r
-#endif /* __APPLE__ */\r
- else if (path) {\r
- while (1) {\r
- char *delim = strchr(path, DELIM);\r
-\r
- if (delim) {\r
- size_t len = delim - path;\r
- if (len > MAXPATHLEN)\r
- len = MAXPATHLEN;\r
- strncpy(progpath, path, len);\r
- *(progpath + len) = '\0';\r
- }\r
- else\r
- strncpy(progpath, path, MAXPATHLEN);\r
-\r
- joinpath(progpath, prog);\r
- if (isxfile(progpath))\r
- break;\r
-\r
- if (!delim) {\r
- progpath[0] = '\0';\r
- break;\r
- }\r
- path = delim + 1;\r
- }\r
- }\r
- else\r
- progpath[0] = '\0';\r
- if (progpath[0] != SEP && progpath[0] != '\0')\r
- absolutize(progpath);\r
- strncpy(argv0_path, progpath, MAXPATHLEN);\r
- argv0_path[MAXPATHLEN] = '\0';\r
-\r
-#ifdef WITH_NEXT_FRAMEWORK\r
- /* On Mac OS X we have a special case if we're running from a framework.\r
- ** This is because the python home should be set relative to the library,\r
- ** which is in the framework, not relative to the executable, which may\r
- ** be outside of the framework. Except when we're in the build directory...\r
- */\r
- pythonModule = NSModuleForSymbol(NSLookupAndBindSymbol("_Py_Initialize"));\r
- /* Use dylib functions to find out where the framework was loaded from */\r
- buf = (char *)NSLibraryNameForModule(pythonModule);\r
- if (buf != NULL) {\r
- /* We're in a framework. */\r
- /* See if we might be in the build directory. The framework in the\r
- ** build directory is incomplete, it only has the .dylib and a few\r
- ** needed symlinks, it doesn't have the Lib directories and such.\r
- ** If we're running with the framework from the build directory we must\r
- ** be running the interpreter in the build directory, so we use the\r
- ** build-directory-specific logic to find Lib and such.\r
- */\r
- strncpy(argv0_path, buf, MAXPATHLEN);\r
- reduce(argv0_path);\r
- joinpath(argv0_path, lib_python);\r
- joinpath(argv0_path, LANDMARK);\r
- if (!ismodule(argv0_path)) {\r
- /* We are in the build directory so use the name of the\r
- executable - we know that the absolute path is passed */\r
- strncpy(argv0_path, progpath, MAXPATHLEN);\r
- }\r
- else {\r
- /* Use the location of the library as the progpath */\r
- strncpy(argv0_path, buf, MAXPATHLEN);\r
- }\r
- }\r
-#endif\r
-\r
-#if HAVE_READLINK\r
- {\r
- char tmpbuffer[MAXPATHLEN+1];\r
- int linklen = readlink(progpath, tmpbuffer, MAXPATHLEN);\r
- while (linklen != -1) {\r
- /* It's not null terminated! */\r
- tmpbuffer[linklen] = '\0';\r
- if (tmpbuffer[0] == SEP)\r
- /* tmpbuffer should never be longer than MAXPATHLEN,\r
- but extra check does not hurt */\r
- strncpy(argv0_path, tmpbuffer, MAXPATHLEN);\r
- else {\r
- /* Interpret relative to progpath */\r
- reduce(argv0_path);\r
- joinpath(argv0_path, tmpbuffer);\r
- }\r
- linklen = readlink(argv0_path, tmpbuffer, MAXPATHLEN);\r
- }\r
- }\r
-#endif /* HAVE_READLINK */\r
-\r
- reduce(argv0_path);\r
- /* At this point, argv0_path is guaranteed to be less than\r
- MAXPATHLEN bytes long.\r
- */\r
-\r
- if (!(pfound = search_for_prefix(argv0_path, home))) {\r
- if (!Py_FrozenFlag)\r
- fprintf(stderr,\r
- "Could not find platform independent libraries <prefix>\n");\r
- strncpy(prefix, PREFIX, MAXPATHLEN);\r
- joinpath(prefix, lib_python);\r
- }\r
- else\r
- reduce(prefix);\r
-\r
- strncpy(zip_path, prefix, MAXPATHLEN);\r
- zip_path[MAXPATHLEN] = '\0';\r
- if (pfound > 0) { /* Use the reduced prefix returned by Py_GetPrefix() */\r
- reduce(zip_path);\r
- reduce(zip_path);\r
- }\r
- else\r
- strncpy(zip_path, PREFIX, MAXPATHLEN);\r
- joinpath(zip_path, "lib/python00.zip");\r
- bufsz = strlen(zip_path); /* Replace "00" with version */\r
- zip_path[bufsz - 6] = VERSION[0];\r
- zip_path[bufsz - 5] = VERSION[2];\r
-\r
- if (!(efound = search_for_exec_prefix(argv0_path, home))) {\r
- if (!Py_FrozenFlag)\r
- fprintf(stderr,\r
- "Could not find platform dependent libraries <exec_prefix>\n");\r
- strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN);\r
- joinpath(exec_prefix, "lib/lib-dynload");\r
- }\r
- /* If we found EXEC_PREFIX do *not* reduce it! (Yet.) */\r
-\r
- if ((!pfound || !efound) && !Py_FrozenFlag)\r
- fprintf(stderr,\r
- "Consider setting $PYTHONHOME to <prefix>[:<exec_prefix>]\n");\r
-\r
- /* Calculate size of return buffer.\r
- */\r
- bufsz = 0;\r
-\r
- if (rtpypath)\r
- bufsz += strlen(rtpypath) + 1;\r
-\r
- prefixsz = strlen(prefix) + 1;\r
-\r
- while (1) {\r
- char *delim = strchr(defpath, DELIM);\r
-\r
- if (defpath[0] != SEP)\r
- /* Paths are relative to prefix */\r
- bufsz += prefixsz;\r
-\r
- if (delim)\r
- bufsz += delim - defpath + 1;\r
- else {\r
- bufsz += strlen(defpath) + 1;\r
- break;\r
- }\r
- defpath = delim + 1;\r
- }\r
-\r
- bufsz += strlen(zip_path) + 1;\r
- bufsz += strlen(exec_prefix) + 1;\r
-\r
- /* This is the only malloc call in this file */\r
- buf = (char *)PyMem_Malloc(bufsz);\r
-\r
- if (buf == NULL) {\r
- /* We can't exit, so print a warning and limp along */\r
- fprintf(stderr, "Not enough memory for dynamic PYTHONPATH.\n");\r
- fprintf(stderr, "Using default static PYTHONPATH.\n");\r
- module_search_path = PYTHONPATH;\r
- }\r
- else {\r
- /* Run-time value of $PYTHONPATH goes first */\r
- if (rtpypath) {\r
- strcpy(buf, rtpypath);\r
- strcat(buf, delimiter);\r
- }\r
- else\r
- buf[0] = '\0';\r
-\r
- /* Next is the default zip path */\r
- strcat(buf, zip_path);\r
- strcat(buf, delimiter);\r
-\r
- /* Next goes merge of compile-time $PYTHONPATH with\r
- * dynamically located prefix.\r
- */\r
- defpath = pythonpath;\r
- while (1) {\r
- char *delim = strchr(defpath, DELIM);\r
-\r
- if (defpath[0] != SEP) {\r
- strcat(buf, prefix);\r
- strcat(buf, separator);\r
- }\r
-\r
- if (delim) {\r
- size_t len = delim - defpath + 1;\r
- size_t end = strlen(buf) + len;\r
- strncat(buf, defpath, len);\r
- *(buf + end) = '\0';\r
- }\r
- else {\r
- strcat(buf, defpath);\r
- break;\r
- }\r
- defpath = delim + 1;\r
- }\r
- strcat(buf, delimiter);\r
-\r
- /* Finally, on goes the directory for dynamic-load modules */\r
- strcat(buf, exec_prefix);\r
-\r
- /* And publish the results */\r
- module_search_path = buf;\r
- }\r
-\r
- /* Reduce prefix and exec_prefix to their essence,\r
- * e.g. /usr/local/lib/python1.5 is reduced to /usr/local.\r
- * If we're loading relative to the build directory,\r
- * return the compiled-in defaults instead.\r
- */\r
- if (pfound > 0) {\r
- reduce(prefix);\r
- reduce(prefix);\r
- /* The prefix is the root directory, but reduce() chopped\r
- * off the "/". */\r
- if (!prefix[0])\r
- strcpy(prefix, separator);\r
- }\r
- else\r
- strncpy(prefix, PREFIX, MAXPATHLEN);\r
-\r
- if (efound > 0) {\r
- reduce(exec_prefix);\r
- reduce(exec_prefix);\r
- reduce(exec_prefix);\r
- if (!exec_prefix[0])\r
- strcpy(exec_prefix, separator);\r
- }\r
- else\r
- strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN);\r
-}\r
-\r
-\r
-/* External interface */\r
-\r
-char *\r
-Py_GetPath(void)\r
-{\r
- if (!module_search_path)\r
- calculate_path();\r
- return module_search_path;\r
-}\r
-\r
-char *\r
-Py_GetPrefix(void)\r
-{\r
- if (!module_search_path)\r
- calculate_path();\r
- return prefix;\r
-}\r
-\r
-char *\r
-Py_GetExecPrefix(void)\r
-{\r
- if (!module_search_path)\r
- calculate_path();\r
- return exec_prefix;\r
-}\r
-\r
-char *\r
-Py_GetProgramFullPath(void)\r
-{\r
- if (!module_search_path)\r
- calculate_path();\r
- return progpath;\r
-}\r
-\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
-\r
projects / mirror_edk2.git / blobdiff