sdcc/support/sdbinutils/libiberty/make-relative-prefix.c

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