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 */ 9char * 10convert_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 */ 28char * 29convert_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 */ 68char * 69w32ify(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 86char * 87getcwd_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 */ 108char * 109convert_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 239