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