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, 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