70 @@ -710,8 +714,30 @@

    71      if (_rtpypath && _rtpypath[0] != '\0') {

    72          size_t rtpypath_len;

    73          rtpypath = _Py_char2wchar(_rtpypath, &rtpypath_len);

    74 -        if (rtpypath != NULL)

    75 -            bufsz += rtpypath_len + 1;

    76 +        if (rtpypath != NULL) {

    77 +            wchar_t *orig_rtpypath = rtpypath;

    78 +

    79 +            /*

    80 +             * Split the path; for each component, add that component + "/64"

    81 +             * (if in 64-bit mode) and the component unadorned (regardless).

    82 +             */

    83 +            while (1) {

    84 +                wchar_t *delim = wcschr(rtpypath, DELIM);

    85 +                if (delim) {

    86 +                    /* once for usual, another for usual + "/64" */

    87 +                    bufsz += delim - rtpypath + 1;

    88 +                    if (sizeof(void *) == 8)

    89 +                        bufsz += delim - rtpypath + 1 + 3;

    90 +                } else {

    91 +                    bufsz += wcslen(rtpypath) + 1;

    92 +                    if (sizeof(void *) == 8)

    93 +                        bufsz += wcslen(rtpypath) + 1 + 3;

    94 +                    break;

    95 +                }

    96 +                rtpypath = delim + 1;

    97 +            }

    98 +            rtpypath = orig_rtpypath;

    99 +        }

   100      }

   101  

   102      defpath = _pythonpath;

   103 @@ -723,9 +749,19 @@

   104              /* Paths are relative to prefix */

   105              bufsz += prefixsz;

   106  

   107 -        if (delim)

   108 +        if (delim) {

   109 +            if (sizeof(void *) == 8) {

   110 +                bufsz += delim - defpath + 1 + 3;

   111 +                if (defpath[0] != SEP)

   112 +                    bufsz += prefixsz;

   113 +            }

   114              bufsz += delim - defpath + 1;

   115 -        else {

   116 +        } else {

   117 +            if (sizeof(void *) == 8) {

   118 +                bufsz += wcslen(defpath) + 1 + 3;

   119 +                if (defpath[0] != SEP)

   120 +                    bufsz += prefixsz;

   121 +            }

   122              bufsz += wcslen(defpath) + 1;

   123              break;

   124          }

   125 @@ -741,13 +777,38 @@

   126              "Not enough memory for dynamic PYTHONPATH");

   127      }

   128  

   129 +    buf[0] = '\0';

   130      /* Run-time value of $PYTHONPATH goes first */

   131      if (rtpypath) {

   132 -        wcscpy(buf, rtpypath);

   133 -        wcscat(buf, delimiter);

   134 +        wchar_t *orig_rtpypath = rtpypath;

   135 +

   136 +        while (1) {

   137 +            wchar_t *delim = wcschr(rtpypath, DELIM);

   138 +

   139 +            if (delim) {

   140 +                *delim = '\0';

   141 +                if (sizeof(void *) == 8) {

   142 +                    wcscat(buf, rtpypath);

   143 +                    wcscat(buf, L"/64");

   144 +                    wcscat(buf, delimiter);

   145 +                }

   146 +                wcscat(buf, rtpypath);

   147 +                wcscat(buf, delimiter);

   148 +                *delim = DELIM;

   149 +            } else {

   150 +                if (sizeof(void *) == 8) {

   151 +                    wcscat(buf, rtpypath);

   152 +                    wcscat(buf, L"/64");

   153 +                    wcscat(buf, delimiter);

   154 +                }

   155 +                wcscat(buf, rtpypath);

   156 +                wcscat(buf, delimiter);

   157 +                break;

   158 +            }

   159 +            rtpypath = delim + 1;

   160 +        }

   161 +        rtpypath = orig_rtpypath;

   162      }

   163 -    else

   164 -        buf[0] = '\0';

   165  

   166      /* Next is the default zip path */

   167      wcscat(buf, zip_path);

   168 @@ -766,18 +827,35 @@

   169          }

   170  

   171          if (delim) {

   172 -            size_t len = delim - defpath + 1;

   173 -            size_t end = wcslen(buf) + len;

   174 -            wcsncat(buf, defpath, len);

   175 -            *(buf + end) = '\0';

   176 -        }

   177 -        else {

   178 +            *delim = '\0';

   179 +            if (sizeof(void *) == 8) {

   180 +                wcscat(buf, defpath);

   181 +                wcscat(buf, L"/64");

   182 +                wcscat(buf, delimiter);

   183 +                if (defpath[0] != SEP) {

   184 +                    wcscat(buf, prefix);

   185 +                    wcscat(buf, separator);

   186 +                }

   187 +            }

   188              wcscat(buf, defpath);

   189 +            wcscat(buf, delimiter);

   190 +            *delim = DELIM;

   191 +        } else {

   192 +            if (sizeof(void *) == 8) {

   193 +                wcscat(buf, defpath);

   194 +                wcscat(buf, L"/64");

   195 +                wcscat(buf, delimiter);

   196 +                if (defpath[0] != SEP) {

   197 +                    wcscat(buf, prefix);

   198 +                    wcscat(buf, separator);

   199 +                }

   200 +            }

   201 +            wcscat(buf, defpath);

   202 +            wcscat(buf, delimiter);

   203              break;

   204          }

   205          defpath = delim + 1;

   206      }

   207 -    wcscat(buf, delimiter);

   208  

   209      /* Finally, on goes the directory for dynamic-load modules */

   210      wcscat(buf, exec_prefix);