gcc/prefix.c

   1 /* Utility to update paths from internal to external forms.
   2    Copyright (C) 1997, 1998 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
  72 static char *std_prefix = PREFIX;
  73
  74 static char *get_key_value      PROTO((char *));
  75 static char *translate_name     PROTO((char *));
  76 static char *concat             PVPROTO((char *, ...));
  77 static char *save_string        PROTO((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 char *
  87 get_key_value (key)
  88      char *key;
  89 {
  90   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 static char *
 114 concat VPROTO((char *first, ...))
 115 {
 116   register int length;
 117   register char *newstr;
 118   register char *end;
 119   register char *arg;
 120   va_list args;
 121 #ifndef __STDC__
 122   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 __STDC__
 129   first = va_arg (args, 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, 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 __STDC__
 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, 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      char *s;
 170      int len;
 171 {
 172   register char *result = (char *) malloc (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 char *
 232 translate_name (name)
 233      char *name;
 234 {
 235   char code = name[0];
 236   char *key, *prefix = 0;
 237   int keylen;
 238
 239   if (code != '@' && code != '$')
 240     return name;
 241
 242   for (keylen = 0;
 243        (name[keylen + 1] != 0 && name[keylen + 1] != '/'
 244 #ifdef DIR_SEPARATOR
 245         && name[keylen + 1] != DIR_SEPARATOR
 246 #endif
 247         );
 248        keylen++)
 249     ;
 250
 251   key = (char *) alloca (keylen + 1);
 252   strncpy (key, &name[1], keylen);
 253   key[keylen] = 0;
 254
 255   name = &name[keylen + 1];
 256
 257   if (code == '@')
 258     {
 259       prefix = get_key_value (key);
 260       if (prefix == 0)
 261         prefix = std_prefix;
 262     }
 263   else
 264     prefix = getenv (key);
 265
 266   if (prefix == 0)
 267     prefix = PREFIX;
 268
 269   /* Remove any trailing directory separator from what we got.  */
 270   if (prefix[strlen (prefix) - 1] == '/'
 271 #ifdef DIR_SEPARATOR
 272       || prefix[strlen (prefix) - 1] == DIR_SEPARATOR
 273 #endif
 274       )
 275     {
 276       prefix = save_string (prefix, strlen (prefix));
 277       prefix[strlen (prefix) - 1] = 0;
 278     }
 279
 280   return concat (prefix, name, NULL_PTR);
 281 }
 282
 283 /* Update PATH using KEY if PATH starts with PREFIX.  */
 284
 285 char *
 286 update_path (path, key)
 287      char *path;
 288      char *key;
 289 {
 290   if (! strncmp (path, std_prefix, strlen (std_prefix)) && key != 0)
 291     {
 292       if (key[0] != '$')
 293         key = concat ("@", key, NULL_PTR);
 294
 295       path = concat (key, &path[strlen (std_prefix)], NULL_PTR);
 296
 297       while (path[0] == '@' || path[0] == '$')
 298         path = translate_name (path);
 299     }
 300
 301 #ifdef DIR_SEPARATOR
 302   if (DIR_SEPARATOR != '/')
 303     {
 304       int i;
 305       int len = strlen (path);
 306
 307       path = save_string (path, len);
 308       for (i = 0; i < len; i++)
 309         if (path[i] == '/')
 310           path[i] = DIR_SEPARATOR;
 311     }
 312 #endif
 313
 314   return path;
 315 }
 316
 317 /* Reset the standard prefix */
 318 void
 319 set_std_prefix (prefix, len)
 320      char *prefix;
 321      int len;
 322 {
 323   std_prefix = save_string (prefix, len);
 324 }