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