gcc/prefix.c

   1 /* Utility to update paths from internal to external forms.
   2    Copyright (C) 1997-2020 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU Library General Public License as published by
   8 the Free Software Foundation; either version 3 of the License, or (at
   9 your option) any later version.
  10
  11 GCC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 Library General Public License for more details.
  15
  16 You should have received a copy of the GNU Library General Public
  17 License along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 /* This file contains routines to update a path, both to canonicalize
  21    the directory format and to handle any prefix translation.
  22
  23    This file must be compiled with -DPREFIX= to specify the "prefix"
  24    value used by configure.  If a filename does not begin with this
  25    prefix, it will not be affected other than by directory canonicalization.
  26
  27    Each caller of 'update_path' may specify both a filename and
  28    a translation prefix and consist of the name of the package that contains
  29    the file ("@GCC", "@BINUTIL", "@GNU", etc).
  30
  31    If the prefix is not specified, the filename will only undergo
  32    directory canonicalization.
  33
  34    If it is specified, the string given by PREFIX will be replaced
  35    by the specified prefix (with a '@' in front unless the prefix begins
  36    with a '$') and further translation will be done as follows
  37    until none of the two conditions below are met:
  38
  39    1) If the filename begins with '@', the string between the '@' and
  40    the end of the name or the first '/' or directory separator will
  41    be considered a "key" and looked up as follows:
  42
  43    -- If this is a Win32 OS, then the Registry will be examined for
  44       an entry of "key" in
  45
  46       HKEY_LOCAL_MACHINE\SOFTWARE\Free Software Foundation\<KEY>
  47
  48       if found, that value will be used. <KEY> defaults to GCC version
  49       string, but can be overridden at configuration time.
  50
  51    -- If not found (or not a Win32 OS), the environment variable
  52       key_ROOT (the value of "key" concatenated with the constant "_ROOT")
  53       is tried.  If that fails, then PREFIX (see above) is used.
  54
  55    2) If the filename begins with a '$', the rest of the string up
  56    to the end or the first '/' or directory separator will be used
  57    as an environment variable, whose value will be returned.
  58
  59    Once all this is done, any '/' will be converted to DIR_SEPARATOR,
  60    if they are different.
  61
  62    NOTE:  using resolve_keyed_path under Win32 requires linking with
  63    advapi32.dll.  */
  64
  65
  66 #include "config.h"
  67 #include "system.h"
  68 #include "coretypes.h"
  69 #if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
  70 #include <windows.h>
  71 #endif
  72 #include "prefix.h"
  73 #include "common/common-target.h"
  74
  75 static const char *std_prefix = PREFIX;
  76
  77 static const char *get_key_value (char *);
  78 static char *translate_name (char *);
  79 static char *save_string (const char *, int);
  80 static void tr (char *, int, int);
  81
  82 #if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
  83 static char *lookup_key (char *);
  84 static HKEY reg_key = (HKEY) INVALID_HANDLE_VALUE;
  85 #endif
  86
  87 /* Given KEY, as above, return its value.  */
  88
  89 static const char *
  90 get_key_value (char *key)
  91 {
  92   const char *prefix = 0;
  93   char *temp = 0;
  94
  95 #if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
  96   prefix = lookup_key (key);
  97 #endif
  98
  99   if (prefix == 0)
 100     prefix = getenv (temp = concat (key, "_ROOT", NULL));
 101
 102   if (prefix == 0)
 103     prefix = std_prefix;
 104
 105   free (temp);
 106
 107   return prefix;
 108 }
 109
 110 /* Return a copy of a string that has been placed in the heap.  */
 111
 112 static char *
 113 save_string (const char *s, int len)
 114 {
 115   char *result = XNEWVEC (char, len + 1);
 116
 117   memcpy (result, s, len);
 118   result[len] = 0;
 119   return result;
 120 }
 121
 122 #if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
 123
 124 #ifndef WIN32_REGISTRY_KEY
 125 # define WIN32_REGISTRY_KEY BASEVER
 126 #endif
 127
 128 /* Look up "key" in the registry, as above.  */
 129
 130 static char *
 131 lookup_key (char *key)
 132 {
 133   char *dst;
 134   DWORD size;
 135   DWORD type;
 136   LONG res;
 137
 138   if (reg_key == (HKEY) INVALID_HANDLE_VALUE)
 139     {
 140       res = RegOpenKeyExA (HKEY_LOCAL_MACHINE, "SOFTWARE", 0,
 141                            KEY_READ, &reg_key);
 142
 143       if (res == ERROR_SUCCESS)
 144         res = RegOpenKeyExA (reg_key, "Free Software Foundation", 0,
 145                              KEY_READ, &reg_key);
 146
 147       if (res == ERROR_SUCCESS)
 148         res = RegOpenKeyExA (reg_key, WIN32_REGISTRY_KEY, 0,
 149                              KEY_READ, &reg_key);
 150
 151       if (res != ERROR_SUCCESS)
 152         {
 153           reg_key = (HKEY) INVALID_HANDLE_VALUE;
 154           return 0;
 155         }
 156     }
 157
 158   size = 32;
 159   dst = XNEWVEC (char, size);
 160
 161   res = RegQueryValueExA (reg_key, key, 0, &type, (LPBYTE) dst, &size);
 162   if (res == ERROR_MORE_DATA && type == REG_SZ)
 163     {
 164       dst = XRESIZEVEC (char, dst, size);
 165       res = RegQueryValueExA (reg_key, key, 0, &type, (LPBYTE) dst, &size);
 166     }
 167
 168   if (type != REG_SZ || res != ERROR_SUCCESS)
 169     {
 170       free (dst);
 171       dst = 0;
 172     }
 173
 174   return dst;
 175 }
 176 #endif
 177
 178 /* If NAME, a malloc-ed string, starts with a '@' or '$', apply the
 179    translation rules above and return a newly malloc-ed name.
 180    Otherwise, return the given name.  */
 181
 182 static char *
 183 translate_name (char *name)
 184 {
 185   char code;
 186   char *key, *old_name;
 187   const char *prefix;
 188   int keylen;
 189
 190   for (;;)
 191     {
 192       code = name[0];
 193       if (code != '@' && code != '$')
 194         break;
 195
 196       for (keylen = 0;
 197            (name[keylen + 1] != 0 && !IS_DIR_SEPARATOR (name[keylen + 1]));
 198            keylen++)
 199         ;
 200
 201       key = (char *) alloca (keylen + 1);
 202       memcpy (key, &name[1], keylen);
 203       key[keylen] = 0;
 204
 205       if (code == '@')
 206         {
 207           prefix = get_key_value (key);
 208           if (prefix == 0)
 209             prefix = std_prefix;
 210         }
 211       else
 212         prefix = getenv (key);
 213
 214       if (prefix == 0)
 215         prefix = PREFIX;
 216
 217       /* We used to strip trailing DIR_SEPARATORs here, but that can
 218          sometimes yield a result with no separator when one was coded
 219          and intended by the user, causing two path components to run
 220          together.  */
 221
 222       old_name = name;
 223       name = concat (prefix, &name[keylen + 1], NULL);
 224       free (old_name);
 225     }
 226
 227   return name;
 228 }
 229
 230 /* In a NUL-terminated STRING, replace character C1 with C2 in-place.  */
 231 static void
 232 tr (char *string, int c1, int c2)
 233 {
 234   do
 235     {
 236       if (*string == c1)
 237         *string = c2;
 238     }
 239   while (*string++);
 240 }
 241
 242 /* Update PATH using KEY if PATH starts with PREFIX as a directory.
 243    The returned string is always malloc-ed, and the caller is
 244    responsible for freeing it.  */
 245
 246 char *
 247 update_path (const char *path, const char *key)
 248 {
 249   char *result, *p;
 250   const int len = strlen (std_prefix);
 251
 252   if (! filename_ncmp (path, std_prefix, len)
 253       && (IS_DIR_SEPARATOR (path[len])
 254           || path[len] == '\0')
 255       && key != 0)
 256     {
 257       bool free_key = false;
 258
 259       if (key[0] != '$')
 260         {
 261           key = concat ("@", key, NULL);
 262           free_key = true;
 263         }
 264
 265       result = concat (key, &path[len], NULL);
 266       if (free_key)
 267         free (CONST_CAST (char *, key));
 268       result = translate_name (result);
 269     }
 270   else
 271     result = xstrdup (path);
 272
 273   p = result;
 274   while (1)
 275     {
 276       char *src, *dest;
 277
 278       p = strchr (p, '.');
 279       if (p == NULL)
 280         break;
 281       /* Look for `/../'  */
 282       if (p[1] == '.'
 283           && IS_DIR_SEPARATOR (p[2])
 284           && (p != result && IS_DIR_SEPARATOR (p[-1])))
 285         {
 286           *p = 0;
 287           if (!targetm_common.always_strip_dotdot
 288               && access (result, X_OK) == 0)
 289             {
 290               *p = '.';
 291               break;
 292             }
 293           else
 294             {
 295               /* We can't access the dir, so we won't be able to
 296                  access dir/.. either.  Strip out `dir/../'.  If `dir'
 297                  turns out to be `.', strip one more path component.  */
 298               dest = p;
 299               do
 300                 {
 301                   --dest;
 302                   while (dest != result && IS_DIR_SEPARATOR (*dest))
 303                     --dest;
 304                   while (dest != result && !IS_DIR_SEPARATOR (dest[-1]))
 305                     --dest;
 306                 }
 307               while (dest != result && *dest == '.');
 308               /* If we have something like `./..' or `/..', don't
 309                  strip anything more.  */
 310               if (*dest == '.' || IS_DIR_SEPARATOR (*dest))
 311                 {
 312                   *p = '.';
 313                   break;
 314                 }
 315               src = p + 3;
 316               while (IS_DIR_SEPARATOR (*src))
 317                 ++src;
 318               p = dest;
 319               while ((*dest++ = *src++) != 0)
 320                 ;
 321             }
 322         }
 323       else
 324         ++p;
 325     }
 326
 327 #ifdef UPDATE_PATH_HOST_CANONICALIZE
 328   /* Perform host dependent canonicalization when needed.  */
 329   UPDATE_PATH_HOST_CANONICALIZE (result);
 330 #endif
 331
 332 #ifdef DIR_SEPARATOR_2
 333   /* Convert DIR_SEPARATOR_2 to DIR_SEPARATOR.  */
 334   if (DIR_SEPARATOR_2 != DIR_SEPARATOR)
 335     tr (result, DIR_SEPARATOR_2, DIR_SEPARATOR);
 336 #endif
 337
 338 #if defined (DIR_SEPARATOR) && !defined (DIR_SEPARATOR_2)
 339   if (DIR_SEPARATOR != '/')
 340     tr (result, '/', DIR_SEPARATOR);
 341 #endif
 342
 343   return result;
 344 }
 345
 346 /* Reset the standard prefix.  */
 347 void
 348 set_std_prefix (const char *prefix, int len)
 349 {
 350   std_prefix = save_string (prefix, len);
 351 }