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