gcc/prefix.c

   1 /* Utility to update paths from internal to external forms.
   2    Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU Library General Public
   8 License as published by the Free Software Foundation; either
   9 version 2 of the License, or (at 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\
  48
  49       if found, that value will be used.
  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 #ifdef _WIN32
  69 #include <windows.h>
  70 #endif
  71 #include "prefix.h"
  72
  73 static const char *std_prefix = PREFIX;
  74
  75 static const char *get_key_value        PROTO((char *));
  76 static const char *translate_name       PROTO((const char *));
  77 static char *save_string                PROTO((const char *, int));
  78
  79 #ifdef _WIN32
  80 static char *lookup_key         PROTO((char *));
  81 static HKEY reg_key = (HKEY) INVALID_HANDLE_VALUE;
  82 #endif
  83
  84 #ifndef DIR_SEPARATOR
  85 # define IS_DIR_SEPARATOR(ch) ((ch) == '/')
  86 #else /* DIR_SEPARATOR */
  87 # ifndef DIR_SEPARATOR_2
  88 #  define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
  89 # else /* DIR_SEPARATOR && DIR_SEPARATOR_2 */
  90 #  define IS_DIR_SEPARATOR(ch) \
  91         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
  92 # endif /* DIR_SEPARATOR && DIR_SEPARATOR_2 */
  93 #endif /* DIR_SEPARATOR */
  94
  95 /* Given KEY, as above, return its value.  */
  96
  97 static const char *
  98 get_key_value (key)
  99      char *key;
 100 {
 101   const char *prefix = 0;
 102   char *temp = 0;
 103
 104 #ifdef _WIN32
 105   prefix = lookup_key (key);
 106 #endif
 107
 108   if (prefix == 0)
 109     prefix = getenv (temp = concat (key, "_ROOT", NULL_PTR));
 110
 111   if (prefix == 0)
 112     prefix = std_prefix;
 113
 114   if (temp)
 115     free (temp);
 116
 117   return prefix;
 118 }
 119
 120 /* Concatenate a sequence of strings, returning the result.
 121
 122    This function is based on the one in libiberty.  */
 123
 124 char *
 125 concat VPROTO((const char *first, ...))
 126 {
 127   register int length;
 128   register char *newstr;
 129   register char *end;
 130   register const char *arg;
 131   va_list args;
 132 #ifndef ANSI_PROTOTYPES
 133   const char *first;
 134 #endif
 135
 136   /* First compute the size of the result and get sufficient memory.  */
 137
 138   VA_START (args, first);
 139 #ifndef ANSI_PROTOTYPES
 140   first = va_arg (args, const char *);
 141 #endif
 142
 143   arg = first;
 144   length = 0;
 145
 146   while (arg != 0)
 147     {
 148       length += strlen (arg);
 149       arg = va_arg (args, const char *);
 150     }
 151
 152   newstr = (char *) malloc (length + 1);
 153   va_end (args);
 154
 155   /* Now copy the individual pieces to the result string.  */
 156
 157   VA_START (args, first);
 158 #ifndef ANSI_PROTOTYPES
 159   first = va_arg (args, char *);
 160 #endif
 161
 162   end = newstr;
 163   arg = first;
 164   while (arg != 0)
 165     {
 166       while (*arg)
 167         *end++ = *arg++;
 168       arg = va_arg (args, const char *);
 169     }
 170   *end = '\000';
 171   va_end (args);
 172
 173   return (newstr);
 174 }
 175
 176 /* Return a copy of a string that has been placed in the heap.  */
 177
 178 static char *
 179 save_string (s, len)
 180   const char *s;
 181   int len;
 182 {
 183   register char *result = xmalloc (len + 1);
 184
 185   bcopy (s, result, len);
 186   result[len] = 0;
 187   return result;
 188 }
 189
 190 #ifdef _WIN32
 191
 192 /* Look up "key" in the registry, as above.  */
 193
 194 static char *
 195 lookup_key (key)
 196      char *key;
 197 {
 198   char *dst;
 199   DWORD size;
 200   DWORD type;
 201   LONG res;
 202
 203   if (reg_key == (HKEY) INVALID_HANDLE_VALUE)
 204     {
 205       res = RegOpenKeyExA (HKEY_LOCAL_MACHINE, "SOFTWARE", 0,
 206                            KEY_READ, &reg_key);
 207
 208       if (res == ERROR_SUCCESS)
 209         res = RegOpenKeyExA (reg_key, "Free Software Foundation", 0,
 210                              KEY_READ, &reg_key);
 211
 212       if (res != ERROR_SUCCESS)
 213         {
 214           reg_key = (HKEY) INVALID_HANDLE_VALUE;
 215           return 0;
 216         }
 217     }
 218
 219   size = 32;
 220   dst = (char *) malloc (size);
 221
 222   res = RegQueryValueExA (reg_key, key, 0, &type, dst, &size);
 223   if (res == ERROR_MORE_DATA && type == REG_SZ)
 224     {
 225       dst = (char *) realloc (dst, size);
 226       res = RegQueryValueExA (reg_key, key, 0, &type, dst, &size);
 227     }
 228
 229   if (type != REG_SZ || res != ERROR_SUCCESS)
 230     {
 231       free (dst);
 232       dst = 0;
 233     }
 234
 235   return dst;
 236 }
 237 #endif
 238
 239 /* If NAME starts with a '@' or '$', apply the translation rules above
 240    and return a new name.  Otherwise, return the given name.  */
 241
 242 static const char *
 243 translate_name (name)
 244   const char *name;
 245 {
 246   char code = name[0];
 247   char *key;
 248   const char *prefix = 0;
 249   int keylen;
 250
 251   if (code != '@' && code != '$')
 252     return name;
 253
 254   for (keylen = 0;
 255        (name[keylen + 1] != 0 && !IS_DIR_SEPARATOR (name[keylen + 1]));
 256        keylen++)
 257     ;
 258
 259   key = (char *) alloca (keylen + 1);
 260   strncpy (key, &name[1], keylen);
 261   key[keylen] = 0;
 262
 263   name = &name[keylen + 1];
 264
 265   if (code == '@')
 266     {
 267       prefix = get_key_value (key);
 268       if (prefix == 0)
 269         prefix = std_prefix;
 270     }
 271   else
 272     prefix = getenv (key);
 273
 274   if (prefix == 0)
 275     prefix = PREFIX;
 276
 277   /* Remove any trailing directory separator from what we got.  */
 278   if (IS_DIR_SEPARATOR (prefix[strlen (prefix) - 1]))
 279     {
 280       char * temp = save_string (prefix, strlen (prefix));
 281       temp[strlen (temp) - 1] = 0;
 282       prefix = temp;
 283     }
 284
 285   return concat (prefix, name, NULL_PTR);
 286 }
 287
 288 /* Update PATH using KEY if PATH starts with PREFIX.  */
 289
 290 const char *
 291 update_path (path, key)
 292   const char *path;
 293   const char *key;
 294 {
 295   if (! strncmp (path, std_prefix, strlen (std_prefix)) && key != 0)
 296     {
 297       if (key[0] != '$')
 298         key = concat ("@", key, NULL_PTR);
 299
 300       path = concat (key, &path[strlen (std_prefix)], NULL_PTR);
 301
 302       while (path[0] == '@' || path[0] == '$')
 303         path = translate_name (path);
 304     }
 305
 306 #ifdef DIR_SEPARATOR_2
 307   /* Convert DIR_SEPARATOR_2 to DIR_SEPARATOR. */
 308   if (DIR_SEPARATOR != DIR_SEPARATOR_2)
 309     {
 310       int i;
 311       int len = strlen (path);
 312       char *new_path = save_string (path, len);
 313       for (i = 0; i < len; i++)
 314         if (new_path[i] == DIR_SEPARATOR_2)
 315           new_path[i] = DIR_SEPARATOR;
 316       path = new_path;
 317     }
 318 #endif
 319
 320 #if defined (DIR_SEPARATOR) && !defined (DIR_SEPARATOR_2)
 321   if (DIR_SEPARATOR != '/')
 322     {
 323       int i;
 324       int len = strlen (path);
 325       char *new_path = save_string (path, len);
 326
 327       for (i = 0; i < len; i++)
 328         if (new_path[i] == '/')
 329           new_path[i] = DIR_SEPARATOR;
 330
 331       path = new_path;
 332     }
 333 #endif
 334
 335   return path;
 336 }
 337
 338 /* Reset the standard prefix */
 339 void
 340 set_std_prefix (prefix, len)
 341   const char *prefix;
 342   int len;
 343 {
 344   std_prefix = save_string (prefix, len);
 345 }