PC/getpathp.c

   1
   2 /* Return the initial module search path. */
   3 /* Used by DOS, OS/2, Windows 3.1, Windows 95/98, Windows NT. */
   4
   5 /* ----------------------------------------------------------------
   6    PATH RULES FOR WINDOWS:
   7    This describes how sys.path is formed on Windows.  It describes the
   8    functionality, not the implementation (ie, the order in which these
   9    are actually fetched is different)
  10
  11    * Python always adds an empty entry at the start, which corresponds
  12      to the current directory.
  13
  14    * If the PYTHONPATH env. var. exists, its entries are added next.
  15
  16    * We look in the registry for "application paths" - that is, sub-keys
  17      under the main PythonPath registry key.  These are added next (the
  18      order of sub-key processing is undefined).
  19      HKEY_CURRENT_USER is searched and added first.
  20      HKEY_LOCAL_MACHINE is searched and added next.
  21      (Note that all known installers only use HKLM, so HKCU is typically
  22      empty)
  23
  24    * We attempt to locate the "Python Home" - if the PYTHONHOME env var
  25      is set, we believe it.  Otherwise, we use the path of our host .EXE's
  26      to try and locate our "landmark" (lib\\os.py) and deduce our home.
  27      - If we DO have a Python Home: The relevant sub-directories (Lib,
  28        plat-win, lib-tk, etc) are based on the Python Home
  29      - If we DO NOT have a Python Home, the core Python Path is
  30        loaded from the registry.  This is the main PythonPath key,
  31        and both HKLM and HKCU are combined to form the path)
  32
  33    * Iff - we can not locate the Python Home, have not had a PYTHONPATH
  34      specified, and can't locate any Registry entries (ie, we have _nothing_
  35      we can assume is a good path), a default path with relative entries is
  36      used (eg. .\Lib;.\plat-win, etc)
  37
  38
  39   The end result of all this is:
  40   * When running python.exe, or any other .exe in the main Python directory
  41     (either an installed version, or directly from the PCbuild directory),
  42     the core path is deduced, and the core paths in the registry are
  43     ignored.  Other "application paths" in the registry are always read.
  44
  45   * When Python is hosted in another exe (different directory, embedded via
  46     COM, etc), the Python Home will not be deduced, so the core path from
  47     the registry is used.  Other "application paths" in the registry are
  48     always read.
  49
  50   * If Python can't find its home and there is no registry (eg, frozen
  51     exe, some very strange installation setup) you get a path with
  52     some default, but relative, paths.
  53
  54    ---------------------------------------------------------------- */
  55
  56
  57 #include "Python.h"
  58 #include "osdefs.h"
  59
  60 #ifdef MS_WINDOWS
  61 #include <windows.h>
  62 #include <tchar.h>
  63 #endif
  64
  65 #include <sys/types.h>
  66 #include <sys/stat.h>
  67 #include <string.h>
  68
  69 /* Search in some common locations for the associated Python libraries.
  70  *
  71  * Py_GetPath() tries to return a sensible Python module search path.
  72  *
  73  * The approach is an adaptation for Windows of the strategy used in
  74  * ../Modules/getpath.c; it uses the Windows Registry as one of its
  75  * information sources.
  76  */
  77
  78 #ifndef LANDMARK
  79 #define LANDMARK "lib\\os.py"
  80 #endif
  81
  82 static char prefix[MAXPATHLEN+1];
  83 static char progpath[MAXPATHLEN+1];
  84 static char dllpath[MAXPATHLEN+1];
  85 static char *module_search_path = NULL;
  86
  87
  88 static int
  89 is_sep(char ch) /* determine if "ch" is a separator character */
  90 {
  91 #ifdef ALTSEP
  92         return ch == SEP || ch == ALTSEP;
  93 #else
  94         return ch == SEP;
  95 #endif
  96 }
  97
  98 /* assumes 'dir' null terminated in bounds.  Never writes
  99    beyond existing terminator.
 100 */
 101 static void
 102 reduce(char *dir)
 103 {
 104         size_t i = strlen(dir);
 105         while (i > 0 && !is_sep(dir[i]))
 106                 --i;
 107         dir[i] = '\0';
 108 }
 109
 110
 111 static int
 112 exists(char *filename)
 113 {
 114         struct stat buf;
 115         return stat(filename, &buf) == 0;
 116 }
 117
 118 /* Assumes 'filename' MAXPATHLEN+1 bytes long -
 119    may extend 'filename' by one character.
 120 */
 121 static int
 122 ismodule(char *filename)        /* Is module -- check for .pyc/.pyo too */
 123 {
 124         if (exists(filename))
 125                 return 1;
 126
 127         /* Check for the compiled version of prefix. */
 128         if (strlen(filename) < MAXPATHLEN) {
 129                 strcat(filename, Py_OptimizeFlag ? "o" : "c");
 130                 if (exists(filename))
 131                         return 1;
 132         }
 133         return 0;
 134 }
 135
 136 /* Add a path component, by appending stuff to buffer.
 137    buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a
 138    NUL-terminated string with no more than MAXPATHLEN characters (not counting
 139    the trailing NUL).  It's a fatal error if it contains a string longer than
 140    that (callers must be careful!).  If these requirements are met, it's
 141    guaranteed that buffer will still be a NUL-terminated string with no more
 142    than MAXPATHLEN characters at exit.  If stuff is too long, only as much of
 143    stuff as fits will be appended.
 144 */
 145 static void
 146 join(char *buffer, char *stuff)
 147 {
 148         size_t n, k;
 149         if (is_sep(stuff[0]))
 150                 n = 0;
 151         else {
 152                 n = strlen(buffer);
 153                 if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN)
 154                         buffer[n++] = SEP;
 155         }
 156         if (n > MAXPATHLEN)
 157                 Py_FatalError("buffer overflow in getpathp.c's joinpath()");
 158         k = strlen(stuff);
 159         if (n + k > MAXPATHLEN)
 160                 k = MAXPATHLEN - n;
 161         strncpy(buffer+n, stuff, k);
 162         buffer[n+k] = '\0';
 163 }
 164
 165 /* gotlandmark only called by search_for_prefix, which ensures
 166    'prefix' is null terminated in bounds.  join() ensures
 167    'landmark' can not overflow prefix if too long.
 168 */
 169 static int
 170 gotlandmark(char *landmark)
 171 {
 172         int ok;
 173         Py_ssize_t n;
 174
 175         n = strlen(prefix);
 176         join(prefix, landmark);
 177         ok = ismodule(prefix);
 178         prefix[n] = '\0';
 179         return ok;
 180 }
 181
 182 /* assumes argv0_path is MAXPATHLEN+1 bytes long, already \0 term'd.
 183    assumption provided by only caller, calculate_path() */
 184 static int
 185 search_for_prefix(char *argv0_path, char *landmark)
 186 {
 187         /* Search from argv0_path, until landmark is found */
 188         strcpy(prefix, argv0_path);
 189         do {
 190                 if (gotlandmark(landmark))
 191                         return 1;
 192                 reduce(prefix);
 193         } while (prefix[0]);
 194         return 0;
 195 }
 196
 197 #ifdef MS_WINDOWS
 198
 199 /* a string loaded from the DLL at startup.*/
 200 extern const char *PyWin_DLLVersionString;
 201
 202
 203 /* Load a PYTHONPATH value from the registry.
 204    Load from either HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER.
 205
 206    Works in both Unicode and 8bit environments.  Only uses the
 207    Ex family of functions so it also works with Windows CE.
 208
 209    Returns NULL, or a pointer that should be freed.
 210
 211    XXX - this code is pretty strange, as it used to also
 212    work on Win16, where the buffer sizes werent available
 213    in advance.  It could be simplied now Win16/Win32s is dead!
 214 */
 215
 216 static char *
 217 getpythonregpath(HKEY keyBase, int skipcore)
 218 {
 219         HKEY newKey = 0;
 220         DWORD dataSize = 0;
 221         DWORD numKeys = 0;
 222         LONG rc;
 223         char *retval = NULL;
 224         TCHAR *dataBuf = NULL;
 225         static const TCHAR keyPrefix[] = _T("Software\\Python\\PythonCore\\");
 226         static const TCHAR keySuffix[] = _T("\\PythonPath");
 227         size_t versionLen;
 228         DWORD index;
 229         TCHAR *keyBuf = NULL;
 230         TCHAR *keyBufPtr;
 231         TCHAR **ppPaths = NULL;
 232
 233         /* Tried to use sysget("winver") but here is too early :-( */
 234         versionLen = _tcslen(PyWin_DLLVersionString);
 235         /* Space for all the chars, plus one \0 */
 236         keyBuf = keyBufPtr = malloc(sizeof(keyPrefix) +
 237                                     sizeof(TCHAR)*(versionLen-1) +
 238                                     sizeof(keySuffix));
 239         if (keyBuf==NULL) goto done;
 240
 241         memcpy(keyBufPtr, keyPrefix, sizeof(keyPrefix)-sizeof(TCHAR));
 242         keyBufPtr += sizeof(keyPrefix)/sizeof(TCHAR) - 1;
 243         memcpy(keyBufPtr, PyWin_DLLVersionString, versionLen * sizeof(TCHAR));
 244         keyBufPtr += versionLen;
 245         /* NULL comes with this one! */
 246         memcpy(keyBufPtr, keySuffix, sizeof(keySuffix));
 247         /* Open the root Python key */
 248         rc=RegOpenKeyEx(keyBase,
 249                         keyBuf, /* subkey */
 250                         0, /* reserved */
 251                         KEY_READ,
 252                         &newKey);
 253         if (rc!=ERROR_SUCCESS) goto done;
 254         /* Find out how big our core buffer is, and how many subkeys we have */
 255         rc = RegQueryInfoKey(newKey, NULL, NULL, NULL, &numKeys, NULL, NULL,
 256                         NULL, NULL, &dataSize, NULL, NULL);
 257         if (rc!=ERROR_SUCCESS) goto done;
 258         if (skipcore) dataSize = 0; /* Only count core ones if we want them! */
 259         /* Allocate a temp array of char buffers, so we only need to loop
 260            reading the registry once
 261         */
 262         ppPaths = malloc( sizeof(TCHAR *) * numKeys );
 263         if (ppPaths==NULL) goto done;
 264         memset(ppPaths, 0, sizeof(TCHAR *) * numKeys);
 265         /* Loop over all subkeys, allocating a temp sub-buffer. */
 266         for(index=0;index<numKeys;index++) {
 267                 TCHAR keyBuf[MAX_PATH+1];
 268                 HKEY subKey = 0;
 269                 DWORD reqdSize = MAX_PATH+1;
 270                 /* Get the sub-key name */
 271                 DWORD rc = RegEnumKeyEx(newKey, index, keyBuf, &reqdSize,
 272                                         NULL, NULL, NULL, NULL );
 273                 if (rc!=ERROR_SUCCESS) goto done;
 274                 /* Open the sub-key */
 275                 rc=RegOpenKeyEx(newKey,
 276                                                 keyBuf, /* subkey */
 277                                                 0, /* reserved */
 278                                                 KEY_READ,
 279                                                 &subKey);
 280                 if (rc!=ERROR_SUCCESS) goto done;
 281                 /* Find the value of the buffer size, malloc, then read it */
 282                 RegQueryValueEx(subKey, NULL, 0, NULL, NULL, &reqdSize);
 283                 if (reqdSize) {
 284                         ppPaths[index] = malloc(reqdSize);
 285                         if (ppPaths[index]) {
 286                                 RegQueryValueEx(subKey, NULL, 0, NULL,
 287                                                 (LPBYTE)ppPaths[index],
 288                                                 &reqdSize);
 289                                 dataSize += reqdSize + 1; /* 1 for the ";" */
 290                         }
 291                 }
 292                 RegCloseKey(subKey);
 293         }
 294         /* original datasize from RegQueryInfo doesn't include the \0 */
 295         dataBuf = malloc((dataSize+1) * sizeof(TCHAR));
 296         if (dataBuf) {
 297                 TCHAR *szCur = dataBuf;
 298                 DWORD reqdSize = dataSize;
 299                 /* Copy our collected strings */
 300                 for (index=0;index<numKeys;index++) {
 301                         if (index > 0) {
 302                                 *(szCur++) = _T(';');
 303                                 dataSize--;
 304                         }
 305                         if (ppPaths[index]) {
 306                                 Py_ssize_t len = _tcslen(ppPaths[index]);
 307                                 _tcsncpy(szCur, ppPaths[index], len);
 308                                 szCur += len;
 309                                 assert(dataSize > (DWORD)len);
 310                                 dataSize -= (DWORD)len;
 311                         }
 312                 }
 313                 if (skipcore)
 314                         *szCur = '\0';
 315                 else {
 316                         /* If we have no values, we dont need a ';' */
 317                         if (numKeys) {
 318                                 *(szCur++) = _T(';');
 319                                 dataSize--;
 320                         }
 321                         /* Now append the core path entries -
 322                            this will include the NULL
 323                         */
 324                         rc = RegQueryValueEx(newKey, NULL, 0, NULL,
 325                                              (LPBYTE)szCur, &dataSize);
 326                 }
 327                 /* And set the result - caller must free
 328                    If MBCS, it is fine as is.  If Unicode, allocate new
 329                    buffer and convert.
 330                 */
 331 #ifdef UNICODE
 332                 retval = (char *)malloc(reqdSize+1);
 333                 if (retval)
 334                         WideCharToMultiByte(CP_ACP, 0,
 335                                         dataBuf, -1, /* source */
 336                                         retval, reqdSize+1, /* dest */
 337                                         NULL, NULL);
 338                 free(dataBuf);
 339 #else
 340                 retval = dataBuf;
 341 #endif
 342         }
 343 done:
 344         /* Loop freeing my temp buffers */
 345         if (ppPaths) {
 346                 for(index=0;index<numKeys;index++)
 347                         if (ppPaths[index]) free(ppPaths[index]);
 348                 free(ppPaths);
 349         }
 350         if (newKey)
 351                 RegCloseKey(newKey);
 352         if (keyBuf)
 353                 free(keyBuf);
 354         return retval;
 355 }
 356 #endif /* MS_WINDOWS */
 357
 358 static void
 359 get_progpath(void)
 360 {
 361         extern char *Py_GetProgramName(void);
 362         char *path = getenv("PATH");
 363         char *prog = Py_GetProgramName();
 364
 365 #ifdef MS_WINDOWS
 366         extern HANDLE PyWin_DLLhModule;
 367 #ifdef UNICODE
 368         WCHAR wprogpath[MAXPATHLEN+1];
 369         /* Windows documents that GetModuleFileName() will "truncate",
 370            but makes no mention of the null terminator.  Play it safe.
 371            PLUS Windows itself defines MAX_PATH as the same, but anyway...
 372         */
 373         wprogpath[MAXPATHLEN]=_T('\0');
 374         if (PyWin_DLLhModule &&
 375             GetModuleFileName(PyWin_DLLhModule, wprogpath, MAXPATHLEN)) {
 376                 WideCharToMultiByte(CP_ACP, 0,
 377                                     wprogpath, -1,
 378                                     dllpath, MAXPATHLEN+1,
 379                                     NULL, NULL);
 380         }
 381         wprogpath[MAXPATHLEN]=_T('\0');
 382         if (GetModuleFileName(NULL, wprogpath, MAXPATHLEN)) {
 383                 WideCharToMultiByte(CP_ACP, 0,
 384                                     wprogpath, -1,
 385                                     progpath, MAXPATHLEN+1,
 386                                     NULL, NULL);
 387                 return;
 388         }
 389 #else
 390         /* static init of progpath ensures final char remains \0 */
 391         if (PyWin_DLLhModule)
 392                 if (!GetModuleFileName(PyWin_DLLhModule, dllpath, MAXPATHLEN))
 393                         dllpath[0] = 0;
 394         if (GetModuleFileName(NULL, progpath, MAXPATHLEN))
 395                 return;
 396 #endif
 397 #endif
 398         if (prog == NULL || *prog == '\0')
 399                 prog = "python";
 400
 401         /* If there is no slash in the argv0 path, then we have to
 402          * assume python is on the user's $PATH, since there's no
 403          * other way to find a directory to start the search from.  If
 404          * $PATH isn't exported, you lose.
 405          */
 406 #ifdef ALTSEP
 407         if (strchr(prog, SEP) || strchr(prog, ALTSEP))
 408 #else
 409         if (strchr(prog, SEP))
 410 #endif
 411                 strncpy(progpath, prog, MAXPATHLEN);
 412         else if (path) {
 413                 while (1) {
 414                         char *delim = strchr(path, DELIM);
 415
 416                         if (delim) {
 417                                 size_t len = delim - path;
 418                                 /* ensure we can't overwrite buffer */
 419                                 len = min(MAXPATHLEN,len);
 420                                 strncpy(progpath, path, len);
 421                                 *(progpath + len) = '\0';
 422                         }
 423                         else
 424                                 strncpy(progpath, path, MAXPATHLEN);
 425
 426                         /* join() is safe for MAXPATHLEN+1 size buffer */
 427                         join(progpath, prog);
 428                         if (exists(progpath))
 429                                 break;
 430
 431                         if (!delim) {
 432                                 progpath[0] = '\0';
 433                                 break;
 434                         }
 435                         path = delim + 1;
 436                 }
 437         }
 438         else
 439                 progpath[0] = '\0';
 440 }
 441
 442 static void
 443 calculate_path(void)
 444 {
 445         char argv0_path[MAXPATHLEN+1];
 446         char *buf;
 447         size_t bufsz;
 448         char *pythonhome = Py_GetPythonHome();
 449         char *envpath = Py_GETENV("PYTHONPATH");
 450
 451 #ifdef MS_WINDOWS
 452         int skiphome, skipdefault;
 453         char *machinepath = NULL;
 454         char *userpath = NULL;
 455         char zip_path[MAXPATHLEN+1];
 456         size_t len;
 457 #endif
 458
 459         get_progpath();
 460         /* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
 461         strcpy(argv0_path, progpath);
 462         reduce(argv0_path);
 463         if (pythonhome == NULL || *pythonhome == '\0') {
 464                 if (search_for_prefix(argv0_path, LANDMARK))
 465                         pythonhome = prefix;
 466                 else
 467                         pythonhome = NULL;
 468         }
 469         else
 470                 strncpy(prefix, pythonhome, MAXPATHLEN);
 471
 472         if (envpath && *envpath == '\0')
 473                 envpath = NULL;
 474
 475
 476 #ifdef MS_WINDOWS
 477         /* Calculate zip archive path */
 478         if (dllpath[0])         /* use name of python DLL */
 479                 strncpy(zip_path, dllpath, MAXPATHLEN);
 480         else                    /* use name of executable program */
 481                 strncpy(zip_path, progpath, MAXPATHLEN);
 482         zip_path[MAXPATHLEN] = '\0';
 483         len = strlen(zip_path);
 484         if (len > 4) {
 485                 zip_path[len-3] = 'z';  /* change ending to "zip" */
 486                 zip_path[len-2] = 'i';
 487                 zip_path[len-1] = 'p';
 488         }
 489         else {
 490                 zip_path[0] = 0;
 491         }
 492
 493         skiphome = pythonhome==NULL ? 0 : 1;
 494         machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, skiphome);
 495         userpath = getpythonregpath(HKEY_CURRENT_USER, skiphome);
 496         /* We only use the default relative PYTHONPATH if we havent
 497            anything better to use! */
 498         skipdefault = envpath!=NULL || pythonhome!=NULL || \
 499                       machinepath!=NULL || userpath!=NULL;
 500 #endif
 501
 502         /* We need to construct a path from the following parts.
 503            (1) the PYTHONPATH environment variable, if set;
 504            (2) for Win32, the zip archive file path;
 505            (3) for Win32, the machinepath and userpath, if set;
 506            (4) the PYTHONPATH config macro, with the leading "."
 507                of each component replaced with pythonhome, if set;
 508            (5) the directory containing the executable (argv0_path).
 509            The length calculation calculates #4 first.
 510            Extra rules:
 511            - If PYTHONHOME is set (in any way) item (3) is ignored.
 512            - If registry values are used, (4) and (5) are ignored.
 513         */
 514
 515         /* Calculate size of return buffer */
 516         if (pythonhome != NULL) {
 517                 char *p;
 518                 bufsz = 1;
 519                 for (p = PYTHONPATH; *p; p++) {
 520                         if (*p == DELIM)
 521                                 bufsz++; /* number of DELIM plus one */
 522                 }
 523                 bufsz *= strlen(pythonhome);
 524         }
 525         else
 526                 bufsz = 0;
 527         bufsz += strlen(PYTHONPATH) + 1;
 528         bufsz += strlen(argv0_path) + 1;
 529 #ifdef MS_WINDOWS
 530         if (userpath)
 531                 bufsz += strlen(userpath) + 1;
 532         if (machinepath)
 533                 bufsz += strlen(machinepath) + 1;
 534         bufsz += strlen(zip_path) + 1;
 535 #endif
 536         if (envpath != NULL)
 537                 bufsz += strlen(envpath) + 1;
 538
 539         module_search_path = buf = malloc(bufsz);
 540         if (buf == NULL) {
 541                 /* We can't exit, so print a warning and limp along */
 542                 fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
 543                 if (envpath) {
 544                         fprintf(stderr, "Using environment $PYTHONPATH.\n");
 545                         module_search_path = envpath;
 546                 }
 547                 else {
 548                         fprintf(stderr, "Using default static path.\n");
 549                         module_search_path = PYTHONPATH;
 550                 }
 551 #ifdef MS_WINDOWS
 552                 if (machinepath)
 553                         free(machinepath);
 554                 if (userpath)
 555                         free(userpath);
 556 #endif /* MS_WINDOWS */
 557                 return;
 558         }
 559
 560         if (envpath) {
 561                 strcpy(buf, envpath);
 562                 buf = strchr(buf, '\0');
 563                 *buf++ = DELIM;
 564         }
 565 #ifdef MS_WINDOWS
 566         if (zip_path[0]) {
 567                 strcpy(buf, zip_path);
 568                 buf = strchr(buf, '\0');
 569                 *buf++ = DELIM;
 570         }
 571         if (userpath) {
 572                 strcpy(buf, userpath);
 573                 buf = strchr(buf, '\0');
 574                 *buf++ = DELIM;
 575                 free(userpath);
 576         }
 577         if (machinepath) {
 578                 strcpy(buf, machinepath);
 579                 buf = strchr(buf, '\0');
 580                 *buf++ = DELIM;
 581                 free(machinepath);
 582         }
 583         if (pythonhome == NULL) {
 584                 if (!skipdefault) {
 585                         strcpy(buf, PYTHONPATH);
 586                         buf = strchr(buf, '\0');
 587                 }
 588         }
 589 #else
 590         if (pythonhome == NULL) {
 591                 strcpy(buf, PYTHONPATH);
 592                 buf = strchr(buf, '\0');
 593         }
 594 #endif /* MS_WINDOWS */
 595         else {
 596                 char *p = PYTHONPATH;
 597                 char *q;
 598                 size_t n;
 599                 for (;;) {
 600                         q = strchr(p, DELIM);
 601                         if (q == NULL)
 602                                 n = strlen(p);
 603                         else
 604                                 n = q-p;
 605                         if (p[0] == '.' && is_sep(p[1])) {
 606                                 strcpy(buf, pythonhome);
 607                                 buf = strchr(buf, '\0');
 608                                 p++;
 609                                 n--;
 610                         }
 611                         strncpy(buf, p, n);
 612                         buf += n;
 613                         if (q == NULL)
 614                                 break;
 615                         *buf++ = DELIM;
 616                         p = q+1;
 617                 }
 618         }
 619         if (argv0_path) {
 620                 *buf++ = DELIM;
 621                 strcpy(buf, argv0_path);
 622                 buf = strchr(buf, '\0');
 623         }
 624         *buf = '\0';
 625         /* Now to pull one last hack/trick.  If sys.prefix is
 626            empty, then try and find it somewhere on the paths
 627            we calculated.  We scan backwards, as our general policy
 628            is that Python core directories are at the *end* of
 629            sys.path.  We assume that our "lib" directory is
 630            on the path, and that our 'prefix' directory is
 631            the parent of that.
 632         */
 633         if (*prefix=='\0') {
 634                 char lookBuf[MAXPATHLEN+1];
 635                 char *look = buf - 1; /* 'buf' is at the end of the buffer */
 636                 while (1) {
 637                         Py_ssize_t nchars;
 638                         char *lookEnd = look;
 639                         /* 'look' will end up one character before the
 640                            start of the path in question - even if this
 641                            is one character before the start of the buffer
 642                         */
 643                         while (*look != DELIM && look >= module_search_path)
 644                                 look--;
 645                         nchars = lookEnd-look;
 646                         strncpy(lookBuf, look+1, nchars);
 647                         lookBuf[nchars] = '\0';
 648                         /* Up one level to the parent */
 649                         reduce(lookBuf);
 650                         if (search_for_prefix(lookBuf, LANDMARK)) {
 651                                 break;
 652                         }
 653                         /* If we are out of paths to search - give up */
 654                         if (look < module_search_path)
 655                                 break;
 656                         look--;
 657                 }
 658         }
 659 }
 660
 661
 662 /* External interface */
 663
 664 char *
 665 Py_GetPath(void)
 666 {
 667         if (!module_search_path)
 668                 calculate_path();
 669         return module_search_path;
 670 }
 671
 672 char *
 673 Py_GetPrefix(void)
 674 {
 675         if (!module_search_path)
 676                 calculate_path();
 677         return prefix;
 678 }
 679
 680 char *
 681 Py_GetExecPrefix(void)
 682 {
 683         return Py_GetPrefix();
 684 }
 685
 686 char *
 687 Py_GetProgramFullPath(void)
 688 {
 689         if (!module_search_path)
 690                 calculate_path();
 691         return progpath;
 692 }