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 slashes 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 #if !defined(PREFIX) || !defined(EXEC_PREFIX) || !defined(VERSION) || !defined(VPATH) 100 #error "PREFIX, EXEC_PREFIX, VERSION, and VPATH must be constant defined" 101 #endif 102 103 #ifndef LANDMARK 104 #define LANDMARK "os.py" 105 #endif 106 107 #ifndef INTERNALDIR 108 #define INTERNALDIR "internal" 109 #endif 110 111 #ifndef STDLIBDIR 112 #define STDLIBDIR "stdlib" 113 #endif 114 115 static char prefix[MAXPATHLEN+1]; 116 static char exec_prefix[MAXPATHLEN+1]; 117 static char progpath[MAXPATHLEN+1]; 118 static char *module_search_path = NULL; 119 static char lib_python[] = "lib/python" VERSION; 120 121 static void 122 reduce(char *dir) 123 { 124 size_t i = strlen(dir); 125 while (i > 0 && dir[i] != SEP) 126 --i; 127 dir[i] = '\0'; 128 } 129 130 131 static int 132 isfile(char *filename) /* Is file, not directory */ 133 { 134 struct stat buf; 135 if (stat(filename, &buf) != 0) 136 return 0; 137 if (!S_ISREG(buf.st_mode)) 138 return 0; 139 return 1; 140 } 141 142 143 static int 144 ismodule(char *filename) /* Is module -- check for .pyc/.pyo too */ 145 { 146 if (isfile(filename)) 147 return 1; 148 149 /* Check for the compiled version of prefix. */ 150 if (strlen(filename) < MAXPATHLEN) { 151 strcat(filename, Py_OptimizeFlag ? "o" : "c"); 152 if (isfile(filename)) 153 return 1; 154 } 155 return 0; 156 } 157 158 159 static int 160 isxfile(char *filename) /* Is executable file */ 161 { 162 struct stat buf; 163 if (stat(filename, &buf) != 0) 164 return 0; 165 if (!S_ISREG(buf.st_mode)) 166 return 0; 167 if ((buf.st_mode & 0111) == 0) 168 return 0; 169 return 1; 170 } 171 172 173 static int 174 isdir(char *filename) /* Is directory */ 175 { 176 struct stat buf; 177 if (stat(filename, &buf) != 0) 178 return 0; 179 if (!S_ISDIR(buf.st_mode)) 180 return 0; 181 return 1; 182 } 183 184 185 /* Add a path component, by appending stuff to buffer. 186 buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a 187 NUL-terminated string with no more than MAXPATHLEN characters (not counting 188 the trailing NUL). It's a fatal error if it contains a string longer than 189 that (callers must be careful!). If these requirements are met, it's 190 guaranteed that buffer will still be a NUL-terminated string with no more 191 than MAXPATHLEN characters at exit. If stuff is too long, only as much of 192 stuff as fits will be appended. 193 */ 194 static void 195 joinpath(char *buffer, char *stuff) 196 { 197 size_t n, k; 198 if (stuff[0] == SEP) 199 n = 0; 200 else { 201 n = strlen(buffer); 202 if (n > 0 && buffer[n-1] != SEP && n < MAXPATHLEN) 203 buffer[n++] = SEP; 204 } 205 if (n > MAXPATHLEN) 206 Py_FatalError("buffer overflow in getpath.c's joinpath()"); 207 k = strlen(stuff); 208 if (n + k > MAXPATHLEN) 209 k = MAXPATHLEN - n; 210 strncpy(buffer+n, stuff, k); 211 buffer[n+k] = '\0'; 212 } 213 214 /* copy_absolute requires that path be allocated at least 215 MAXPATHLEN + 1 bytes and that p be no more than MAXPATHLEN bytes. */ 216 static void 217 copy_absolute(char *path, char *p) 218 { 219 if (p[0] == SEP) 220 strcpy(path, p); 221 else { 222 if (!getcwd(path, MAXPATHLEN)) { 223 /* unable to get the current directory */ 224 strcpy(path, p); 225 return; 226 } 227 if (p[0] == '.' && p[1] == SEP) 228 p += 2; 229 joinpath(path, p); 230 } 231 } 232 233 /* absolutize() requires that path be allocated at least MAXPATHLEN+1 bytes. */ 234 static void 235 absolutize(char *path) 236 { 237 char buffer[MAXPATHLEN + 1]; 238 239 if (path[0] == SEP) 240 return; 241 copy_absolute(buffer, path); 242 strcpy(path, buffer); 243 } 244 245 /* search_for_prefix requires that argv0_path be no more than MAXPATHLEN 246 bytes long. 247 */ 248 static int 249 search_for_prefix(char *argv0_path, char *home) 250 { 251 size_t n; 252 char *vpath; 253 254 /* If PYTHONHOME is set, we believe it unconditionally */ 255 if (home) { 256 char *delim; 257 strncpy(prefix, home, MAXPATHLEN); 258 delim = strchr(prefix, DELIM); 259 if (delim) 260 *delim = '\0'; 261 joinpath(prefix, lib_python); 262 joinpath(prefix, LANDMARK); 263 return 1; 264 } 265 266 // GOOGLE(nanzhang): Always set prefix with hermetic executable full path. 267 strcpy(prefix, argv0_path); 268 return 1; 269 270 /* Check to see if argv[0] is in the build directory */ 271 joinpath(prefix, "Modules/Setup"); 272 if (isfile(prefix)) { 273 /* Check VPATH to see if argv0_path is in the build directory. */ 274 vpath = VPATH; 275 strcpy(prefix, argv0_path); 276 joinpath(prefix, vpath); 277 joinpath(prefix, "Lib"); 278 joinpath(prefix, LANDMARK); 279 if (ismodule(prefix)) 280 return -1; 281 } 282 283 /* Search from argv0_path, until root is found */ 284 copy_absolute(prefix, argv0_path); 285 do { 286 n = strlen(prefix); 287 joinpath(prefix, lib_python); 288 joinpath(prefix, LANDMARK); 289 if (ismodule(prefix)) 290 return 1; 291 prefix[n] = '\0'; 292 reduce(prefix); 293 } while (prefix[0]); 294 295 /* Look at configure's PREFIX */ 296 strncpy(prefix, PREFIX, MAXPATHLEN); 297 joinpath(prefix, lib_python); 298 joinpath(prefix, LANDMARK); 299 if (ismodule(prefix)) 300 return 1; 301 302 /* Fail */ 303 return 0; 304 } 305 306 307 /* search_for_exec_prefix requires that argv0_path be no more than 308 MAXPATHLEN bytes long. 309 */ 310 static int 311 search_for_exec_prefix(char *argv0_path, char *home) 312 { 313 size_t n; 314 315 /* If PYTHONHOME is set, we believe it unconditionally */ 316 if (home) { 317 char *delim; 318 delim = strchr(home, DELIM); 319 if (delim) 320 strncpy(exec_prefix, delim+1, MAXPATHLEN); 321 else 322 strncpy(exec_prefix, home, MAXPATHLEN); 323 joinpath(exec_prefix, lib_python); 324 joinpath(exec_prefix, "lib-dynload"); 325 return 1; 326 } 327 328 // GOOGLE(nanzhang): Always set exec_prefix with hermetic executable full path. 329 strcpy(exec_prefix, argv0_path); 330 return 1; 331 332 /* Check to see if argv[0] is in the build directory. "pybuilddir.txt" 333 is written by setup.py and contains the relative path to the location 334 of shared library modules. */ 335 joinpath(exec_prefix, "pybuilddir.txt"); 336 if (isfile(exec_prefix)) { 337 FILE *f = fopen(exec_prefix, "r"); 338 if (f == NULL) 339 errno = 0; 340 else { 341 char rel_builddir_path[MAXPATHLEN+1]; 342 size_t n; 343 n = fread(rel_builddir_path, 1, MAXPATHLEN, f); 344 rel_builddir_path[n] = '\0'; 345 fclose(f); 346 strcpy(exec_prefix, argv0_path); 347 joinpath(exec_prefix, rel_builddir_path); 348 return -1; 349 } 350 } 351 352 /* Search from argv0_path, until root is found */ 353 copy_absolute(exec_prefix, argv0_path); 354 do { 355 n = strlen(exec_prefix); 356 joinpath(exec_prefix, lib_python); 357 joinpath(exec_prefix, "lib-dynload"); 358 if (isdir(exec_prefix)) 359 return 1; 360 exec_prefix[n] = '\0'; 361 reduce(exec_prefix); 362 } while (exec_prefix[0]); 363 364 /* Look at configure's EXEC_PREFIX */ 365 strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN); 366 joinpath(exec_prefix, lib_python); 367 joinpath(exec_prefix, "lib-dynload"); 368 if (isdir(exec_prefix)) 369 return 1; 370 371 /* Fail */ 372 return 0; 373 } 374 375 376 static void 377 calculate_path(void) 378 { 379 extern char *Py_GetProgramName(void); 380 static char delimiter[2] = {DELIM, '\0'}; 381 static char separator[2] = {SEP, '\0'}; 382 char *pythonpath = PYTHONPATH; 383 char *home = Py_GetPythonHome(); 384 // We have overrided argv[0] using the full path to the hermetic Python 385 // launcher itself. And then Py_SetProgramName(argv[0]) was invoked at 386 // launcher_main.cpp. The launcher_main.cpp has guaranteed that 387 // strlen(Py_GetProgramName()) must not exceed MAXPATHLEN. 388 char *prog = Py_GetProgramName(); 389 char argv0_path[MAXPATHLEN+1]; 390 char *buf; 391 size_t bufsz; 392 393 strncpy(progpath, prog, MAXPATHLEN); 394 progpath[MAXPATHLEN] = '\0' /* In case of no NUL-termination. */; 395 strncpy(argv0_path, prog, MAXPATHLEN); 396 argv0_path[MAXPATHLEN] = '\0' /* In case of no NUL-termination. */; 397 398 // We don't reduce the path of prefix, and exec_prefix. 399 search_for_prefix(argv0_path, home); 400 search_for_exec_prefix(argv0_path, home); 401 402 // Calculate size of return buffer. 403 bufsz = strlen(prog) + 1 + sizeof(INTERNALDIR) /* 1 is for SEP */; 404 bufsz += strlen(prog) + 1 + sizeof(INTERNALDIR) + 1 + sizeof(STDLIBDIR) /* 1 is for SEP */; 405 406 /* This is the only malloc call in this file */ 407 buf = (char *)PyMem_Malloc(bufsz); 408 409 if (buf == NULL) { 410 /* We can't exit, so print a warning and limp along */ 411 fprintf(stderr, "Not enough memory for dynamic PYTHONPATH.\n"); 412 fprintf(stderr, "Using default static PYTHONPATH.\n"); 413 exit(1); 414 } else { 415 buf[0] = '\0'; 416 strcat(buf, prefix); 417 strcat(buf, separator); 418 strcat(buf, INTERNALDIR); 419 strcat(buf, delimiter); 420 421 strcat(buf, prefix); 422 strcat(buf, separator); 423 strcat(buf, INTERNALDIR); 424 strcat(buf, separator); 425 strcat(buf, STDLIBDIR); 426 427 module_search_path = buf; 428 } 429 // GOOGLE(nanzhang): Don't need all the code below for embedded Python launcher. 430 return; 431 432 char *path = getenv("PATH"); 433 char *rtpypath = Py_GETENV("PYTHONPATH"); 434 char zip_path[MAXPATHLEN+1]; 435 int pfound, efound; /* 1 if found; -1 if found build directory */ 436 size_t prefixsz; 437 char *defpath = pythonpath; 438 #ifdef WITH_NEXT_FRAMEWORK 439 NSModule pythonModule; 440 #endif 441 #ifdef __APPLE__ 442 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4 443 uint32_t nsexeclength = MAXPATHLEN; 444 #else 445 unsigned long nsexeclength = MAXPATHLEN; 446 #endif 447 #endif 448 449 /* If there is no slash in the argv0 path, then we have to 450 * assume python is on the user's $PATH, since there's no 451 * other way to find a directory to start the search from. If 452 * $PATH isn't exported, you lose. 453 */ 454 if (strchr(prog, SEP)) 455 strncpy(progpath, prog, MAXPATHLEN); 456 #ifdef __APPLE__ 457 /* On Mac OS X, if a script uses an interpreter of the form 458 * "#!/opt/python2.3/bin/python", the kernel only passes "python" 459 * as argv[0], which falls through to the $PATH search below. 460 * If /opt/python2.3/bin isn't in your path, or is near the end, 461 * this algorithm may incorrectly find /usr/bin/python. To work 462 * around this, we can use _NSGetExecutablePath to get a better 463 * hint of what the intended interpreter was, although this 464 * will fail if a relative path was used. but in that case, 465 * absolutize() should help us out below 466 */ 467 else if(0 == _NSGetExecutablePath(progpath, &nsexeclength) && progpath[0] == SEP) 468 ; 469 #endif /* __APPLE__ */ 470 else if (path) { 471 while (1) { 472 char *delim = strchr(path, DELIM); 473 474 if (delim) { 475 size_t len = delim - path; 476 if (len > MAXPATHLEN) 477 len = MAXPATHLEN; 478 strncpy(progpath, path, len); 479 *(progpath + len) = '\0'; 480 } 481 else 482 strncpy(progpath, path, MAXPATHLEN); 483 484 joinpath(progpath, prog); 485 if (isxfile(progpath)) 486 break; 487 488 if (!delim) { 489 progpath[0] = '\0'; 490 break; 491 } 492 path = delim + 1; 493 } 494 } 495 else 496 progpath[0] = '\0'; 497 if (progpath[0] != SEP && progpath[0] != '\0') 498 absolutize(progpath); 499 strncpy(argv0_path, progpath, MAXPATHLEN); 500 argv0_path[MAXPATHLEN] = '\0'; 501 502 #ifdef WITH_NEXT_FRAMEWORK 503 /* On Mac OS X we have a special case if we're running from a framework. 504 ** This is because the python home should be set relative to the library, 505 ** which is in the framework, not relative to the executable, which may 506 ** be outside of the framework. Except when we're in the build directory... 507 */ 508 pythonModule = NSModuleForSymbol(NSLookupAndBindSymbol("_Py_Initialize")); 509 /* Use dylib functions to find out where the framework was loaded from */ 510 buf = (char *)NSLibraryNameForModule(pythonModule); 511 if (buf != NULL) { 512 /* We're in a framework. */ 513 /* See if we might be in the build directory. The framework in the 514 ** build directory is incomplete, it only has the .dylib and a few 515 ** needed symlinks, it doesn't have the Lib directories and such. 516 ** If we're running with the framework from the build directory we must 517 ** be running the interpreter in the build directory, so we use the 518 ** build-directory-specific logic to find Lib and such. 519 */ 520 strncpy(argv0_path, buf, MAXPATHLEN); 521 reduce(argv0_path); 522 joinpath(argv0_path, lib_python); 523 joinpath(argv0_path, LANDMARK); 524 if (!ismodule(argv0_path)) { 525 /* We are in the build directory so use the name of the 526 executable - we know that the absolute path is passed */ 527 strncpy(argv0_path, progpath, MAXPATHLEN); 528 } 529 else { 530 /* Use the location of the library as the progpath */ 531 strncpy(argv0_path, buf, MAXPATHLEN); 532 } 533 } 534 #endif 535 536 #if HAVE_READLINK 537 { 538 char tmpbuffer[MAXPATHLEN+1]; 539 int linklen = readlink(progpath, tmpbuffer, MAXPATHLEN); 540 while (linklen != -1) { 541 /* It's not null terminated! */ 542 tmpbuffer[linklen] = '\0'; 543 if (tmpbuffer[0] == SEP) 544 /* tmpbuffer should never be longer than MAXPATHLEN, 545 but extra check does not hurt */ 546 strncpy(argv0_path, tmpbuffer, MAXPATHLEN); 547 else { 548 /* Interpret relative to progpath */ 549 reduce(argv0_path); 550 joinpath(argv0_path, tmpbuffer); 551 } 552 linklen = readlink(argv0_path, tmpbuffer, MAXPATHLEN); 553 } 554 } 555 #endif /* HAVE_READLINK */ 556 557 reduce(argv0_path); 558 /* At this point, argv0_path is guaranteed to be less than 559 MAXPATHLEN bytes long. 560 */ 561 562 if (!(pfound = search_for_prefix(argv0_path, home))) { 563 if (!Py_FrozenFlag) 564 fprintf(stderr, 565 "Could not find platform independent libraries <prefix>\n"); 566 strncpy(prefix, PREFIX, MAXPATHLEN); 567 joinpath(prefix, lib_python); 568 } 569 else 570 reduce(prefix); 571 572 strncpy(zip_path, prefix, MAXPATHLEN); 573 zip_path[MAXPATHLEN] = '\0'; 574 if (pfound > 0) { /* Use the reduced prefix returned by Py_GetPrefix() */ 575 reduce(zip_path); 576 reduce(zip_path); 577 } 578 else 579 strncpy(zip_path, PREFIX, MAXPATHLEN); 580 joinpath(zip_path, "lib/python00.zip"); 581 bufsz = strlen(zip_path); /* Replace "00" with version */ 582 zip_path[bufsz - 6] = VERSION[0]; 583 zip_path[bufsz - 5] = VERSION[2]; 584 585 if (!(efound = search_for_exec_prefix(argv0_path, home))) { 586 if (!Py_FrozenFlag) 587 fprintf(stderr, 588 "Could not find platform dependent libraries <exec_prefix>\n"); 589 strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN); 590 joinpath(exec_prefix, "lib/lib-dynload"); 591 } 592 /* If we found EXEC_PREFIX do *not* reduce it! (Yet.) */ 593 594 if ((!pfound || !efound) && !Py_FrozenFlag) 595 fprintf(stderr, 596 "Consider setting $PYTHONHOME to <prefix>[:<exec_prefix>]\n"); 597 598 /* Calculate size of return buffer. 599 */ 600 bufsz = 0; 601 602 if (rtpypath) 603 bufsz += strlen(rtpypath) + 1; 604 605 prefixsz = strlen(prefix) + 1; 606 607 while (1) { 608 char *delim = strchr(defpath, DELIM); 609 610 if (defpath[0] != SEP) 611 /* Paths are relative to prefix */ 612 bufsz += prefixsz; 613 614 if (delim) 615 bufsz += delim - defpath + 1; 616 else { 617 bufsz += strlen(defpath) + 1; 618 break; 619 } 620 defpath = delim + 1; 621 } 622 623 bufsz += strlen(zip_path) + 1; 624 bufsz += strlen(exec_prefix) + 1; 625 626 /* This is the only malloc call in this file */ 627 buf = (char *)PyMem_Malloc(bufsz); 628 629 if (buf == NULL) { 630 /* We can't exit, so print a warning and limp along */ 631 fprintf(stderr, "Not enough memory for dynamic PYTHONPATH.\n"); 632 fprintf(stderr, "Using default static PYTHONPATH.\n"); 633 module_search_path = PYTHONPATH; 634 } 635 else { 636 /* Run-time value of $PYTHONPATH goes first */ 637 if (rtpypath) { 638 strcpy(buf, rtpypath); 639 strcat(buf, delimiter); 640 } 641 else 642 buf[0] = '\0'; 643 644 /* Next is the default zip path */ 645 strcat(buf, zip_path); 646 strcat(buf, delimiter); 647 648 /* Next goes merge of compile-time $PYTHONPATH with 649 * dynamically located prefix. 650 */ 651 defpath = pythonpath; 652 while (1) { 653 char *delim = strchr(defpath, DELIM); 654 655 if (defpath[0] != SEP) { 656 strcat(buf, prefix); 657 if (prefixsz >= 2 && prefix[prefixsz - 2] != SEP && 658 defpath[0] != (delim ? DELIM : L'\0')) { /* not empty */ 659 strcat(buf, separator); 660 } 661 } 662 663 if (delim) { 664 size_t len = delim - defpath + 1; 665 size_t end = strlen(buf) + len; 666 strncat(buf, defpath, len); 667 *(buf + end) = '\0'; 668 } 669 else { 670 strcat(buf, defpath); 671 break; 672 } 673 defpath = delim + 1; 674 } 675 strcat(buf, delimiter); 676 677 /* Finally, on goes the directory for dynamic-load modules */ 678 strcat(buf, exec_prefix); 679 680 /* And publish the results */ 681 module_search_path = buf; 682 } 683 684 /* Reduce prefix and exec_prefix to their essence, 685 * e.g. /usr/local/lib/python1.5 is reduced to /usr/local. 686 * If we're loading relative to the build directory, 687 * return the compiled-in defaults instead. 688 */ 689 if (pfound > 0) { 690 reduce(prefix); 691 reduce(prefix); 692 /* The prefix is the root directory, but reduce() chopped 693 * off the "/". */ 694 if (!prefix[0]) 695 strcpy(prefix, separator); 696 } 697 else 698 strncpy(prefix, PREFIX, MAXPATHLEN); 699 700 if (efound > 0) { 701 reduce(exec_prefix); 702 reduce(exec_prefix); 703 reduce(exec_prefix); 704 if (!exec_prefix[0]) 705 strcpy(exec_prefix, separator); 706 } 707 else 708 strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN); 709 } 710 711 712 /* External interface */ 713 714 char * 715 Py_GetPath(void) 716 { 717 if (!module_search_path) 718 calculate_path(); 719 return module_search_path; 720 } 721 722 char * 723 Py_GetPrefix(void) 724 { 725 if (!module_search_path) 726 calculate_path(); 727 return prefix; 728 } 729 730 char * 731 Py_GetExecPrefix(void) 732 { 733 if (!module_search_path) 734 calculate_path(); 735 return exec_prefix; 736 } 737 738 char * 739 Py_GetProgramFullPath(void) 740 { 741 if (!module_search_path) 742 calculate_path(); 743 return progpath; 744 } 745 746 747 #ifdef __cplusplus 748 } 749 #endif 750 751