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

   1 /* Utility to update paths from internal to external forms.
   2    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   3    2007  Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU Library General Public License as published by
   9 the Free Software Foundation; either version 3 of the License, or (at
  10 your option) any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 Library General Public License for more details.
  16
  17 You should have received a copy of the GNU Library General Public
  18 License along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  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 (char *);
  77 static char *translate_name (char *);
  78 static char *save_string (const char *, int);
  79 static void tr (char *, int, int);
  80
  81 #if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
  82 static char *lookup_key (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 (char *key)
  90 {
  91   const char *prefix = 0;
  92   char *temp = 0;
  93
  94 #if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
  95   prefix = lookup_key (key);
  96 #endif
  97
  98   if (prefix == 0)
  99     prefix = getenv (temp = concat (key, "_ROOT", NULL));
 100
 101   if (prefix == 0)
 102     prefix = std_prefix;
 103
 104   if (temp)
 105     free (temp);
 106
 107   return prefix;
 108 }
 109
 110 /* Return a copy of a string that has been placed in the heap.  */
 111
 112 static char *
 113 save_string (const char *s, int len)
 114 {
 115   char *result = XNEWVEC (char, len + 1);
 116
 117   memcpy (result, s, len);
 118   result[len] = 0;
 119   return result;
 120 }
 121
 122 #if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
 123
 124 #ifndef WIN32_REGISTRY_KEY
 125 # define WIN32_REGISTRY_KEY BASEVER
 126 #endif
 127
 128 /* Look up "key" in the registry, as above.  */
 129
 130 static char *
 131 lookup_key (char *key)
 132 {
 133   char *dst;
 134   DWORD size;
 135   DWORD type;
 136   LONG res;
 137
 138   if (reg_key == (HKEY) INVALID_HANDLE_VALUE)
 139     {
 140       res = RegOpenKeyExA (HKEY_LOCAL_MACHINE, "SOFTWARE", 0,
 141                            KEY_READ, &reg_key);
 142
 143       if (res == ERROR_SUCCESS)
 144         res = RegOpenKeyExA (reg_key, "Free Software Foundation", 0,
 145                              KEY_READ, &reg_key);
 146
 147       if (res == ERROR_SUCCESS)
 148         res = RegOpenKeyExA (reg_key, WIN32_REGISTRY_KEY, 0,
 149                              KEY_READ, &reg_key);
 150
 151       if (res != ERROR_SUCCESS)
 152         {
 153           reg_key = (HKEY) INVALID_HANDLE_VALUE;
 154           return 0;
 155         }
 156     }
 157
 158   size = 32;
 159   dst = xmalloc (size);
 160
 161   res = RegQueryValueExA (reg_key, key, 0, &type, (LPBYTE) dst, &size);
 162   if (res == ERROR_MORE_DATA && type == REG_SZ)
 163     {
 164       dst = xrealloc (dst, size);
 165       res = RegQueryValueExA (reg_key, key, 0, &type, (LPBYTE) dst, &size);
 166     }
 167
 168   if (type != REG_SZ || res != ERROR_SUCCESS)
 169     {
 170       free (dst);
 171       dst = 0;
 172     }
 173
 174   return dst;
 175 }
 176 #endif
 177
 178 /* If NAME, a malloc-ed string, starts with a '@' or '$', apply the
 179    translation rules above and return a newly malloc-ed name.
 180    Otherwise, return the given name.  */
 181
 182 static char *
 183 translate_name (char *name)
 184 {
 185   char code;
 186   char *key, *old_name;
 187   const char *prefix;
 188   int keylen;
 189
 190   for (;;)
 191     {
 192       code = name[0];
 193       if (code != '@' && code != '$')
 194         break;
 195
 196       for (keylen = 0;
 197            (name[keylen + 1] != 0 && !IS_DIR_SEPARATOR (name[keylen + 1]));
 198            keylen++)
 199         ;
 200
 201       key = (char *) alloca (keylen + 1);
 202       strncpy (key, &name[1], keylen);
 203       key[keylen] = 0;
 204
 205       if (code == '@')
 206         {
 207           prefix = get_key_value (key);
 208           if (prefix == 0)
 209             prefix = std_prefix;
 210         }
 211       else
 212         prefix = getenv (key);
 213
 214       if (prefix == 0)
 215         prefix = PREFIX;
 216
 217       /* We used to strip trailing DIR_SEPARATORs here, but that can
 218          sometimes yield a result with no separator when one was coded
 219          and intended by the user, causing two path components to run
 220          together.  */
 221
 222       old_name = name;
 223       name = concat (prefix, &name[keylen + 1], NULL);
 224       free (old_name);
 225     }
 226
 227   return name;
 228 }
 229
 230 /* In a NUL-terminated STRING, replace character C1 with C2 in-place.  */
 231 static void
 232 tr (char *string, int c1, int c2)
 233 {
 234   do
 235     {
 236       if (*string == c1)
 237         *string = c2;
 238     }
 239   while (*string++);
 240 }
 241
 242 /* Update PATH using KEY if PATH starts with PREFIX as a directory.
 243    The returned string is always malloc-ed, and the caller is
 244    responsible for freeing it.  */
 245
 246 char *
 247 update_path (const char *path, const char *key)
 248 {
 249   char *result, *p;
 250   const int len = strlen (std_prefix);
 251
 252   if (! strncmp (path, std_prefix, len)
 253       && (IS_DIR_SEPARATOR(path[len])
 254           || path[len] == '\0')
 255       && key != 0)
 256     {
 257       bool free_key = false;
 258
 259       if (key[0] != '$')
 260         {
 261           key = concat ("@", key, NULL);
 262           free_key = true;
 263         }
 264
 265       result = concat (key, &path[len], NULL);
 266       if (free_key)
 267         free (CONST_CAST (char *, key));
 268       result = translate_name (result);
 269     }
 270   else
 271     result = xstrdup (path);
 272
 273 #ifndef ALWAYS_STRIP_DOTDOT
 274 #define ALWAYS_STRIP_DOTDOT 0
 275 #endif
 276
 277   p = result;
 278   while (1)
 279     {
 280       char *src, *dest;
 281
 282       p = strchr (p, '.');
 283       if (p == NULL)
 284         break;
 285       /* Look for `/../'  */
 286       if (p[1] == '.'
 287           && IS_DIR_SEPARATOR (p[2])
 288           && (p != result && IS_DIR_SEPARATOR (p[-1])))
 289         {
 290           *p = 0;
 291           if (!ALWAYS_STRIP_DOTDOT && access (result, X_OK) == 0)
 292             {
 293               *p = '.';
 294               break;
 295             }
 296           else
 297             {
 298               /* We can't access the dir, so we won't be able to
 299                  access dir/.. either.  Strip out `dir/../'.  If `dir'
 300                  turns out to be `.', strip one more path component.  */
 301               dest = p;
 302               do
 303                 {
 304                   --dest;
 305                   while (dest != result && IS_DIR_SEPARATOR (*dest))
 306                     --dest;
 307                   while (dest != result && !IS_DIR_SEPARATOR (dest[-1]))
 308                     --dest;
 309                 }
 310               while (dest != result && *dest == '.');
 311               /* If we have something like `./..' or `/..', don't
 312                  strip anything more.  */
 313               if (*dest == '.' || IS_DIR_SEPARATOR (*dest))
 314                 {
 315                   *p = '.';
 316                   break;
 317                 }
 318               src = p + 3;
 319               while (IS_DIR_SEPARATOR (*src))
 320                 ++src;
 321               p = dest;
 322               while ((*dest++ = *src++) != 0)
 323                 ;
 324             }
 325         }
 326       else
 327         ++p;
 328     }
 329
 330 #ifdef UPDATE_PATH_HOST_CANONICALIZE
 331   /* Perform host dependent canonicalization when needed.  */
 332   UPDATE_PATH_HOST_CANONICALIZE (result);
 333 #endif
 334
 335 #ifdef DIR_SEPARATOR_2
 336   /* Convert DIR_SEPARATOR_2 to DIR_SEPARATOR.  */
 337   if (DIR_SEPARATOR_2 != DIR_SEPARATOR)
 338     tr (result, DIR_SEPARATOR_2, DIR_SEPARATOR);
 339 #endif
 340
 341 #if defined (DIR_SEPARATOR) && !defined (DIR_SEPARATOR_2)
 342   if (DIR_SEPARATOR != '/')
 343     tr (result, '/', DIR_SEPARATOR);
 344 #endif
 345
 346   return result;
 347 }
 348
 349 /* Reset the standard prefix.  */
 350 void
 351 set_std_prefix (const char *prefix, int len)
 352 {
 353   std_prefix = save_string (prefix, len);
 354 }