git.gag.com Git - fw/sdcc/blob - support/cpp2/prefix.c

   1 /* Utility to update paths from internal to external forms.
   2    Copyright (C) 1997, 1998, 1999, 2000 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\<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 const char *translate_name       PARAMS ((const char *));
  78 static char *save_string                PARAMS ((const char *, int));
  79 char *concat                            VPARAMS ((const char *first, ...));
  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 /* Concatenate a sequence of strings, returning the result.
 112
 113    This function is based on the one in libiberty.  */
 114
 115 char *
 116 concat VPARAMS ((const char *first, ...))
 117 {
 118   register int length;
 119   register char *newstr;
 120   register char *end;
 121   register const char *arg;
 122   va_list args;
 123 #ifndef ANSI_PROTOTYPES
 124   const char *first;
 125 #endif
 126
 127   /* First compute the size of the result and get sufficient memory.  */
 128
 129   VA_START (args, first);
 130 #ifndef ANSI_PROTOTYPES
 131   first = va_arg (args, const char *);
 132 #endif
 133
 134   arg = first;
 135   length = 0;
 136
 137   while (arg != 0)
 138     {
 139       length += strlen (arg);
 140       arg = va_arg (args, const char *);
 141     }
 142
 143   newstr = (char *) xmalloc (length + 1);
 144   va_end (args);
 145
 146   /* Now copy the individual pieces to the result string.  */
 147
 148   VA_START (args, first);
 149 #ifndef ANSI_PROTOTYPES
 150   first = va_arg (args, char *);
 151 #endif
 152
 153   end = newstr;
 154   arg = first;
 155   while (arg != 0)
 156     {
 157       while (*arg)
 158         *end++ = *arg++;
 159       arg = va_arg (args, const char *);
 160     }
 161   *end = '\000';
 162   va_end (args);
 163
 164   return (newstr);
 165 }
 166
 167 /* Return a copy of a string that has been placed in the heap.  */
 168
 169 static char *
 170 save_string (s, len)
 171   const char *s;
 172   int len;
 173 {
 174   register char *result = xmalloc (len + 1);
 175
 176   memcpy (result, s, len);
 177   result[len] = 0;
 178   return result;
 179 }
 180
 181 #if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
 182
 183 /* Look up "key" in the registry, as above.  */
 184
 185 static char *
 186 lookup_key (key)
 187      char *key;
 188 {
 189   char *dst;
 190   DWORD size;
 191   DWORD type;
 192   LONG res;
 193
 194   if (reg_key == (HKEY) INVALID_HANDLE_VALUE)
 195     {
 196       res = RegOpenKeyExA (HKEY_LOCAL_MACHINE, "SOFTWARE", 0,
 197                            KEY_READ, &reg_key);
 198
 199       if (res == ERROR_SUCCESS)
 200         res = RegOpenKeyExA (reg_key, "Free Software Foundation", 0,
 201                              KEY_READ, &reg_key);
 202
 203       if (res == ERROR_SUCCESS)
 204         res = RegOpenKeyExA (reg_key, WIN32_REGISTRY_KEY, 0,
 205                              KEY_READ, &reg_key);
 206
 207       if (res != ERROR_SUCCESS)
 208         {
 209           reg_key = (HKEY) INVALID_HANDLE_VALUE;
 210           return 0;
 211         }
 212     }
 213
 214   size = 32;
 215   dst = (char *) xmalloc (size);
 216
 217   res = RegQueryValueExA (reg_key, key, 0, &type, dst, &size);
 218   if (res == ERROR_MORE_DATA && type == REG_SZ)
 219     {
 220       dst = (char *) xrealloc (dst, size);
 221       res = RegQueryValueExA (reg_key, key, 0, &type, dst, &size);
 222     }
 223
 224   if (type != REG_SZ || res != ERROR_SUCCESS)
 225     {
 226       free (dst);
 227       dst = 0;
 228     }
 229
 230   return dst;
 231 }
 232 #endif
 233
 234 /* If NAME starts with a '@' or '$', apply the translation rules above
 235    and return a new name.  Otherwise, return the given name.  */
 236
 237 static const char *
 238 translate_name (name)
 239   const char *name;
 240 {
 241   char code = name[0];
 242   char *key;
 243   const char *prefix = 0;
 244   int keylen;
 245
 246   if (code != '@' && code != '$')
 247     return name;
 248
 249   for (keylen = 0;
 250        (name[keylen + 1] != 0 && !IS_DIR_SEPARATOR (name[keylen + 1]));
 251        keylen++)
 252     ;
 253
 254   key = (char *) alloca (keylen + 1);
 255   strncpy (key, &name[1], keylen);
 256   key[keylen] = 0;
 257
 258   name = &name[keylen + 1];
 259
 260   if (code == '@')
 261     {
 262       prefix = get_key_value (key);
 263       if (prefix == 0)
 264         prefix = std_prefix;
 265     }
 266   else
 267     prefix = getenv (key);
 268
 269   if (prefix == 0)
 270     prefix = PREFIX;
 271
 272   /* We used to strip trailing DIR_SEPARATORs here, but that can
 273      sometimes yield a result with no separator when one was coded
 274      and intended by the user, causing two path components to run
 275      together.  */
 276
 277   return concat (prefix, name, NULL);
 278 }
 279
 280 /* Update PATH using KEY if PATH starts with PREFIX.  */
 281
 282 const char *
 283 update_path (path, key)
 284   const char *path;
 285   const char *key;
 286 {
 287   if (! strncmp (path, std_prefix, strlen (std_prefix)) && key != 0)
 288     {
 289       if (key[0] != '$')
 290         key = concat ("@", key, NULL);
 291
 292       path = concat (key, &path[strlen (std_prefix)], NULL);
 293
 294       while (path[0] == '@' || path[0] == '$')
 295         path = translate_name (path);
 296     }
 297
 298 #ifdef UPDATE_PATH_HOST_CANONICALIZE
 299 /* Perform host dependant canonicalization when needed.  */
 300 UPDATE_PATH_HOST_CANONICALIZE (path, key);
 301 #endif
 302
 303 #ifdef DIR_SEPARATOR_2
 304   /* Convert DIR_SEPARATOR_2 to DIR_SEPARATOR. */
 305   if (DIR_SEPARATOR != DIR_SEPARATOR_2)
 306     {
 307       char *new_path = xstrdup (path);
 308       path = new_path;
 309       do {
 310         if (*new_path == DIR_SEPARATOR_2)
 311           *new_path = DIR_SEPARATOR;
 312       } while (*new_path++);
 313     }
 314 #endif
 315
 316 #if defined (DIR_SEPARATOR) && !defined (DIR_SEPARATOR_2)
 317   if (DIR_SEPARATOR != '/')
 318     {
 319       char *new_path = xstrdup (path);
 320       path = new_path;
 321       do {
 322         if (*new_path == '/')
 323           *new_path = DIR_SEPARATOR;
 324       } while (*new_path++);
 325     }
 326 #endif
 327
 328   return path;
 329 }
 330
 331 /* Reset the standard prefix */
 332 void
 333 set_std_prefix (prefix, len)
 334   const char *prefix;
 335   int len;
 336 {
 337   std_prefix = save_string (prefix, len);
 338 }