gcc/prefix.c

   1 /* Utility to update paths from internal to external forms.
   2    Copyright (C) 1997, 1998, 1999, 2000, 2001 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 2 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 COPYING.  If not, write to the Free
  18 Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  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 #if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
  70 #include <windows.h>
  71 #endif
  72 #include "prefix.h"
  73
  74 static const char *std_prefix = PREFIX;
  75
  76 static const char *get_key_value        PARAMS ((char *));
  77 static char *translate_name             PARAMS ((char *));
  78 static char *save_string                PARAMS ((const char *, int));
  79 static void tr                          PARAMS ((char *, int, int));
  80
  81 #if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
  82 static char *lookup_key         PARAMS ((char *));
  83 static HKEY reg_key = (HKEY) INVALID_HANDLE_VALUE;
  84 #endif
  85
  86 /* Given KEY, as above, return its value.  */
  87
  88 static const char *
  89 get_key_value (key)
  90      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   if (temp)
 106     free (temp);
 107
 108   return prefix;
 109 }
 110
 111 /* Return a copy of a string that has been placed in the heap.  */
 112
 113 static char *
 114 save_string (s, len)
 115   const char *s;
 116   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 (key)
 131      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 = (char *) xmalloc (size);
 160
 161   res = RegQueryValueExA (reg_key, key, 0, &type, dst, &size);
 162   if (res == ERROR_MORE_DATA && type == REG_SZ)
 163     {
 164       dst = (char *) xrealloc (dst, size);
 165       res = RegQueryValueExA (reg_key, key, 0, &type, 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 (name)
 184      char *name;
 185 {
 186   char code;
 187   char *key, *old_name;
 188   const char *prefix;
 189   int keylen;
 190
 191   for (;;)
 192     {
 193       code = name[0];
 194       if (code != '@' && code != '$')
 195         break;
 196
 197       for (keylen = 0;
 198            (name[keylen + 1] != 0 && !IS_DIR_SEPARATOR (name[keylen + 1]));
 199            keylen++)
 200         ;
 201
 202       key = (char *) alloca (keylen + 1);
 203       strncpy (key, &name[1], keylen);
 204       key[keylen] = 0;
 205
 206       if (code == '@')
 207         {
 208           prefix = get_key_value (key);
 209           if (prefix == 0)
 210             prefix = std_prefix;
 211         }
 212       else
 213         prefix = getenv (key);
 214
 215       if (prefix == 0)
 216         prefix = PREFIX;
 217
 218       /* We used to strip trailing DIR_SEPARATORs here, but that can
 219          sometimes yield a result with no separator when one was coded
 220          and intended by the user, causing two path components to run
 221          together.  */
 222
 223       old_name = name;
 224       name = concat (prefix, &name[keylen + 1], NULL);
 225       free (old_name);
 226     }
 227
 228   return name;
 229 }
 230
 231 /* In a NUL-terminated STRING, replace character C1 with C2 in-place.  */
 232 static void
 233 tr (string, c1, c2)
 234      char *string;
 235      int c1, c2;
 236 {
 237   do
 238     {
 239       if (*string == c1)
 240         *string = c2;
 241     }
 242   while (*string++);
 243 }
 244
 245 /* Update PATH using KEY if PATH starts with PREFIX.  The returned
 246    string is always malloc-ed, and the caller is responsible for
 247    freeing it.  */
 248
 249 char *
 250 update_path (path, key)
 251   const char *path;
 252   const char *key;
 253 {
 254   char *result;
 255
 256   if (! strncmp (path, std_prefix, strlen (std_prefix)) && key != 0)
 257     {
 258       bool free_key = false;
 259
 260       if (key[0] != '$')
 261         {
 262           key = concat ("@", key, NULL);
 263           free_key = true;
 264         }
 265
 266       result = concat (key, &path[strlen (std_prefix)], NULL);
 267       if (free_key)
 268         free ((char *) key);
 269       result = translate_name (result);
 270     }
 271   else
 272     result = xstrdup (path);
 273
 274 #ifdef UPDATE_PATH_HOST_CANONICALIZE
 275   /* Perform host dependent canonicalization when needed.  */
 276   UPDATE_PATH_HOST_CANONICALIZE (path);
 277 #endif
 278
 279 #ifdef DIR_SEPARATOR_2
 280   /* Convert DIR_SEPARATOR_2 to DIR_SEPARATOR.  */
 281   if (DIR_SEPARATOR_2 != DIR_SEPARATOR)
 282     tr (result, DIR_SEPARATOR_2, DIR_SEPARATOR);
 283 #endif
 284
 285 #if defined (DIR_SEPARATOR) && !defined (DIR_SEPARATOR_2)
 286   if (DIR_SEPARATOR != '/')
 287     tr (result, '/', DIR_SEPARATOR);
 288 #endif
 289
 290   return result;
 291 }
 292
 293 /* Reset the standard prefix */
 294 void
 295 set_std_prefix (prefix, len)
 296   const char *prefix;
 297   int len;
 298 {
 299   std_prefix = save_string (prefix, len);
 300 }