gnu/dist/gmake/w32/pathstuff.c

   1 #include <string.h>
   2 #include <stdlib.h>
   3 #include "make.h"
   4 #include "pathstuff.h"
   5
   6 /*
   7  * Convert delimiter separated vpath to Canonical format.
   8  */
   9 char *
  10 convert_vpath_to_windows32(char *Path, char to_delim)
  11 {
  12     char *etok;            /* token separator for old Path */
  13
  14         /*
  15          * Convert all spaces to delimiters. Note that pathnames which
  16          * contain blanks get trounced here. Use 8.3 format as a workaround.
  17          */
  18         for (etok = Path; etok && *etok; etok++)
  19                 if (isblank ((unsigned char) *etok))
  20                         *etok = to_delim;
  21
  22         return (convert_Path_to_windows32(Path, to_delim));
  23 }
  24
  25 /*
  26  * Convert delimiter separated path to Canonical format.
  27  */
  28 char *
  29 convert_Path_to_windows32(char *Path, char to_delim)
  30 {
  31     char *etok;            /* token separator for old Path */
  32     char *p;            /* points to element of old Path */
  33
  34     /* is this a multi-element Path ? */
  35     for (p = Path, etok = strpbrk(p, ":;");
  36          etok;
  37          etok = strpbrk(p, ":;"))
  38         if ((etok - p) == 1) {
  39             if (*(etok - 1) == ';' ||
  40                 *(etok - 1) == ':') {
  41                 etok[-1] = to_delim;
  42                 etok[0] = to_delim;
  43                 p = ++etok;
  44                 continue;    /* ignore empty bucket */
  45             } else if (!isalpha ((unsigned char) *p)) {
  46                 /* found one to count, handle things like '.' */
  47                 *etok = to_delim;
  48                 p = ++etok;
  49             } else if ((*etok == ':') && (etok = strpbrk(etok+1, ":;"))) {
  50                 /* found one to count, handle drive letter */
  51                 *etok = to_delim;
  52                 p = ++etok;
  53             } else
  54                 /* all finished, force abort */
  55                 p += strlen(p);
  56         } else {
  57             /* found another one, no drive letter */
  58             *etok = to_delim;
  59             p = ++etok;
  60         }
  61
  62     return Path;
  63 }
  64
  65 /*
  66  * Convert to forward slashes. Resolve to full pathname optionally
  67  */
  68 char *
  69 w32ify(char *filename, int resolve)
  70 {
  71     static char w32_path[FILENAME_MAX];
  72     char *p;
  73
  74     if (resolve)
  75         _fullpath(w32_path, filename, sizeof (w32_path));
  76     else
  77         strncpy(w32_path, filename, sizeof (w32_path));
  78
  79     for (p = w32_path; p && *p; p++)
  80         if (*p == '\\')
  81             *p = '/';
  82
  83     return w32_path;
  84 }
  85
  86 char *
  87 getcwd_fs(char* buf, int len)
  88 {
  89         char *p;
  90
  91         if (p = getcwd(buf, len)) {
  92                 char *q = w32ify(buf, 0);
  93                 strncpy(buf, q, len);
  94         }
  95
  96         return p;
  97 }
  98
  99 #ifdef unused
 100 /*
 101  * Convert delimiter separated pathnames (e.g. PATH) or single file pathname
 102  * (e.g. c:/foo, c:\bar) to NutC format. If we are handed a string that
 103  * _NutPathToNutc() fails to convert, just return the path we were handed
 104  * and assume the caller will know what to do with it (It was probably
 105  * a mistake to try and convert it anyway due to some of the bizarre things
 106  * that might look like pathnames in makefiles).
 107  */
 108 char *
 109 convert_path_to_nutc(char *path)
 110 {
 111     int  count;            /* count of path elements */
 112     char *nutc_path;     /* new NutC path */
 113     int  nutc_path_len;    /* length of buffer to allocate for new path */
 114     char *pathp;        /* pointer to nutc_path used to build it */
 115     char *etok;            /* token separator for old path */
 116     char *p;            /* points to element of old path */
 117     char sep;            /* what flavor of separator used in old path */
 118     char *rval;
 119
 120     /* is this a multi-element path ? */
 121     for (p = path, etok = strpbrk(p, ":;"), count = 0;
 122          etok;
 123          etok = strpbrk(p, ":;"))
 124         if ((etok - p) == 1) {
 125             if (*(etok - 1) == ';' ||
 126                 *(etok - 1) == ':') {
 127                 p = ++etok;
 128                 continue;    /* ignore empty bucket */
 129             } else if (etok = strpbrk(etok+1, ":;"))
 130                 /* found one to count, handle drive letter */
 131                 p = ++etok, count++;
 132             else
 133                 /* all finished, force abort */
 134                 p += strlen(p);
 135         } else
 136             /* found another one, no drive letter */
 137             p = ++etok, count++;
 138
 139     if (count) {
 140         count++;    /* x1;x2;x3 <- need to count x3 */
 141
 142         /*
 143          * Hazard a guess on how big the buffer needs to be.
 144          * We have to convert things like c:/foo to /c=/foo.
 145          */
 146         nutc_path_len = strlen(path) + (count*2) + 1;
 147         nutc_path = xmalloc(nutc_path_len);
 148         pathp = nutc_path;
 149         *pathp = '\0';
 150
 151         /*
 152          * Loop through PATH and convert one elemnt of the path at at
 153          * a time. Single file pathnames will fail this and fall
 154          * to the logic below loop.
 155          */
 156         for (p = path, etok = strpbrk(p, ":;");
 157              etok;
 158              etok = strpbrk(p, ":;")) {
 159
 160             /* don't trip up on device specifiers or empty path slots */
 161             if ((etok - p) == 1)
 162                 if (*(etok - 1) == ';' ||
 163                     *(etok - 1) == ':') {
 164                     p = ++etok;
 165                     continue;
 166                 } else if ((etok = strpbrk(etok+1, ":;")) == NULL)
 167                     break;    /* thing found was a WINDOWS32 pathname */
 168
 169             /* save separator */
 170             sep = *etok;
 171
 172             /* terminate the current path element -- temporarily */
 173             *etok = '\0';
 174
 175 #ifdef __NUTC__
 176             /* convert to NutC format */
 177             if (_NutPathToNutc(p, pathp, 0) == FALSE) {
 178                 free(nutc_path);
 179                 rval = savestring(path, strlen(path));
 180                 return rval;
 181             }
 182 #else
 183             *pathp++ = '/';
 184             *pathp++ = p[0];
 185             *pathp++ = '=';
 186             *pathp++ = '/';
 187             strcpy(pathp, &p[2]);
 188 #endif
 189
 190             pathp += strlen(pathp);
 191             *pathp++ = ':';     /* use Unix style path separtor for new path */
 192             *pathp   = '\0'; /* make sure we are null terminaed */
 193
 194             /* restore path separator */
 195             *etok = sep;
 196
 197             /* point p to first char of next path element */
 198             p = ++etok;
 199
 200         }
 201     } else {
 202         nutc_path_len = strlen(path) + 3;
 203         nutc_path = xmalloc(nutc_path_len);
 204         pathp = nutc_path;
 205         *pathp = '\0';
 206         p = path;
 207     }
 208
 209     /*
 210       * OK, here we handle the last element in PATH (e.g. c of a;b;c)
 211      * or the path was a single filename and will be converted
 212      * here. Note, testing p here assures that we don't trip up
 213      * on paths like a;b; which have trailing delimiter followed by
 214      * nothing.
 215      */
 216     if (*p != '\0') {
 217 #ifdef __NUTC__
 218         if (_NutPathToNutc(p, pathp, 0) == FALSE) {
 219             free(nutc_path);
 220             rval = savestring(path, strlen(path));
 221             return rval;
 222         }
 223 #else
 224         *pathp++ = '/';
 225         *pathp++ = p[0];
 226         *pathp++ = '=';
 227         *pathp++ = '/';
 228         strcpy(pathp, &p[2]);
 229 #endif
 230     } else
 231         *(pathp-1) = '\0'; /* we're already done, don't leave trailing : */
 232
 233     rval = savestring(nutc_path, strlen(nutc_path));
 234     free(nutc_path);
 235     return rval;
 236 }
 237
 238 #endif