contrib/gdb-6/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     {
 297       full_progname = lrealpath (progname);
 298       if (full_progname == NULL)
 299         return NULL;
 300     }
 301   else
 302     full_progname = strdup(progname);
 303
 304   prog_dirs = split_directories (full_progname, &prog_num);
 305   free (full_progname);
 306   if (prog_dirs == NULL)
 307     return NULL;
 308
 309   bin_dirs = split_directories (bin_prefix, &bin_num);
 310   if (bin_dirs == NULL)
 311     goto bailout;
 312
 313   /* Remove the program name from comparison of directory names.  */
 314   prog_num--;
 315
 316   /* If we are still installed in the standard location, we don't need to
 317      specify relative directories.  Also, if argv[0] still doesn't contain
 318      any directory specifiers after the search above, then there is not much
 319      we can do.  */
 320   if (prog_num == bin_num)
 321     {
 322       for (i = 0; i < bin_num; i++)
 323         {
 324           if (strcmp (prog_dirs[i], bin_dirs[i]) != 0)
 325             break;
 326         }
 327
 328       if (prog_num <= 0 || i == bin_num)
 329         goto bailout;
 330     }
 331
 332   prefix_dirs = split_directories (prefix, &prefix_num);
 333   if (prefix_dirs == NULL)
 334     goto bailout;
 335
 336   /* Find how many directories are in common between bin_prefix & prefix.  */
 337   n = (prefix_num < bin_num) ? prefix_num : bin_num;
 338   for (common = 0; common < n; common++)
 339     {
 340       if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0)
 341         break;
 342     }
 343
 344   /* If there are no common directories, there can be no relative prefix.  */
 345   if (common == 0)
 346     goto bailout;
 347
 348   /* Two passes: first figure out the size of the result string, and
 349      then construct it.  */
 350   needed_len = 0;
 351   for (i = 0; i < prog_num; i++)
 352     needed_len += strlen (prog_dirs[i]);
 353   needed_len += sizeof (DIR_UP) * (bin_num - common);
 354   for (i = common; i < prefix_num; i++)
 355     needed_len += strlen (prefix_dirs[i]);
 356   needed_len += 1; /* Trailing NUL.  */
 357
 358   ret = (char *) malloc (needed_len);
 359   if (ret == NULL)
 360     goto bailout;
 361
 362   /* Build up the pathnames in argv[0].  */
 363   *ret = '\0';
 364   for (i = 0; i < prog_num; i++)
 365     strcat (ret, prog_dirs[i]);
 366
 367   /* Now build up the ..'s.  */
 368   ptr = ret + strlen(ret);
 369   for (i = common; i < bin_num; i++)
 370     {
 371       strcpy (ptr, DIR_UP);
 372       ptr += sizeof (DIR_UP) - 1;
 373       *(ptr++) = DIR_SEPARATOR;
 374     }
 375   *ptr = '\0';
 376
 377   /* Put in directories to move over to prefix.  */
 378   for (i = common; i < prefix_num; i++)
 379     strcat (ret, prefix_dirs[i]);
 380
 381  bailout:
 382   free_split_directories (prog_dirs);
 383   free_split_directories (bin_dirs);
 384   free_split_directories (prefix_dirs);
 385
 386   return ret;
 387 }
 388
 389
 390 /* Do the full job, including symlink resolution.
 391    This path will find files installed in the same place as the
 392    program even when a soft link has been made to the program
 393    from somwhere else. */
 394
 395 char *
 396 make_relative_prefix (const char *progname, const char *bin_prefix,
 397                       const char *prefix)
 398 {
 399   return make_relative_prefix_1 (progname, bin_prefix, prefix, 1);
 400 }
 401
 402 /* Make the relative pathname without attempting to resolve any links.
 403    '..' etc may also be left in the pathname.
 404    This will find the files the user meant the program to find if the
 405    installation is patched together with soft links. */
 406
 407 char *
 408 make_relative_prefix_ignore_links (const char *progname,
 409                                    const char *bin_prefix,
 410                                    const char *prefix)
 411 {
 412   return make_relative_prefix_1 (progname, bin_prefix, prefix, 0);
 413 }
 414