Changeset 391 for python/trunk/PC/os2emx/getpathp.c

Timestamp:

Mar 19, 2014, 11:31:01 PM (11 years ago)

Author:

dmik

Message:

python: Merge vendor 2.7.6 to trunk.

Location:

python/trunk

Files:

• . (modified) (1 prop)
• PC/os2emx/getpathp.c (modified) (15 diffs)

python/trunk/PC/os2emx/getpathp.c

@@ -5 +5 @@
 /* ----------------------------------------------------------------
    PATH RULES FOR OS/2+EMX:
-   This describes how sys.path is formed on OS/2+EMX.  It describes the 
-   functionality, not the implementation (ie, the order in which these 
+   This describes how sys.path is formed on OS/2+EMX.  It describes the
+   functionality, not the implementation (ie, the order in which these
    are actually fetched is different)
 
@@ -17 +17 @@
      is set, we believe it.  Otherwise, we use the path of our host .EXE's
      to try and locate our "landmark" (lib\\os.py) and deduce our home.
-     - If we DO have a Python Home: The relevant sub-directories (Lib, 
+     - If we DO have a Python Home: The relevant sub-directories (Lib,
        plat-win, lib-tk, etc) are based on the Python Home
      - If we DO NOT have a Python Home, the core Python Path is
-       loaded from the registry.  This is the main PythonPath key, 
+       loaded from the registry.  This is the main PythonPath key,
        and both HKLM and HKCU are combined to form the path)
 
@@ -33 +33 @@
     the core path is deduced.
 
-  * When Python is hosted in another exe (different directory, embedded via 
+  * When Python is hosted in another exe (different directory, embedded via
     COM, etc), the Python Home will not be deduced, so the core path from
-    the registry is used.  Other "application paths "in the registry are 
+    the registry is used.  Other "application paths "in the registry are
     always read.
 
@@ -86 +86 @@
 
 static int
-is_sep(char ch) /* determine if "ch" is a separator character */
+is_sep(char ch) /* determine if "ch" is a separator character */
 {
 #ifdef ALTSEP
-        return ch == SEP || ch == ALTSEP;
+    return ch == SEP || ch == ALTSEP;
 #else
-        return ch == SEP;
+    return ch == SEP;
 #endif
 }
@@ -101 +101 @@
 reduce(char *dir)
 {
-        size_t i = strlen(dir);
-        while (i > 0 && !is_sep(dir[i]))
-                --i;
-        dir[i] = '\0';
-}
-        
+    size_t i = strlen(dir);
+    while (i > 0 && !is_sep(dir[i]))
+        --i;
+    dir[i] = '\0';
+}
+
 static int
 exists(char *filename)
 {
-        struct stat buf;
-        return stat(filename, &buf) == 0;
+    struct stat buf;
+    return stat(filename, &buf) == 0;
 }
 
 /* Is module  (check for .pyc/.pyo too)
- * Assumes 'filename' MAXPATHLEN+1 bytes long - 
+ * Assumes 'filename' MAXPATHLEN+1 bytes long -
  * may extend 'filename' by one character.
  */
@@ -121 +121 @@
 ismodule(char *filename)
 {
-        if (exists(filename))
-                return 1;
-
-        /* Check for the compiled version of prefix. */
-        if (strlen(filename) < MAXPATHLEN) {
-                strcat(filename, Py_OptimizeFlag ? "o" : "c");
-                if (exists(filename))
-                        return 1;
-        }
-        return 0;
+    if (exists(filename))
+        return 1;
+
+    /* Check for the compiled version of prefix. */
+    if (strlen(filename) < MAXPATHLEN) {
+        strcat(filename, Py_OptimizeFlag ? "o" : "c");
+        if (exists(filename))
+            return 1;
+    }
+    return 0;
 }
 
@@ -146 +146 @@
 join(char *buffer, char *stuff)
 {
-        size_t n, k;
-        if (is_sep(stuff[0]))
-                n = 0;
-        else {
-                n = strlen(buffer);
-                if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN)
-                        buffer[n++] = SEP;
-        }
-        if (n > MAXPATHLEN)
-                Py_FatalError("buffer overflow in getpathp.c's joinpath()");
-        k = strlen(stuff);
-        if (n + k > MAXPATHLEN)
-                k = MAXPATHLEN - n;
-        strncpy(buffer+n, stuff, k);
-        buffer[n+k] = '\0';
+    size_t n, k;
+    if (is_sep(stuff[0]))
+        n = 0;
+    else {
+        n = strlen(buffer);
+        if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN)
+            buffer[n++] = SEP;
+    }
+    if (n > MAXPATHLEN)
+        Py_FatalError("buffer overflow in getpathp.c's joinpath()");
+    k = strlen(stuff);
+    if (n + k > MAXPATHLEN)
+        k = MAXPATHLEN - n;
+    strncpy(buffer+n, stuff, k);
+    buffer[n+k] = '\0';
 }
 
