Showing the changes to sys/src/cmd/python/Modules/getpath.c (1 of 3706 files). Show all
Unified · Split
| @@ -0,0 +1,694 @@ | |||
| 1 | /* Return the initial module search path. */ | ||
| 2 | |||
| 3 | #include "Python.h" | ||
| 4 | #include "osdefs.h" | ||
| 5 | |||
| 6 | #include <sys/types.h> | ||
| 7 | #include <string.h> | ||
| 8 | |||
| 9 | #ifdef __APPLE__ | ||
| 10 | #include <mach-o/dyld.h> | ||
| 11 | #endif | ||
| 12 | |||
| 13 | /* Search in some common locations for the associated Python libraries. | ||
| 14 | * | ||
| 15 | * Two directories must be found, the platform independent directory | ||
| 16 | * (prefix), containing the common .py and .pyc files, and the platform | ||
| 17 | * dependent directory (exec_prefix), containing the shared library | ||
| 18 | * modules. Note that prefix and exec_prefix can be the same directory, | ||
| 19 | * but for some installations, they are different. | ||
| 20 | * | ||
| 21 | * Py_GetPath() carries out separate searches for prefix and exec_prefix. | ||
| 22 | * Each search tries a number of different locations until a ``landmark'' | ||
| 23 | * file or directory is found. If no prefix or exec_prefix is found, a | ||
| 24 | * warning message is issued and the preprocessor defined PREFIX and | ||
| 25 | * EXEC_PREFIX are used (even though they will not work); python carries on | ||
| 26 | * as best as is possible, but most imports will fail. | ||
| 27 | * | ||
| 28 | * Before any searches are done, the location of the executable is | ||
| 29 | * determined. If argv[0] has one or more slashs in it, it is used | ||
| 30 | * unchanged. Otherwise, it must have been invoked from the shell's path, | ||
| 31 | * so we search $PATH for the named executable and use that. If the | ||
| 32 | * executable was not found on $PATH (or there was no $PATH environment | ||
| 33 | * variable), the original argv[0] string is used. | ||
| 34 | * | ||
| 35 | * Next, the executable location is examined to see if it is a symbolic | ||
| 36 | * link. If so, the link is chased (correctly interpreting a relative | ||
| 37 | * pathname if one is found) and the directory of the link target is used. | ||
| 38 | * | ||
| 39 | * Finally, argv0_path is set to the directory containing the executable | ||
| 40 | * (i.e. the last component is stripped). | ||
| 41 | * | ||
| 42 | * With argv0_path in hand, we perform a number of steps. The same steps | ||
| 43 | * are performed for prefix and for exec_prefix, but with a different | ||
| 44 | * landmark. | ||
| 45 | * | ||
| 46 | * Step 1. Are we running python out of the build directory? This is | ||
| 47 | * checked by looking for a different kind of landmark relative to | ||
| 48 | * argv0_path. For prefix, the landmark's path is derived from the VPATH | ||
| 49 | * preprocessor variable (taking into account that its value is almost, but | ||
| 50 | * not quite, what we need). For exec_prefix, the landmark is | ||
| 51 | * Modules/Setup. If the landmark is found, we're done. | ||
| 52 | * | ||
| 53 | * For the remaining steps, the prefix landmark will always be | ||
| 54 | * lib/python$VERSION/os.py and the exec_prefix will always be | ||
| 55 | * lib/python$VERSION/lib-dynload, where $VERSION is Python's version | ||
| 56 | * number as supplied by the Makefile. Note that this means that no more | ||
| 57 | * build directory checking is performed; if the first step did not find | ||
| 58 | * the landmarks, the assumption is that python is running from an | ||
| 59 | * installed setup. | ||
| 60 | * | ||
| 61 | * Step 2. See if the $PYTHONHOME environment variable points to the | ||
| 62 | * installed location of the Python libraries. If $PYTHONHOME is set, then | ||
| 63 | * it points to prefix and exec_prefix. $PYTHONHOME can be a single | ||
| 64 | * directory, which is used for both, or the prefix and exec_prefix | ||
| 65 | * directories separated by a colon. | ||
| 66 | * | ||
| 67 | * Step 3. Try to find prefix and exec_prefix relative to argv0_path, | ||
| 68 | * backtracking up the path until it is exhausted. This is the most common | ||
| 69 | * step to succeed. Note that if prefix and exec_prefix are different, | ||
| 70 | * exec_prefix is more likely to be found; however if exec_prefix is a | ||
| 71 | * subdirectory of prefix, both will be found. | ||
| 72 | * | ||
| 73 | * Step 4. Search the directories pointed to by the preprocessor variables | ||
| 74 | * PREFIX and EXEC_PREFIX. These are supplied by the Makefile but can be | ||
| 75 | * passed in as options to the configure script. | ||
| 76 | * | ||
| 77 | * That's it! | ||
| 78 | * | ||
| 79 | * Well, almost. Once we have determined prefix and exec_prefix, the | ||
| 80 | * preprocessor variable PYTHONPATH is used to construct a path. Each | ||
| 81 | * relative path on PYTHONPATH is prefixed with prefix. Then the directory | ||
| 82 | * containing the shared library modules is appended. The environment | ||
| 83 | * variable $PYTHONPATH is inserted in front of it all. Finally, the | ||
| 84 | * prefix and exec_prefix globals are tweaked so they reflect the values | ||
| 85 | * expected by other code, by stripping the "lib/python$VERSION/..." stuff | ||
| 86 | * off. If either points to the build directory, the globals are reset to | ||
| 87 | * the corresponding preprocessor variables (so sys.prefix will reflect the | ||
| 88 | * installation location, even though sys.path points into the build | ||
| 89 | * directory). This seems to make more sense given that currently the only | ||
| 90 | * known use of sys.prefix and sys.exec_prefix is for the ILU installation | ||
| 91 | * process to find the installed Python tree. | ||
| 92 | */ | ||
| 93 | |||
| 94 | #ifdef __cplusplus | ||
| 95 | extern "C" { | ||
| 96 | #endif | ||
| 97 | |||
| 98 | |||
| 99 | #ifndef VERSION | ||
| 100 | #define VERSION "2.1" | ||
| 101 | #endif | ||
| 102 | |||
| 103 | #ifndef VPATH | ||
| 104 | #define VPATH "." | ||
| 105 | #endif | ||
| 106 | |||
| 107 | #ifndef PREFIX | ||
| 108 | # ifdef __VMS | ||
| 109 | # define PREFIX "" | ||
| 110 | # else | ||
| 111 | # define PREFIX "/usr/local" | ||
| 112 | # endif | ||
| 113 | #endif | ||
| 114 | |||
| 115 | #ifndef EXEC_PREFIX | ||
| 116 | #define EXEC_PREFIX PREFIX | ||
| 117 | #endif | ||
| 118 | |||
| 119 | #ifndef PYTHONPATH | ||
| 120 | #define PYTHONPATH PREFIX "/lib/python" VERSION ":" \ | ||
| 121 | EXEC_PREFIX "/lib/python" VERSION "/lib-dynload" | ||
| 122 | #endif | ||
| 123 | |||
| 124 | #ifndef LANDMARK | ||
| 125 | #define LANDMARK "os.py" | ||
| 126 | #endif | ||
| 127 | |||
| 128 | static char prefix[MAXPATHLEN+1]; | ||
| 129 | static char exec_prefix[MAXPATHLEN+1]; | ||
| 130 | static char progpath[MAXPATHLEN+1]; | ||
| 131 | static char *module_search_path = NULL; | ||
| 132 | static char lib_python[] = "lib/python" VERSION; | ||
| 133 | |||
| 134 | static void | ||
| 135 | reduce(char *dir) | ||
| 136 | { | ||
| 137 | size_t i = strlen(dir); | ||
| 138 | while (i > 0 && dir[i] != SEP) | ||
| 139 | --i; | ||
| 140 | dir[i] = '\0'; | ||
| 141 | } | ||
| 142 | |||
| 143 | |||
| 144 | static int | ||
| 145 | isfile(char *filename) /* Is file, not directory */ | ||
| 146 | { | ||
| 147 | struct stat buf; | ||
| 148 | if (stat(filename, &buf) != 0) | ||
| 149 | return 0; | ||
| 150 | if (!S_ISREG(buf.st_mode)) | ||
| 151 | return 0; | ||
| 152 | return 1; | ||
| 153 | } | ||
| 154 | |||
| 155 | |||
| 156 | static int | ||
| 157 | ismodule(char *filename) /* Is module -- check for .pyc/.pyo too */ | ||
| 158 | { | ||
| 159 | if (isfile(filename)) | ||
| 160 | return 1; | ||
| 161 | |||
| 162 | /* Check for the compiled version of prefix. */ | ||
| 163 | if (strlen(filename) < MAXPATHLEN) { | ||
| 164 | strcat(filename, Py_OptimizeFlag ? "o" : "c"); | ||
| 165 | if (isfile(filename)) | ||
| 166 | return 1; | ||
| 167 | } | ||
| 168 | return 0; | ||
| 169 | } | ||
| 170 | |||
| 171 | |||
| 172 | static int | ||
| 173 | isxfile(char *filename) /* Is executable file */ | ||
| 174 | { | ||
| 175 | struct stat buf; | ||
| 176 | if (stat(filename, &buf) != 0) | ||
| 177 | return 0; | ||
| 178 | if (!S_ISREG(buf.st_mode)) | ||
| 179 | return 0; | ||
| 180 | if ((buf.st_mode & 0111) == 0) | ||
| 181 | return 0; | ||
| 182 | return 1; | ||
| 183 | } | ||
| 184 | |||
| 185 | |||
| 186 | static int | ||
| 187 | isdir(char *filename) /* Is directory */ | ||
| 188 | { | ||
| 189 | struct stat buf; | ||
| 190 | if (stat(filename, &buf) != 0) | ||
| 191 | return 0; | ||
| 192 | if (!S_ISDIR(buf.st_mode)) | ||
| 193 | return 0; | ||
| 194 | return 1; | ||
| 195 | } | ||
| 196 | |||
| 197 | |||
| 198 | /* Add a path component, by appending stuff to buffer. | ||
| 199 | buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a | ||
| 200 | NUL-terminated string with no more than MAXPATHLEN characters (not counting | ||
| 201 | the trailing NUL). It's a fatal error if it contains a string longer than | ||
| 202 | that (callers must be careful!). If these requirements are met, it's | ||
| 203 | guaranteed that buffer will still be a NUL-terminated string with no more | ||
| 204 | than MAXPATHLEN characters at exit. If stuff is too long, only as much of | ||
| 205 | stuff as fits will be appended. | ||
| 206 | */ | ||
| 207 | static void | ||
| 208 | joinpath(char *buffer, char *stuff) | ||
| 209 | { | ||
| 210 | size_t n, k; | ||
| 211 | if (stuff[0] == SEP) | ||
| 212 | n = 0; | ||
| 213 | else { | ||
| 214 | n = strlen(buffer); | ||
| 215 | if (n > 0 && buffer[n-1] != SEP && n < MAXPATHLEN) | ||
| 216 | buffer[n++] = SEP; | ||
| 217 | } | ||
| 218 | if (n > MAXPATHLEN) | ||
| 219 | Py_FatalError("buffer overflow in getpath.c's joinpath()"); | ||
| 220 | k = strlen(stuff); | ||
| 221 | if (n + k > MAXPATHLEN) | ||
| 222 | k = MAXPATHLEN - n; | ||
| 223 | strncpy(buffer+n, stuff, k); | ||
| 224 | buffer[n+k] = '\0'; | ||
| 225 | } | ||
| 226 | |||
| 227 | /* copy_absolute requires that path be allocated at least | ||
| 228 | MAXPATHLEN + 1 bytes and that p be no more than MAXPATHLEN bytes. */ | ||
| 229 | static void | ||
| 230 | copy_absolute(char *path, char *p) | ||
| 231 | { | ||
| 232 | if (p[0] == SEP) | ||
| 233 | strcpy(path, p); | ||
| 234 | else { | ||
| 235 | getcwd(path, MAXPATHLEN); | ||
| 236 | if (p[0] == '.' && p[1] == SEP) | ||
| 237 | p += 2; | ||
| 238 | joinpath(path, p); | ||
| 239 | } | ||
| 240 | } | ||
| 241 | |||
| 242 | /* absolutize() requires that path be allocated at least MAXPATHLEN+1 bytes. */ | ||
| 243 | static void | ||
| 244 | absolutize(char *path) | ||
| 245 | { | ||
| 246 | char buffer[MAXPATHLEN + 1]; | ||
| 247 | |||
| 248 | if (path[0] == SEP) | ||
| 249 | return; | ||
| 250 | copy_absolute(buffer, path); | ||
| 251 | strcpy(path, buffer); | ||
| 252 | } | ||
| 253 | |||
| 254 | /* search_for_prefix requires that argv0_path be no more than MAXPATHLEN | ||
| 255 | bytes long. | ||
| 256 | */ | ||
| 257 | static int | ||
| 258 | search_for_prefix(char *argv0_path, char *home) | ||
| 259 | { | ||
| 260 | size_t n; | ||
| 261 | char *vpath; | ||
| 262 | |||
| 263 | /* If PYTHONHOME is set, we believe it unconditionally */ | ||
| 264 | if (home) { | ||
| 265 | char *delim; | ||
| 266 | strncpy(prefix, home, MAXPATHLEN); | ||
| 267 | delim = strchr(prefix, DELIM); | ||
| 268 | if (delim) | ||
| 269 | *delim = '\0'; | ||
| 270 | joinpath(prefix, lib_python); | ||
| 271 | joinpath(prefix, LANDMARK); | ||
| 272 | return 1; | ||
| 273 | } | ||
| 274 | |||
| 275 | /* Check to see if argv[0] is in the build directory */ | ||
| 276 | strcpy(prefix, argv0_path); | ||
| 277 | joinpath(prefix, "Modules/Setup"); | ||
| 278 | if (isfile(prefix)) { | ||
| 279 | /* Check VPATH to see if argv0_path is in the build directory. */ | ||
| 280 | vpath = VPATH; | ||
| 281 | strcpy(prefix, argv0_path); | ||
| 282 | joinpath(prefix, vpath); | ||
| 283 | joinpath(prefix, "Lib"); | ||
| 284 | joinpath(prefix, LANDMARK); | ||
| 285 | if (ismodule(prefix)) | ||
| 286 | return -1; | ||
| 287 | } | ||
| 288 | |||
| 289 | /* Search from argv0_path, until root is found */ | ||
| 290 | copy_absolute(prefix, argv0_path); | ||
| 291 | do { | ||
| 292 | n = strlen(prefix); | ||
| 293 | joinpath(prefix, lib_python); | ||
| 294 | joinpath(prefix, LANDMARK); | ||
| 295 | if (ismodule(prefix)) | ||
| 296 | return 1; | ||
| 297 | prefix[n] = '\0'; | ||
| 298 | reduce(prefix); | ||
| 299 | } while (prefix[0]); | ||
| 300 | |||
| 301 | /* Look at configure's PREFIX */ | ||
| 302 | strncpy(prefix, PREFIX, MAXPATHLEN); | ||
| 303 | joinpath(prefix, lib_python); | ||
| 304 | joinpath(prefix, LANDMARK); | ||
| 305 | if (ismodule(prefix)) | ||
| 306 | return 1; | ||
| 307 | |||
| 308 | /* Fail */ | ||
| 309 | return 0; | ||
| 310 | } | ||
| 311 | |||
| 312 | |||
| 313 | /* search_for_exec_prefix requires that argv0_path be no more than | ||
| 314 | MAXPATHLEN bytes long. | ||
| 315 | */ | ||
| 316 | static int | ||
| 317 | search_for_exec_prefix(char *argv0_path, char *home) | ||
| 318 | { | ||
| 319 | size_t n; | ||
| 320 | |||
| 321 | /* If PYTHONHOME is set, we believe it unconditionally */ | ||
| 322 | if (home) { | ||
| 323 | char *delim; | ||
| 324 | delim = strchr(home, DELIM); | ||
| 325 | if (delim) | ||
| 326 | strncpy(exec_prefix, delim+1, MAXPATHLEN); | ||
| 327 | else | ||
| 328 | strncpy(exec_prefix, home, MAXPATHLEN); | ||
| 329 | joinpath(exec_prefix, lib_python); | ||
| 330 | joinpath(exec_prefix, "lib-dynload"); | ||
| 331 | return 1; | ||
| 332 | } | ||
| 333 | |||
| 334 | /* Check to see if argv[0] is in the build directory */ | ||
| 335 | strcpy(exec_prefix, argv0_path); | ||
| 336 | joinpath(exec_prefix, "Modules/Setup"); | ||
| 337 | if (isfile(exec_prefix)) { | ||
| 338 | reduce(exec_prefix); | ||
| 339 | return -1; | ||
| 340 | } | ||
| 341 | |||
| 342 | /* Search from argv0_path, until root is found */ | ||
| 343 | copy_absolute(exec_prefix, argv0_path); | ||
| 344 | do { | ||
| 345 | n = strlen(exec_prefix); | ||
| 346 | joinpath(exec_prefix, lib_python); | ||
| 347 | joinpath(exec_prefix, "lib-dynload"); | ||
| 348 | if (isdir(exec_prefix)) | ||
| 349 | return 1; | ||
| 350 | exec_prefix[n] = '\0'; | ||
| 351 | reduce(exec_prefix); | ||
| 352 | } while (exec_prefix[0]); | ||
| 353 | |||
| 354 | /* Look at configure's EXEC_PREFIX */ | ||
| 355 | strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN); | ||
| 356 | joinpath(exec_prefix, lib_python); | ||
| 357 | joinpath(exec_prefix, "lib-dynload"); | ||
| 358 | if (isdir(exec_prefix)) | ||
| 359 | return 1; | ||
| 360 | |||
| 361 | /* Fail */ | ||
| 362 | return 0; | ||
| 363 | } | ||
| 364 | |||
| 365 | |||
| 366 | static void | ||
| 367 | calculate_path(void) | ||
| 368 | { | ||
| 369 | extern char *Py_GetProgramName(void); | ||
| 370 | |||
| 371 | static char delimiter[2] = {DELIM, '\0'}; | ||
| 372 | static char separator[2] = {SEP, '\0'}; | ||
| 373 | char *pythonpath = PYTHONPATH; | ||
| 374 | char *rtpypath = Py_GETENV("PYTHONPATH"); | ||
| 375 | char *home = Py_GetPythonHome(); | ||
| 376 | char *path = getenv("PATH"); | ||
| 377 | char *prog = Py_GetProgramName(); | ||
| 378 | char argv0_path[MAXPATHLEN+1]; | ||
| 379 | char zip_path[MAXPATHLEN+1]; | ||
| 380 | int pfound, efound; /* 1 if found; -1 if found build directory */ | ||
| 381 | char *buf; | ||
| 382 | size_t bufsz; | ||
| 383 | size_t prefixsz; | ||
| 384 | char *defpath = pythonpath; | ||
| 385 | #ifdef WITH_NEXT_FRAMEWORK | ||
| 386 | NSModule pythonModule; | ||
| 387 | #endif | ||
| 388 | #ifdef __APPLE__ | ||
| 389 | #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4 | ||
| 390 | uint32_t nsexeclength = MAXPATHLEN; | ||
| 391 | #else | ||
| 392 | unsigned long nsexeclength = MAXPATHLEN; | ||
| 393 | #endif | ||
| 394 | #endif | ||
| 395 | |||
| 396 | /* If there is no slash in the argv0 path, then we have to | ||
| 397 | * assume python is on the user's $PATH, since there's no | ||
| 398 | * other way to find a directory to start the search from. If | ||
| 399 | * $PATH isn't exported, you lose. | ||
| 400 | */ | ||
| 401 | if (strchr(prog, SEP)) | ||
| 402 | strncpy(progpath, prog, MAXPATHLEN); | ||
| 403 | #ifdef __APPLE__ | ||
| 404 | /* On Mac OS X, if a script uses an interpreter of the form | ||
| 405 | * "#!/opt/python2.3/bin/python", the kernel only passes "python" | ||
| 406 | * as argv[0], which falls through to the $PATH search below. | ||
| 407 | * If /opt/python2.3/bin isn't in your path, or is near the end, | ||
| 408 | * this algorithm may incorrectly find /usr/bin/python. To work | ||
| 409 | * around this, we can use _NSGetExecutablePath to get a better | ||
| 410 | * hint of what the intended interpreter was, although this | ||
| 411 | * will fail if a relative path was used. but in that case, | ||
| 412 | * absolutize() should help us out below | ||
| 413 | */ | ||
| 414 | else if(0 == _NSGetExecutablePath(progpath, &nsexeclength) && progpath[0] == SEP) | ||
| 415 | ; | ||
| 416 | #endif /* __APPLE__ */ | ||
| 417 | else if (path) { | ||
| 418 | while (1) { | ||
| 419 | char *delim = strchr(path, DELIM); | ||
| 420 | |||
| 421 | if (delim) { | ||
| 422 | size_t len = delim - path; | ||
| 423 | if (len > MAXPATHLEN) | ||
| 424 | len = MAXPATHLEN; | ||
| 425 | strncpy(progpath, path, len); | ||
| 426 | *(progpath + len) = '\0'; | ||
| 427 | } | ||
| 428 | else | ||
| 429 | strncpy(progpath, path, MAXPATHLEN); | ||
| 430 | |||
| 431 | joinpath(progpath, prog); | ||
| 432 | if (isxfile(progpath)) | ||
| 433 | break; | ||
| 434 | |||
| 435 | if (!delim) { | ||
| 436 | progpath[0] = '\0'; | ||
| 437 | break; | ||
| 438 | } | ||
| 439 | path = delim + 1; | ||
| 440 | } | ||
| 441 | } | ||
| 442 | else | ||
| 443 | progpath[0] = '\0'; | ||
| 444 | if (progpath[0] != SEP) | ||
| 445 | absolutize(progpath); | ||
| 446 | strncpy(argv0_path, progpath, MAXPATHLEN); | ||
| 447 | argv0_path[MAXPATHLEN] = '\0'; | ||
| 448 | |||
| 449 | #ifdef WITH_NEXT_FRAMEWORK | ||
| 450 | /* On Mac OS X we have a special case if we're running from a framework. | ||
| 451 | ** This is because the python home should be set relative to the library, | ||
| 452 | ** which is in the framework, not relative to the executable, which may | ||
| 453 | ** be outside of the framework. Except when we're in the build directory... | ||
| 454 | */ | ||
| 455 | pythonModule = NSModuleForSymbol(NSLookupAndBindSymbol("_Py_Initialize")); | ||
| 456 | /* Use dylib functions to find out where the framework was loaded from */ | ||
| 457 | buf = (char *)NSLibraryNameForModule(pythonModule); | ||
| 458 | if (buf != NULL) { | ||
| 459 | /* We're in a framework. */ | ||
| 460 | /* See if we might be in the build directory. The framework in the | ||
| 461 | ** build directory is incomplete, it only has the .dylib and a few | ||
| 462 | ** needed symlinks, it doesn't have the Lib directories and such. | ||
| 463 | ** If we're running with the framework from the build directory we must | ||
| 464 | ** be running the interpreter in the build directory, so we use the | ||
| 465 | ** build-directory-specific logic to find Lib and such. | ||
| 466 | */ | ||
| 467 | strncpy(argv0_path, buf, MAXPATHLEN); | ||
| 468 | reduce(argv0_path); | ||
| 469 | joinpath(argv0_path, lib_python); | ||
| 470 | joinpath(argv0_path, LANDMARK); | ||
| 471 | if (!ismodule(argv0_path)) { | ||
| 472 | /* We are in the build directory so use the name of the | ||
| 473 | executable - we know that the absolute path is passed */ | ||
| 474 | strncpy(argv0_path, prog, MAXPATHLEN); | ||
| 475 | } | ||
| 476 | else { | ||
| 477 | /* Use the location of the library as the progpath */ | ||
| 478 | strncpy(argv0_path, buf, MAXPATHLEN); | ||
| 479 | } | ||
| 480 | } | ||
| 481 | #endif | ||
| 482 | |||
| 483 | #if HAVE_READLINK | ||
| 484 | { | ||
| 485 | char tmpbuffer[MAXPATHLEN+1]; | ||
| 486 | int linklen = readlink(progpath, tmpbuffer, MAXPATHLEN); | ||
| 487 | while (linklen != -1) { | ||
| 488 | /* It's not null terminated! */ | ||
| 489 | tmpbuffer[linklen] = '\0'; | ||
| 490 | if (tmpbuffer[0] == SEP) | ||
| 491 | /* tmpbuffer should never be longer than MAXPATHLEN, | ||
| 492 | but extra check does not hurt */ | ||
| 493 | strncpy(argv0_path, tmpbuffer, MAXPATHLEN); | ||
| 494 | else { | ||
| 495 | /* Interpret relative to progpath */ | ||
| 496 | reduce(argv0_path); | ||
| 497 | joinpath(argv0_path, tmpbuffer); | ||
| 498 | } | ||
| 499 | linklen = readlink(argv0_path, tmpbuffer, MAXPATHLEN); | ||
| 500 | } | ||
| 501 | } | ||
| 502 | #endif /* HAVE_READLINK */ | ||
| 503 | |||
| 504 | reduce(argv0_path); | ||
| 505 | /* At this point, argv0_path is guaranteed to be less than | ||
| 506 | MAXPATHLEN bytes long. | ||
| 507 | */ | ||
| 508 | |||
| 509 | if (!(pfound = search_for_prefix(argv0_path, home))) { | ||
| 510 | if (!Py_FrozenFlag) | ||
| 511 | fprintf(stderr, | ||
| 512 | "Could not find platform independent libraries <prefix>\n"); | ||
| 513 | strncpy(prefix, PREFIX, MAXPATHLEN); | ||
| 514 | joinpath(prefix, lib_python); | ||
| 515 | } | ||
| 516 | else | ||
| 517 | reduce(prefix); | ||
| 518 | |||
| 519 | strncpy(zip_path, prefix, MAXPATHLEN); | ||
| 520 | zip_path[MAXPATHLEN] = '\0'; | ||
| 521 | if (pfound > 0) { /* Use the reduced prefix returned by Py_GetPrefix() */ | ||
| 522 | reduce(zip_path); | ||
| 523 | reduce(zip_path); | ||
| 524 | } | ||
| 525 | else | ||
| 526 | strncpy(zip_path, PREFIX, MAXPATHLEN); | ||
| 527 | joinpath(zip_path, "lib/python00.zip"); | ||
| 528 | bufsz = strlen(zip_path); /* Replace "00" with version */ | ||
| 529 | zip_path[bufsz - 6] = VERSION[0]; | ||
| 530 | zip_path[bufsz - 5] = VERSION[2]; | ||
| 531 | |||
| 532 | if (!(efound = search_for_exec_prefix(argv0_path, home))) { | ||
| 533 | if (!Py_FrozenFlag) | ||
| 534 | fprintf(stderr, | ||
| 535 | "Could not find platform dependent libraries <exec_prefix>\n"); | ||
| 536 | strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN); | ||
| 537 | joinpath(exec_prefix, "lib/lib-dynload"); | ||
| 538 | } | ||
| 539 | /* If we found EXEC_PREFIX do *not* reduce it! (Yet.) */ | ||
| 540 | |||
| 541 | if ((!pfound || !efound) && !Py_FrozenFlag) | ||
| 542 | fprintf(stderr, | ||
| 543 | "Consider setting $PYTHONHOME to <prefix>[:<exec_prefix>]\n"); | ||
| 544 | |||
| 545 | /* Calculate size of return buffer. | ||
| 546 | */ | ||
| 547 | bufsz = 0; | ||
| 548 | |||
| 549 | if (rtpypath) | ||
| 550 | bufsz += strlen(rtpypath) + 1; | ||
| 551 | |||
| 552 | prefixsz = strlen(prefix) + 1; | ||
| 553 | |||
| 554 | while (1) { | ||
| 555 | char *delim = strchr(defpath, DELIM); | ||
| 556 | |||
| 557 | if (defpath[0] != SEP) | ||
| 558 | /* Paths are relative to prefix */ | ||
| 559 | bufsz += prefixsz; | ||
| 560 | |||
| 561 | if (delim) | ||
| 562 | bufsz += delim - defpath + 1; | ||
| 563 | else { | ||
| 564 | bufsz += strlen(defpath) + 1; | ||
| 565 | break; | ||
| 566 | } | ||
| 567 | defpath = delim + 1; | ||
| 568 | } | ||
| 569 | |||
| 570 | bufsz += strlen(zip_path) + 1; | ||
| 571 | bufsz += strlen(exec_prefix) + 1; | ||
| 572 | |||
| 573 | /* This is the only malloc call in this file */ | ||
| 574 | buf = (char *)PyMem_Malloc(bufsz); | ||
| 575 | |||
| 576 | if (buf == NULL) { | ||
| 577 | /* We can't exit, so print a warning and limp along */ | ||
| 578 | fprintf(stderr, "Not enough memory for dynamic PYTHONPATH.\n"); | ||
| 579 | fprintf(stderr, "Using default static PYTHONPATH.\n"); | ||
| 580 | module_search_path = PYTHONPATH; | ||
| 581 | } | ||
| 582 | else { | ||
| 583 | /* Run-time value of $PYTHONPATH goes first */ | ||
| 584 | if (rtpypath) { | ||
| 585 | strcpy(buf, rtpypath); | ||
| 586 | strcat(buf, delimiter); | ||
| 587 | } | ||
| 588 | else | ||
| 589 | buf[0] = '\0'; | ||
| 590 | |||
| 591 | /* Next is the default zip path */ | ||
| 592 | strcat(buf, zip_path); | ||
| 593 | strcat(buf, delimiter); | ||
| 594 | |||
| 595 | /* Next goes merge of compile-time $PYTHONPATH with | ||
| 596 | * dynamically located prefix. | ||
| 597 | */ | ||
| 598 | defpath = pythonpath; | ||
| 599 | while (1) { | ||
| 600 | char *delim = strchr(defpath, DELIM); | ||
| 601 | |||
| 602 | if (defpath[0] != SEP) { | ||
| 603 | strcat(buf, prefix); | ||
| 604 | strcat(buf, separator); | ||
| 605 | } | ||
| 606 | |||
| 607 | if (delim) { | ||
| 608 | size_t len = delim - defpath + 1; | ||
| 609 | size_t end = strlen(buf) + len; | ||
| 610 | strncat(buf, defpath, len); | ||
| 611 | *(buf + end) = '\0'; | ||
| 612 | } | ||
| 613 | else { | ||
| 614 | strcat(buf, defpath); | ||
| 615 | break; | ||
| 616 | } | ||
| 617 | defpath = delim + 1; | ||
| 618 | } | ||
| 619 | strcat(buf, delimiter); | ||
| 620 | |||
| 621 | /* Finally, on goes the directory for dynamic-load modules */ | ||
| 622 | strcat(buf, exec_prefix); | ||
| 623 | |||
| 624 | /* And publish the results */ | ||
| 625 | module_search_path = buf; | ||
| 626 | } | ||
| 627 | |||
| 628 | /* Reduce prefix and exec_prefix to their essence, | ||
| 629 | * e.g. /usr/local/lib/python1.5 is reduced to /usr/local. | ||
| 630 | * If we're loading relative to the build directory, | ||
| 631 | * return the compiled-in defaults instead. | ||
| 632 | */ | ||
| 633 | if (pfound > 0) { | ||
| 634 | reduce(prefix); | ||
| 635 | reduce(prefix); | ||
| 636 | /* The prefix is the root directory, but reduce() chopped | ||
| 637 | * off the "/". */ | ||
| 638 | if (!prefix[0]) | ||
| 639 | strcpy(prefix, separator); | ||
| 640 | } | ||
| 641 | else | ||
| 642 | strncpy(prefix, PREFIX, MAXPATHLEN); | ||
| 643 | |||
| 644 | if (efound > 0) { | ||
| 645 | reduce(exec_prefix); | ||
| 646 | reduce(exec_prefix); | ||
| 647 | reduce(exec_prefix); | ||
| 648 | if (!exec_prefix[0]) | ||
| 649 | strcpy(exec_prefix, separator); | ||
| 650 | } | ||
| 651 | else | ||
| 652 | strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN); | ||
| 653 | } | ||
| 654 | |||
| 655 | |||
| 656 | /* External interface */ | ||
| 657 | |||
| 658 | char * | ||
| 659 | Py_GetPath(void) | ||
| 660 | { | ||
| 661 | if (!module_search_path) | ||
| 662 | calculate_path(); | ||
| 663 | return module_search_path; | ||
| 664 | } | ||
| 665 | |||
| 666 | char * | ||
| 667 | Py_GetPrefix(void) | ||
| 668 | { | ||
| 669 | if (!module_search_path) | ||
| 670 | calculate_path(); | ||
| 671 | return prefix; | ||
| 672 | } | ||
| 673 | |||
| 674 | char * | ||
| 675 | Py_GetExecPrefix(void) | ||
| 676 | { | ||
| 677 | if (!module_search_path) | ||
| 678 | calculate_path(); | ||
| 679 | return exec_prefix; | ||
| 680 | } | ||
| 681 | |||
| 682 | char * | ||
| 683 | Py_GetProgramFullPath(void) | ||
| 684 | { | ||
| 685 | if (!module_search_path) | ||
| 686 | calculate_path(); | ||
| 687 | return progpath; | ||
| 688 | } | ||
| 689 | |||
| 690 | |||
| 691 | #ifdef __cplusplus | ||
| 692 | } | ||
| 693 | #endif | ||
| 694 | |||