gcc/prefix.c

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