@@ -170 +170 @@
 gotlandmark(char *landmark)
 {
-        int n, ok;
-
-        n = strlen(prefix);
-        join(prefix, landmark);
-        ok = ismodule(prefix);
-        prefix[n] = '\0';
-        return ok;
-}
-
-/* assumes argv0_path is MAXPATHLEN+1 bytes long, already \0 term'd. 
+    int n, ok;
+
+    n = strlen(prefix);
+    join(prefix, landmark);
+    ok = ismodule(prefix);
+    prefix[n] = '\0';
+    return ok;
+}
+
+/* assumes argv0_path is MAXPATHLEN+1 bytes long, already \0 term'd.
  * assumption provided by only caller, calculate_path()
  */
@@ -185 +185 @@
 search_for_prefix(char *argv0_path, char *landmark)
 {
-        /* Search from argv0_path, until landmark is found */
-        strcpy(prefix, argv0_path);
-        do {
-                if (gotlandmark(landmark))
-                        return 1;
-                reduce(prefix);
-        } while (prefix[0]);
-        return 0;
+    /* Search from argv0_path, until landmark is found */
+    strcpy(prefix, argv0_path);
+    do {
+        if (gotlandmark(landmark))
+            return 1;
+        reduce(prefix);
+    } while (prefix[0]);
+    return 0;
 }
 
@@ -199 +199 @@
 get_progpath(void)
 {
-        extern char *Py_GetProgramName(void);
-        char *path = getenv("PATH");
-        char *prog = Py_GetProgramName();
-
-        PPIB pib;
-        if ((DosGetInfoBlocks(NULL, &pib) == 0) &&
-            (DosQueryModuleName(pib->pib_hmte, sizeof(progpath), progpath) == 0))
-                return;
-
-        if (prog == NULL || *prog == '\0')
-                prog = "python";
-
-        /* If there is no slash in the argv0 path, then we have to
-         * assume python is on the user's $PATH, since there's no
-         * other way to find a directory to start the search from.  If
-         * $PATH isn't exported, you lose.
-         */
+    extern char *Py_GetProgramName(void);
+    char *path = getenv("PATH");
+    char *prog = Py_GetProgramName();
+
+    PPIB pib;
+    if ((DosGetInfoBlocks(NULL, &pib) == 0) &&
+        (DosQueryModuleName(pib->pib_hmte, sizeof(progpath), progpath) == 0))
+        return;
+
+    if (prog == NULL || *prog == '\0')
+        prog = "python";
+
+    /* If there is no slash in the argv0 path, then we have to
+     * assume python is on the user's $PATH, since there's no
+     * other way to find a directory to start the search from.  If
+     * $PATH isn't exported, you lose.
+     */
 #ifdef ALTSEP
-        if (strchr(prog, SEP) || strchr(prog, ALTSEP))
+    if (strchr(prog, SEP) || strchr(prog, ALTSEP))
 #else
-        if (strchr(prog, SEP))
-#endif
-                strncpy(progpath, prog, MAXPATHLEN);
-        else if (path) {
-                while (1) {
-                        char *delim = strchr(path, DELIM);
-
-                        if (delim) {
-                                size_t len = delim - path;
-                                /* ensure we can't overwrite buffer */
+    if (strchr(prog, SEP))
+#endif
+        strncpy(progpath, prog, MAXPATHLEN);
+    else if (path) {
+        while (1) {
+            char *delim = strchr(path, DELIM);
+
+            if (delim) {
+                size_t len = delim - path;
+                /* ensure we can't overwrite buffer */
 #if !defined(PYCC_GCC)
-                                len = min(MAXPATHLEN,len);
+                len = min(MAXPATHLEN,len);
 #else
-                                len = MAXPATHLEN < len ? MAXPATHLEN : len;
-#endif
-                                strncpy(progpath, path, len);
-                                *(progpath + len) = '\0';
-                        }
-                        else
-                                strncpy(progpath, path, MAXPATHLEN);
-
-                        /* join() is safe for MAXPATHLEN+1 size buffer */
-                        join(progpath, prog);
-                        if (exists(progpath))
-                                break;
-
-                        if (!delim) {
-                                progpath[0] = '\0';
-                                break;
-                        }
-                        path = delim + 1;
-                }
-        }
-        else
-                progpath[0] = '\0';
+                len = MAXPATHLEN < len ? MAXPATHLEN : len;
+#endif
+                strncpy(progpath, path, len);
+                *(progpath + len) = '\0';
+            }
+            else
+                strncpy(progpath, path, MAXPATHLEN);
+
+            /* join() is safe for MAXPATHLEN+1 size buffer */
+            join(progpath, prog);
+            if (exists(progpath))
+                break;
+
+            if (!delim) {
+                progpath[0] = '\0';
+                break;
+            }
+            path = delim + 1;
+        }
+    }
+    else
+        progpath[0] = '\0';
 }
 
