OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [prefix.c] - Blame information for rev 304

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.