merge from gcc
[platform/upstream/binutils.git] / libiberty / make-relative-prefix.c
1 /* Relative (relocatable) prefix support.
2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002 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, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, 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 PARAMS ((const char *, int));
99 static char **split_directories PARAMS ((const char *, int *));
100 static void free_split_directories PARAMS ((char **));
101
102 static char *
103 save_string (s, len)
104      const char *s;
105      int len;
106 {
107   char *result = malloc (len + 1);
108
109   memcpy (result, s, len);
110   result[len] = 0;
111   return result;
112 }
113
114 /* Split a filename into component directories.  */
115
116 static char **
117 split_directories (name, ptr_num_dirs)
118      const char *name;
119      int *ptr_num_dirs;
120 {
121   int num_dirs = 0;
122   char **dirs;
123   const char *p, *q;
124   int ch;
125
126   /* Count the number of directories.  Special case MSDOS disk names as part
127      of the initial directory.  */
128   p = name;
129 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
130   if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
131     {
132       p += 3;
133       num_dirs++;
134     }
135 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
136
137   while ((ch = *p++) != '\0')
138     {
139       if (IS_DIR_SEPARATOR (ch))
140         {
141           num_dirs++;
142           while (IS_DIR_SEPARATOR (*p))
143             p++;
144         }
145     }
146
147   dirs = (char **) malloc (sizeof (char *) * (num_dirs + 2));
148   if (dirs == NULL)
149     return NULL;
150
151   /* Now copy the directory parts.  */
152   num_dirs = 0;
153   p = name;
154 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
155   if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
156     {
157       dirs[num_dirs++] = save_string (p, 3);
158       if (dirs[num_dirs - 1] == NULL)
159         {
160           free (dirs);
161           return NULL;
162         }
163       p += 3;
164     }
165 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
166
167   q = p;
168   while ((ch = *p++) != '\0')
169     {
170       if (IS_DIR_SEPARATOR (ch))
171         {
172           while (IS_DIR_SEPARATOR (*p))
173             p++;
174
175           dirs[num_dirs++] = save_string (q, p - q);
176           if (dirs[num_dirs - 1] == NULL)
177             {
178               dirs[num_dirs] = NULL;
179               free_split_directories (dirs);
180               return NULL;
181             }
182           q = p;
183         }
184     }
185
186   if (p - 1 - q > 0)
187     dirs[num_dirs++] = save_string (q, p - 1 - q);
188   dirs[num_dirs] = NULL;
189
190   if (dirs[num_dirs - 1] == NULL)
191     {
192       free_split_directories (dirs);
193       return NULL;
194     }
195
196   if (ptr_num_dirs)
197     *ptr_num_dirs = num_dirs;
198   return dirs;
199 }
200
201 /* Release storage held by split directories.  */
202
203 static void
204 free_split_directories (dirs)
205      char **dirs;
206 {
207   int i = 0;
208
209   while (dirs[i] != NULL)
210     free (dirs[i++]);
211
212   free ((char *) dirs);
213 }
214
215 /* Given three strings PROGNAME, BIN_PREFIX, PREFIX, return a string that gets
216    to PREFIX starting with the directory portion of PROGNAME and a relative
217    pathname of the difference between BIN_PREFIX and PREFIX.
218
219    For example, if BIN_PREFIX is /alpha/beta/gamma/gcc/delta, PREFIX is
220    /alpha/beta/gamma/omega/, and PROGNAME is /red/green/blue/gcc, then this
221    function will return /red/green/blue/../../omega/.
222
223    If no relative prefix can be found, return NULL.  */
224
225 char *
226 make_relative_prefix (progname, bin_prefix, prefix)
227      const char *progname;
228      const char *bin_prefix;
229      const char *prefix;
230 {
231   char **prog_dirs, **bin_dirs, **prefix_dirs;
232   int prog_num, bin_num, prefix_num;
233   int i, n, common;
234   int needed_len;
235   char *ret, *ptr, *full_progname = NULL;
236
237   if (progname == NULL || bin_prefix == NULL || prefix == NULL)
238     return NULL;
239
240   /* If there is no full pathname, try to find the program by checking in each
241      of the directories specified in the PATH environment variable.  */
242   if (lbasename (progname) == progname)
243     {
244       char *temp;
245
246       temp = getenv ("PATH");
247       if (temp)
248         {
249           char *startp, *endp, *nstore;
250           size_t prefixlen = strlen (temp) + 1;
251           if (prefixlen < 2)
252             prefixlen = 2;
253
254           nstore = (char *) alloca (prefixlen + strlen (progname) + 1);
255
256           startp = endp = temp;
257           while (1)
258             {
259               if (*endp == PATH_SEPARATOR || *endp == 0)
260                 {
261                   if (endp == startp)
262                     {
263                       nstore[0] = '.';
264                       nstore[1] = DIR_SEPARATOR;
265                       nstore[2] = '\0';
266                     }
267                   else
268                     {
269                       strncpy (nstore, startp, endp - startp);
270                       if (! IS_DIR_SEPARATOR (endp[-1]))
271                         {
272                           nstore[endp - startp] = DIR_SEPARATOR;
273                           nstore[endp - startp + 1] = 0;
274                         }
275                       else
276                         nstore[endp - startp] = 0;
277                     }
278                   strcat (nstore, progname);
279                   if (! access (nstore, X_OK)
280 #ifdef HAVE_HOST_EXECUTABLE_SUFFIX
281                       || ! access (strcat (nstore, HOST_EXECUTABLE_SUFFIX), X_OK)
282 #endif
283                       )
284                     {
285                       progname = nstore;
286                       break;
287                     }
288
289                   if (*endp == 0)
290                     break;
291                   endp = startp = endp + 1;
292                 }
293               else
294                 endp++;
295             }
296         }
297     }
298
299   full_progname = lrealpath (progname);
300   if (full_progname == NULL)
301     return NULL;
302
303   prog_dirs = split_directories (full_progname, &prog_num);
304   bin_dirs = split_directories (bin_prefix, &bin_num);
305   free (full_progname);
306   if (bin_dirs == NULL || prog_dirs == NULL)
307     return NULL;
308
309   /* Remove the program name from comparison of directory names.  */
310   prog_num--;
311
312   /* If we are still installed in the standard location, we don't need to
313      specify relative directories.  Also, if argv[0] still doesn't contain
314      any directory specifiers after the search above, then there is not much
315      we can do.  */
316   if (prog_num == bin_num)
317     {
318       for (i = 0; i < bin_num; i++)
319         {
320           if (strcmp (prog_dirs[i], bin_dirs[i]) != 0)
321             break;
322         }
323
324       if (prog_num <= 0 || i == bin_num)
325         {
326           free_split_directories (prog_dirs);
327           free_split_directories (bin_dirs);
328           prog_dirs = bin_dirs = (char **) 0;
329           return NULL;
330         }
331     }
332
333   prefix_dirs = split_directories (prefix, &prefix_num);
334   if (prefix_dirs == NULL)
335     {
336       free_split_directories (prog_dirs);
337       free_split_directories (bin_dirs);
338       return NULL;
339     }
340
341   /* Find how many directories are in common between bin_prefix & prefix.  */
342   n = (prefix_num < bin_num) ? prefix_num : bin_num;
343   for (common = 0; common < n; common++)
344     {
345       if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0)
346         break;
347     }
348
349   /* If there are no common directories, there can be no relative prefix.  */
350   if (common == 0)
351     {
352       free_split_directories (prog_dirs);
353       free_split_directories (bin_dirs);
354       free_split_directories (prefix_dirs);
355       return NULL;
356     }
357
358   /* Two passes: first figure out the size of the result string, and
359      then construct it.  */
360   needed_len = 0;
361   for (i = 0; i < prog_num; i++)
362     needed_len += strlen (prog_dirs[i]);
363   needed_len += sizeof (DIR_UP) * (bin_num - common);
364   for (i = common; i < prefix_num; i++)
365     needed_len += strlen (prefix_dirs[i]);
366   needed_len += 1; /* Trailing NUL.  */
367
368   ret = (char *) malloc (needed_len);
369   if (ret == NULL)
370     return NULL;
371
372   /* Build up the pathnames in argv[0].  */
373   *ret = '\0';
374   for (i = 0; i < prog_num; i++)
375     strcat (ret, prog_dirs[i]);
376
377   /* Now build up the ..'s.  */
378   ptr = ret + strlen(ret);
379   for (i = common; i < bin_num; i++)
380     {
381       strcpy (ptr, DIR_UP);
382       ptr += sizeof (DIR_UP) - 1;
383       *(ptr++) = DIR_SEPARATOR;
384     }
385   *ptr = '\0';
386
387   /* Put in directories to move over to prefix.  */
388   for (i = common; i < prefix_num; i++)
389     strcat (ret, prefix_dirs[i]);
390
391   free_split_directories (prog_dirs);
392   free_split_directories (bin_dirs);
393   free_split_directories (prefix_dirs);
394
395   return ret;
396 }