@@ -259 +259 @@
 calculate_path(void)
 {
-        char argv0_path[MAXPATHLEN+1];
-        char *buf;
-        size_t bufsz;
-        char *pythonhome = Py_GetPythonHome();
-        char *envpath = getenv("PYTHONPATH");
-        char zip_path[MAXPATHLEN+1];
-        size_t len;
-
-        get_progpath();
-        /* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
-        strcpy(argv0_path, progpath);
-        reduce(argv0_path);
-        if (pythonhome == NULL || *pythonhome == '\0') {
-                if (search_for_prefix(argv0_path, LANDMARK))
-                        pythonhome = prefix;
-                else
-                        pythonhome = NULL;
-        }
-        else
-                strncpy(prefix, pythonhome, MAXPATHLEN);
-
-        if (envpath && *envpath == '\0')
-                envpath = NULL;
-
-        /* Calculate zip archive path */
-        strncpy(zip_path, progpath, MAXPATHLEN);
-        zip_path[MAXPATHLEN] = '\0';
-        len = strlen(zip_path);
-        if (len > 4) {
-                zip_path[len-3] = 'z';  /* change ending to "zip" */
-                zip_path[len-2] = 'i';
-                zip_path[len-1] = 'p';
-        }
-        else {
-                zip_path[0] = 0;
-        }
-
-        /* We need to construct a path from the following parts.
-         * (1) the PYTHONPATH environment variable, if set;
-         * (2) the zip archive file path;
-         * (3) the PYTHONPATH config macro, with the leading "."
-         *     of each component replaced with pythonhome, if set;
-         * (4) the directory containing the executable (argv0_path).
-         * The length calculation calculates #3 first.
-         */
-
-        /* Calculate size of return buffer */
-        if (pythonhome != NULL) {
-                char *p;
-                bufsz = 1;      
-                for (p = PYTHONPATH; *p; p++) {
-                        if (*p == DELIM)
-                                bufsz++; /* number of DELIM plus one */
-                }
-                bufsz *= strlen(pythonhome);
-        }
-        else
-                bufsz = 0;
-        bufsz += strlen(PYTHONPATH) + 1;
-        bufsz += strlen(argv0_path) + 1;
-        bufsz += strlen(zip_path) + 1;
-        if (envpath != NULL)
-                bufsz += strlen(envpath) + 1;
-
-        module_search_path = buf = malloc(bufsz);
-        if (buf == NULL) {
-                /* We can't exit, so print a warning and limp along */
-                fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
-                if (envpath) {
-                        fprintf(stderr, "Using environment $PYTHONPATH.\n");
-                        module_search_path = envpath;
-                }
-                else {
-                        fprintf(stderr, "Using default static path.\n");
-                        module_search_path = PYTHONPATH;
-                }
-                return;
-        }
-
-        if (envpath) {
-                strcpy(buf, envpath);
-                buf = strchr(buf, '\0');
-                *buf++ = DELIM;
-        }
-        if (zip_path[0]) {
-                strcpy(buf, zip_path);
-                buf = strchr(buf, '\0');
-                *buf++ = DELIM;
-        }
-
-        if (pythonhome == NULL) {
-                strcpy(buf, PYTHONPATH);
-                buf = strchr(buf, '\0');
-        }
-        else {
-                char *p = PYTHONPATH;
-                char *q;
-                size_t n;
-                for (;;) {
-                        q = strchr(p, DELIM);
-                        if (q == NULL)
-                                n = strlen(p);
-                        else
-                                n = q-p;
-                        if (p[0] == '.' && is_sep(p[1])) {
-                                strcpy(buf, pythonhome);
-                                buf = strchr(buf, '\0');
-                                p++;
-                                n--;
-                        }
-                        strncpy(buf, p, n);
-                        buf += n;
-                        if (q == NULL)
-                                break;
-                        *buf++ = DELIM;
-                        p = q+1;
-                }
-        }
-        if (argv0_path) {
-                *buf++ = DELIM;
-                strcpy(buf, argv0_path);
-                buf = strchr(buf, '\0');
-        }
-        *buf = '\0';
+    char argv0_path[MAXPATHLEN+1];
+    char *buf;
+    size_t bufsz;
+    char *pythonhome = Py_GetPythonHome();
+    char *envpath = getenv("PYTHONPATH");
+    char zip_path[MAXPATHLEN+1];
+    size_t len;
+
+    get_progpath();
+    /* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
+    strcpy(argv0_path, progpath);
+    reduce(argv0_path);
+    if (pythonhome == NULL || *pythonhome == '\0') {
+        if (search_for_prefix(argv0_path, LANDMARK))
+            pythonhome = prefix;
+        else
+            pythonhome = NULL;
+    }
+    else
+        strncpy(prefix, pythonhome, MAXPATHLEN);
+
+    if (envpath && *envpath == '\0')
+        envpath = NULL;
+
+    /* Calculate zip archive path */
+    strncpy(zip_path, progpath, MAXPATHLEN);
+    zip_path[MAXPATHLEN] = '\0';
+    len = strlen(zip_path);
+    if (len > 4) {
+        zip_path[len-3] = 'z';  /* change ending to "zip" */
+        zip_path[len-2] = 'i';
+        zip_path[len-1] = 'p';
+    }
+    else {
+        zip_path[0] = 0;
+    }
+
+    /* We need to construct a path from the following parts.
+     * (1) the PYTHONPATH environment variable, if set;
+     * (2) the zip archive file path;
+     * (3) the PYTHONPATH config macro, with the leading "."
+     *     of each component replaced with pythonhome, if set;
+     * (4) the directory containing the executable (argv0_path).
+     * The length calculation calculates #3 first.
+     */
+
+    /* Calculate size of return buffer */
+    if (pythonhome != NULL) {
+        char *p;
+        bufsz = 1;
+        for (p = PYTHONPATH; *p; p++) {
+            if (*p == DELIM)
+                bufsz++; /* number of DELIM plus one */
+        }
+        bufsz *= strlen(pythonhome);
+    }
+    else
+        bufsz = 0;
+    bufsz += strlen(PYTHONPATH) + 1;
+    bufsz += strlen(argv0_path) + 1;
+    bufsz += strlen(zip_path) + 1;
+    if (envpath != NULL)
+        bufsz += strlen(envpath) + 1;
+
+    module_search_path = buf = malloc(bufsz);
+    if (buf == NULL) {
+        /* We can't exit, so print a warning and limp along */
+        fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
+        if (envpath) {
+            fprintf(stderr, "Using environment $PYTHONPATH.\n");
+            module_search_path = envpath;
+        }
+        else {
+            fprintf(stderr, "Using default static path.\n");
+            module_search_path = PYTHONPATH;
+        }
+        return;
+    }
+
+    if (envpath) {
+        strcpy(buf, envpath);
+        buf = strchr(buf, '\0');
+        *buf++ = DELIM;
+    }
+    if (zip_path[0]) {
+        strcpy(buf, zip_path);
+        buf = strchr(buf, '\0');
+        *buf++ = DELIM;
+    }
+
+    if (pythonhome == NULL) {
+        strcpy(buf, PYTHONPATH);
+        buf = strchr(buf, '\0');
+    }
+    else {
+        char *p = PYTHONPATH;
+        char *q;
+        size_t n;
+        for (;;) {
+            q = strchr(p, DELIM);
+            if (q == NULL)
+                n = strlen(p);
+            else
+                n = q-p;
+            if (p[0] == '.' && is_sep(p[1])) {
+                strcpy(buf, pythonhome);
+                buf = strchr(buf, '\0');
+                p++;
+                n--;
+            }
+            strncpy(buf, p, n);
+            buf += n;
+            if (q == NULL)
+                break;
+            *buf++ = DELIM;
+            p = q+1;
+        }
+    }
+    if (argv0_path) {
+        *buf++ = DELIM;
+        strcpy(buf, argv0_path);
+        buf = strchr(buf, '\0');
+    }
+    *buf = '\0';
 }
 
@@ -391 +391 @@
 Py_GetPath(void)
 {
-        if (!module_search_path)
-                calculate_path();
-        return module_search_path;
+    if (!module_search_path)
+        calculate_path();
+    return module_search_path;
 }
 
@@ -399 +399 @@
 Py_GetPrefix(void)
 {
-        if (!module_search_path)
-                calculate_path();
-        return prefix;
+    if (!module_search_path)
+        calculate_path();
+    return prefix;
 }
 
@@ -407 +407 @@
 Py_GetExecPrefix(void)
 {
-        return Py_GetPrefix();
+    return Py_GetPrefix();
 }
 
@@ -413 +413 @@
 Py_GetProgramFullPath(void)
 {
-        if (!module_search_path)
-                calculate_path();
-        return progpath;
-}
+    if (!module_search_path)
+        calculate_path();
+    return progpath;
+}