gcc/prefix.c

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