|
0
|
1 /* Relative (relocatable) prefix support.
|
|
|
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
|
|
3 1999, 2000, 2001, 2002, 2006 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 This file is part of libiberty.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 2, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING. If not, write to the Free
|
|
|
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
|
|
|
20 02110-1301, USA. */
|
|
|
21
|
|
|
22 /*
|
|
|
23
|
|
|
24 @deftypefn Extension {const char*} make_relative_prefix (const char *@var{progname}, const char *@var{bin_prefix}, const char *@var{prefix})
|
|
|
25
|
|
|
26 Given three paths @var{progname}, @var{bin_prefix}, @var{prefix},
|
|
|
27 return the path that is in the same position relative to
|
|
|
28 @var{progname}'s directory as @var{prefix} is relative to
|
|
|
29 @var{bin_prefix}. That is, a string starting with the directory
|
|
|
30 portion of @var{progname}, followed by a relative pathname of the
|
|
|
31 difference between @var{bin_prefix} and @var{prefix}.
|
|
|
32
|
|
|
33 If @var{progname} does not contain any directory separators,
|
|
|
34 @code{make_relative_prefix} will search @env{PATH} to find a program
|
|
|
35 named @var{progname}. Also, if @var{progname} is a symbolic link,
|
|
|
36 the symbolic link will be resolved.
|
|
|
37
|
|
|
38 For example, if @var{bin_prefix} is @code{/alpha/beta/gamma/gcc/delta},
|
|
|
39 @var{prefix} is @code{/alpha/beta/gamma/omega/}, and @var{progname} is
|
|
|
40 @code{/red/green/blue/gcc}, then this function will return
|
|
|
41 @code{/red/green/blue/../../omega/}.
|
|
|
42
|
|
|
43 The return value is normally allocated via @code{malloc}. If no
|
|
|
44 relative prefix can be found, return @code{NULL}.
|
|
|
45
|
|
|
46 @end deftypefn
|
|
|
47
|
|
|
48 */
|
|
|
49
|
|
|
50 #ifdef HAVE_CONFIG_H
|
|
|
51 #include "config.h"
|
|
|
52 #endif
|
|
|
53
|
|
|
54 #ifdef HAVE_STDLIB_H
|
|
|
55 #include <stdlib.h>
|
|
|
56 #endif
|
|
|
57 #ifdef HAVE_UNISTD_H
|
|
|
58 #include <unistd.h>
|
|
|
59 #endif
|
|
|
60
|
|
|
61 #include <string.h>
|
|
|
62
|
|
|
63 #include "ansidecl.h"
|
|
|
64 #include "libiberty.h"
|
|
|
65
|
|
|
66 #ifndef R_OK
|
|
|
67 #define R_OK 4
|
|
|
68 #define W_OK 2
|
|
|
69 #define X_OK 1
|
|
|
70 #endif
|
|
|
71
|
|
|
72 #ifndef DIR_SEPARATOR
|
|
|
73 # define DIR_SEPARATOR '/'
|
|
|
74 #endif
|
|
|
75
|
|
|
76 #if defined (_WIN32) || defined (__MSDOS__) \
|
|
|
77 || defined (__DJGPP__) || defined (__OS2__)
|
|
|
78 # define HAVE_DOS_BASED_FILE_SYSTEM
|
|
|
79 # define HAVE_HOST_EXECUTABLE_SUFFIX
|
|
|
80 # define HOST_EXECUTABLE_SUFFIX ".exe"
|
|
|
81 # ifndef DIR_SEPARATOR_2
|
|
|
82 # define DIR_SEPARATOR_2 '\\'
|
|
|
83 # endif
|
|
|
84 # define PATH_SEPARATOR ';'
|
|
|
85 #else
|
|
|
86 # define PATH_SEPARATOR ':'
|
|
|
87 #endif
|
|
|
88
|
|
|
89 #ifndef DIR_SEPARATOR_2
|
|
|
90 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
|
|
|
91 #else
|
|
|
92 # define IS_DIR_SEPARATOR(ch) \
|
|
|
93 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
|
|
|
94 #endif
|
|
|
95
|
|
|
96 #define DIR_UP ".."
|
|
|
97
|
|
|
98 static char *save_string (const char *, int);
|
|
|
99 static char **split_directories (const char *, int *);
|
|
|
100 static void free_split_directories (char **);
|
|
|
101
|
|
|
102 static char *
|
|
|
103 save_string (const char *s, int len)
|
|
|
104 {
|
|
|
105 char *result = (char *) malloc (len + 1);
|
|
|
106
|
|
|
107 memcpy (result, s, len);
|
|
|
108 result[len] = 0;
|
|
|
109 return result;
|
|
|
110 }
|
|
|
111
|
|
|
112 /* Split a filename into component directories. */
|
|
|
113
|
|
|
114 static char **
|
|
|
115 split_directories (const char *name, int *ptr_num_dirs)
|
|
|
116 {
|
|
|
117 int num_dirs = 0;
|
|
|
118 char **dirs;
|
|
|
119 const char *p, *q;
|
|
|
120 int ch;
|
|
|
121
|
|
|
122 /* Count the number of directories. Special case MSDOS disk names as part
|
|
|
123 of the initial directory. */
|
|
|
124 p = name;
|
|
|
125 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
|
|
|
126 if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
|
|
|
127 {
|
|
|
128 p += 3;
|
|
|
129 num_dirs++;
|
|
|
130 }
|
|
|
131 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
|
|
|
132
|
|
|
133 while ((ch = *p++) != '\0')
|
|
|
134 {
|
|
|
135 if (IS_DIR_SEPARATOR (ch))
|
|
|
136 {
|
|
|
137 num_dirs++;
|
|
|
138 while (IS_DIR_SEPARATOR (*p))
|
|
|
139 p++;
|
|
|
140 }
|
|
|
141 }
|
|
|
142
|
|
|
143 dirs = (char **) malloc (sizeof (char *) * (num_dirs + 2));
|
|
|
144 if (dirs == NULL)
|
|
|
145 return NULL;
|
|
|
146
|
|
|
147 /* Now copy the directory parts. */
|
|
|
148 num_dirs = 0;
|
|
|
149 p = name;
|
|
|
150 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
|
|
|
151 if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
|
|
|
152 {
|
|
|
153 dirs[num_dirs++] = save_string (p, 3);
|
|
|
154 if (dirs[num_dirs - 1] == NULL)
|
|
|
155 {
|
|
|
156 free (dirs);
|
|
|
157 return NULL;
|
|
|
158 }
|
|
|
159 p += 3;
|
|
|
160 }
|
|
|
161 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
|
|
|
162
|
|
|
163 q = p;
|
|
|
164 while ((ch = *p++) != '\0')
|
|
|
165 {
|
|
|
166 if (IS_DIR_SEPARATOR (ch))
|
|
|
167 {
|
|
|
168 while (IS_DIR_SEPARATOR (*p))
|
|
|
169 p++;
|
|
|
170
|
|
|
171 dirs[num_dirs++] = save_string (q, p - q);
|
|
|
172 if (dirs[num_dirs - 1] == NULL)
|
|
|
173 {
|
|
|
174 dirs[num_dirs] = NULL;
|
|
|
175 free_split_directories (dirs);
|
|
|
176 return NULL;
|
|
|
177 }
|
|
|
178 q = p;
|
|
|
179 }
|
|
|
180 }
|
|
|
181
|
|
|
182 if (p - 1 - q > 0)
|
|
|
183 dirs[num_dirs++] = save_string (q, p - 1 - q);
|
|
|
184 dirs[num_dirs] = NULL;
|
|
|
185
|
|
|
186 if (dirs[num_dirs - 1] == NULL)
|
|
|
187 {
|
|
|
188 free_split_directories (dirs);
|
|
|
189 return NULL;
|
|
|
190 }
|
|
|
191
|
|
|
192 if (ptr_num_dirs)
|
|
|
193 *ptr_num_dirs = num_dirs;
|
|
|
194 return dirs;
|
|
|
195 }
|
|
|
196
|
|
|
197 /* Release storage held by split directories. */
|
|
|
198
|
|
|
199 static void
|
|
|
200 free_split_directories (char **dirs)
|
|
|
201 {
|
|
|
202 int i = 0;
|
|
|
203
|
|
|
204 if (dirs != NULL)
|
|
|
205 {
|
|
|
206 while (dirs[i] != NULL)
|
|
|
207 free (dirs[i++]);
|
|
|
208
|
|
|
209 free ((char *) dirs);
|
|
|
210 }
|
|
|
211 }
|
|
|
212
|
|
|
213 /* Given three strings PROGNAME, BIN_PREFIX, PREFIX, return a string that gets
|
|
|
214 to PREFIX starting with the directory portion of PROGNAME and a relative
|
|
|
215 pathname of the difference between BIN_PREFIX and PREFIX.
|
|
|
216
|
|
|
217 For example, if BIN_PREFIX is /alpha/beta/gamma/gcc/delta, PREFIX is
|
|
|
218 /alpha/beta/gamma/omega/, and PROGNAME is /red/green/blue/gcc, then this
|
|
|
219 function will return /red/green/blue/../../omega/.
|
|
|
220
|
|
|
221 If no relative prefix can be found, return NULL. */
|
|
|
222
|
|
|
223 static char *
|
|
|
224 make_relative_prefix_1 (const char *progname, const char *bin_prefix,
|
|
|
225 const char *prefix, const int resolve_links)
|
|
|
226 {
|
|
|
227 char **prog_dirs = NULL, **bin_dirs = NULL, **prefix_dirs = NULL;
|
|
|
228 int prog_num, bin_num, prefix_num;
|
|
|
229 int i, n, common;
|
|
|
230 int needed_len;
|
|
|
231 char *ret = NULL, *ptr, *full_progname;
|
|
|
232
|
|
|
233 if (progname == NULL || bin_prefix == NULL || prefix == NULL)
|
|
|
234 return NULL;
|
|
|
235
|
|
|
236 /* If there is no full pathname, try to find the program by checking in each
|
|
|
237 of the directories specified in the PATH environment variable. */
|
|
|
238 if (lbasename (progname) == progname)
|
|
|
239 {
|
|
|
240 char *temp;
|
|
|
241
|
|
|
242 temp = getenv ("PATH");
|
|
|
243 if (temp)
|
|
|
244 {
|
|
|
245 char *startp, *endp, *nstore;
|
|
|
246 size_t prefixlen = strlen (temp) + 1;
|
|
|
247 if (prefixlen < 2)
|
|
|
248 prefixlen = 2;
|
|
|
249
|
|
|
250 nstore = (char *) alloca (prefixlen + strlen (progname) + 1);
|
|
|
251
|
|
|
252 startp = endp = temp;
|
|
|
253 while (1)
|
|
|
254 {
|
|
|
255 if (*endp == PATH_SEPARATOR || *endp == 0)
|
|
|
256 {
|
|
|
257 if (endp == startp)
|
|
|
258 {
|
|
|
259 nstore[0] = '.';
|
|
|
260 nstore[1] = DIR_SEPARATOR;
|
|
|
261 nstore[2] = '\0';
|
|
|
262 }
|
|
|
263 else
|
|
|
264 {
|
|
|
265 strncpy (nstore, startp, endp - startp);
|
|
|
266 if (! IS_DIR_SEPARATOR (endp[-1]))
|
|
|
267 {
|
|
|
268 nstore[endp - startp] = DIR_SEPARATOR;
|
|
|
269 nstore[endp - startp + 1] = 0;
|
|
|
270 }
|
|
|
271 else
|
|
|
272 nstore[endp - startp] = 0;
|
|
|
273 }
|
|
|
274 strcat (nstore, progname);
|
|
|
275 if (! access (nstore, X_OK)
|
|
|
276 #ifdef HAVE_HOST_EXECUTABLE_SUFFIX
|
|
|
277 || ! access (strcat (nstore, HOST_EXECUTABLE_SUFFIX), X_OK)
|
|
|
278 #endif
|
|
|
279 )
|
|
|
280 {
|
|
|
281 progname = nstore;
|
|
|
282 break;
|
|
|
283 }
|
|
|
284
|
|
|
285 if (*endp == 0)
|
|
|
286 break;
|
|
|
287 endp = startp = endp + 1;
|
|
|
288 }
|
|
|
289 else
|
|
|
290 endp++;
|
|
|
291 }
|
|
|
292 }
|
|
|
293 }
|
|
|
294
|
|
|
295 if (resolve_links)
|
|
|
296 full_progname = lrealpath (progname);
|
|
|
297 else
|
|
|
298 full_progname = strdup (progname);
|
|
|
299 if (full_progname == NULL)
|
|
|
300 return NULL;
|
|
|
301
|
|
|
302 prog_dirs = split_directories (full_progname, &prog_num);
|
|
|
303 free (full_progname);
|
|
|
304 if (prog_dirs == NULL)
|
|
|
305 return NULL;
|
|
|
306
|
|
|
307 bin_dirs = split_directories (bin_prefix, &bin_num);
|
|
|
308 if (bin_dirs == NULL)
|
|
|
309 goto bailout;
|
|
|
310
|
|
|
311 /* Remove the program name from comparison of directory names. */
|
|
|
312 prog_num--;
|
|
|
313
|
|
|
314 /* If we are still installed in the standard location, we don't need to
|
|
|
315 specify relative directories. Also, if argv[0] still doesn't contain
|
|
|
316 any directory specifiers after the search above, then there is not much
|
|
|
317 we can do. */
|
|
|
318 if (prog_num == bin_num)
|
|
|
319 {
|
|
|
320 for (i = 0; i < bin_num; i++)
|
|
|
321 {
|
|
|
322 if (strcmp (prog_dirs[i], bin_dirs[i]) != 0)
|
|
|
323 break;
|
|
|
324 }
|
|
|
325
|
|
|
326 if (prog_num <= 0 || i == bin_num)
|
|
|
327 goto bailout;
|
|
|
328 }
|
|
|
329
|
|
|
330 prefix_dirs = split_directories (prefix, &prefix_num);
|
|
|
331 if (prefix_dirs == NULL)
|
|
|
332 goto bailout;
|
|
|
333
|
|
|
334 /* Find how many directories are in common between bin_prefix & prefix. */
|
|
|
335 n = (prefix_num < bin_num) ? prefix_num : bin_num;
|
|
|
336 for (common = 0; common < n; common++)
|
|
|
337 {
|
|
|
338 if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0)
|
|
|
339 break;
|
|
|
340 }
|
|
|
341
|
|
|
342 /* If there are no common directories, there can be no relative prefix. */
|
|
|
343 if (common == 0)
|
|
|
344 goto bailout;
|
|
|
345
|
|
|
346 /* Two passes: first figure out the size of the result string, and
|
|
|
347 then construct it. */
|
|
|
348 needed_len = 0;
|
|
|
349 for (i = 0; i < prog_num; i++)
|
|
|
350 needed_len += strlen (prog_dirs[i]);
|
|
|
351 needed_len += sizeof (DIR_UP) * (bin_num - common);
|
|
|
352 for (i = common; i < prefix_num; i++)
|
|
|
353 needed_len += strlen (prefix_dirs[i]);
|
|
|
354 needed_len += 1; /* Trailing NUL. */
|
|
|
355
|
|
|
356 ret = (char *) malloc (needed_len);
|
|
|
357 if (ret == NULL)
|
|
|
358 goto bailout;
|
|
|
359
|
|
|
360 /* Build up the pathnames in argv[0]. */
|
|
|
361 *ret = '\0';
|
|
|
362 for (i = 0; i < prog_num; i++)
|
|
|
363 strcat (ret, prog_dirs[i]);
|
|
|
364
|
|
|
365 /* Now build up the ..'s. */
|
|
|
366 ptr = ret + strlen(ret);
|
|
|
367 for (i = common; i < bin_num; i++)
|
|
|
368 {
|
|
|
369 strcpy (ptr, DIR_UP);
|
|
|
370 ptr += sizeof (DIR_UP) - 1;
|
|
|
371 *(ptr++) = DIR_SEPARATOR;
|
|
|
372 }
|
|
|
373 *ptr = '\0';
|
|
|
374
|
|
|
375 /* Put in directories to move over to prefix. */
|
|
|
376 for (i = common; i < prefix_num; i++)
|
|
|
377 strcat (ret, prefix_dirs[i]);
|
|
|
378
|
|
|
379 bailout:
|
|
|
380 free_split_directories (prog_dirs);
|
|
|
381 free_split_directories (bin_dirs);
|
|
|
382 free_split_directories (prefix_dirs);
|
|
|
383
|
|
|
384 return ret;
|
|
|
385 }
|
|
|
386
|
|
|
387
|
|
|
388 /* Do the full job, including symlink resolution.
|
|
|
389 This path will find files installed in the same place as the
|
|
|
390 program even when a soft link has been made to the program
|
|
|
391 from somwhere else. */
|
|
|
392
|
|
|
393 char *
|
|
|
394 make_relative_prefix (const char *progname, const char *bin_prefix,
|
|
|
395 const char *prefix)
|
|
|
396 {
|
|
|
397 return make_relative_prefix_1 (progname, bin_prefix, prefix, 1);
|
|
|
398 }
|
|
|
399
|
|
|
400 /* Make the relative pathname without attempting to resolve any links.
|
|
|
401 '..' etc may also be left in the pathname.
|
|
|
402 This will find the files the user meant the program to find if the
|
|
|
403 installation is patched together with soft links. */
|
|
|
404
|
|
|
405 char *
|
|
|
406 make_relative_prefix_ignore_links (const char *progname,
|
|
|
407 const char *bin_prefix,
|
|
|
408 const char *prefix)
|
|
|
409 {
|
|
|
410 return make_relative_prefix_1 (progname, bin_prefix, prefix, 0);
|
|
|
411 }
|
|
|
412
|
