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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [libiberty/] [make-relative-prefix.c] - Blame information for rev 321

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

Line No. Rev Author Line
1 274 jeremybenn
/* Relative (relocatable) prefix support.
2
   Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3
   1999, 2000, 2001, 2002, 2006 Free Software Foundation, Inc.
4
 
5
This file is part of libiberty.
6
 
7
GCC is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 2, or (at your option) any later
10
version.
11
 
12
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15
for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING.  If not, write to the Free
19
Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
20
02110-1301, USA.  */
21
 
22
/*
23
 
24
@deftypefn Extension {const char*} make_relative_prefix (const char *@var{progname}, const char *@var{bin_prefix}, const char *@var{prefix})
25
 
26
Given three paths @var{progname}, @var{bin_prefix}, @var{prefix},
27
return the path that is in the same position relative to
28
@var{progname}'s directory as @var{prefix} is relative to
29
@var{bin_prefix}.  That is, a string starting with the directory
30
portion of @var{progname}, followed by a relative pathname of the
31
difference between @var{bin_prefix} and @var{prefix}.
32
 
33
If @var{progname} does not contain any directory separators,
34
@code{make_relative_prefix} will search @env{PATH} to find a program
35
named @var{progname}.  Also, if @var{progname} is a symbolic link,
36
the symbolic link will be resolved.
37
 
38
For example, if @var{bin_prefix} is @code{/alpha/beta/gamma/gcc/delta},
39
@var{prefix} is @code{/alpha/beta/gamma/omega/}, and @var{progname} is
40
@code{/red/green/blue/gcc}, then this function will return
41
@code{/red/green/blue/../../omega/}.
42
 
43
The return value is normally allocated via @code{malloc}.  If no
44
relative prefix can be found, return @code{NULL}.
45
 
46
@end deftypefn
47
 
48
*/
49
 
50
#ifdef HAVE_CONFIG_H
51
#include "config.h"
52
#endif
53
 
54
#ifdef HAVE_STDLIB_H
55
#include <stdlib.h>
56
#endif
57
#ifdef HAVE_UNISTD_H
58
#include <unistd.h>
59
#endif
60
 
61
#include <string.h>
62
 
63
#include "ansidecl.h"
64
#include "libiberty.h"
65
 
66
#ifndef R_OK
67
#define R_OK 4
68
#define W_OK 2
69
#define X_OK 1
70
#endif
71
 
72
#ifndef DIR_SEPARATOR
73
#  define DIR_SEPARATOR '/'
74
#endif
75
 
76
#if defined (_WIN32) || defined (__MSDOS__) \
77
    || defined (__DJGPP__) || defined (__OS2__)
78
#  define HAVE_DOS_BASED_FILE_SYSTEM
79
#  define HAVE_HOST_EXECUTABLE_SUFFIX
80
#  define HOST_EXECUTABLE_SUFFIX ".exe"
81
#  ifndef DIR_SEPARATOR_2 
82
#    define DIR_SEPARATOR_2 '\\'
83
#  endif
84
#  define PATH_SEPARATOR ';'
85
#else
86
#  define PATH_SEPARATOR ':'
87
#endif
88
 
89
#ifndef DIR_SEPARATOR_2
90
#  define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
91
#else
92
#  define IS_DIR_SEPARATOR(ch) \
93
        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
94
#endif
95
 
96
#define DIR_UP ".."
97
 
98
static char *save_string (const char *, int);
99
static char **split_directories (const char *, int *);
100
static void free_split_directories (char **);
101
 
102
static char *
103
save_string (const char *s, int len)
104
{
105
  char *result = (char *) malloc (len + 1);
106
 
107
  memcpy (result, s, len);
108
  result[len] = 0;
109
  return result;
110
}
111
 
112
/* Split a filename into component directories.  */
113
 
114
static char **
115
split_directories (const char *name, int *ptr_num_dirs)
116
{
117
  int num_dirs = 0;
118
  char **dirs;
119
  const char *p, *q;
120
  int ch;
121
 
122
  /* Count the number of directories.  Special case MSDOS disk names as part
123
     of the initial directory.  */
124
  p = name;
125
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
126
  if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
127
    {
128
      p += 3;
129
      num_dirs++;
130
    }
131
#endif /* HAVE_DOS_BASED_FILE_SYSTEM */
132
 
133
  while ((ch = *p++) != '\0')
134
    {
135
      if (IS_DIR_SEPARATOR (ch))
136
        {
137
          num_dirs++;
138
          while (IS_DIR_SEPARATOR (*p))
139
            p++;
140
        }
141
    }
142
 
143
  dirs = (char **) malloc (sizeof (char *) * (num_dirs + 2));
144
  if (dirs == NULL)
145
    return NULL;
146
 
147
  /* Now copy the directory parts.  */
148
  num_dirs = 0;
149
  p = name;
150
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
151
  if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
152
    {
153
      dirs[num_dirs++] = save_string (p, 3);
154
      if (dirs[num_dirs - 1] == NULL)
155
        {
156
          free (dirs);
157
          return NULL;
158
        }
159
      p += 3;
160
    }
161
#endif /* HAVE_DOS_BASED_FILE_SYSTEM */
162
 
163
  q = p;
164
  while ((ch = *p++) != '\0')
165
    {
166
      if (IS_DIR_SEPARATOR (ch))
167
        {
168
          while (IS_DIR_SEPARATOR (*p))
169
            p++;
170
 
171
          dirs[num_dirs++] = save_string (q, p - q);
172
          if (dirs[num_dirs - 1] == NULL)
173
            {
174
              dirs[num_dirs] = NULL;
175
              free_split_directories (dirs);
176
              return NULL;
177
            }
178
          q = p;
179
        }
180
    }
181
 
182
  if (p - 1 - q > 0)
183
    dirs[num_dirs++] = save_string (q, p - 1 - q);
184
  dirs[num_dirs] = NULL;
185
 
186
  if (dirs[num_dirs - 1] == NULL)
187
    {
188
      free_split_directories (dirs);
189
      return NULL;
190
    }
191
 
192
  if (ptr_num_dirs)
193
    *ptr_num_dirs = num_dirs;
194
  return dirs;
195
}
196
 
197
/* Release storage held by split directories.  */
198
 
199
static void
200
free_split_directories (char **dirs)
201
{
202
  int i = 0;
203
 
204
  if (dirs != NULL)
205
    {
206
      while (dirs[i] != NULL)
207
        free (dirs[i++]);
208
 
209
      free ((char *) dirs);
210
    }
211
}
212
 
213
/* Given three strings PROGNAME, BIN_PREFIX, PREFIX, return a string that gets
214
   to PREFIX starting with the directory portion of PROGNAME and a relative
215
   pathname of the difference between BIN_PREFIX and PREFIX.
216
 
217
   For example, if BIN_PREFIX is /alpha/beta/gamma/gcc/delta, PREFIX is
218
   /alpha/beta/gamma/omega/, and PROGNAME is /red/green/blue/gcc, then this
219
   function will return /red/green/blue/../../omega/.
220
 
221
   If no relative prefix can be found, return NULL.  */
222
 
223
static char *
224
make_relative_prefix_1 (const char *progname, const char *bin_prefix,
225
                        const char *prefix, const int resolve_links)
226
{
227
  char **prog_dirs = NULL, **bin_dirs = NULL, **prefix_dirs = NULL;
228
  int prog_num, bin_num, prefix_num;
229
  int i, n, common;
230
  int needed_len;
231
  char *ret = NULL, *ptr, *full_progname;
232
 
233
  if (progname == NULL || bin_prefix == NULL || prefix == NULL)
234
    return NULL;
235
 
236
  /* If there is no full pathname, try to find the program by checking in each
237
     of the directories specified in the PATH environment variable.  */
238
  if (lbasename (progname) == progname)
239
    {
240
      char *temp;
241
 
242
      temp = getenv ("PATH");
243
      if (temp)
244
        {
245
          char *startp, *endp, *nstore;
246
          size_t prefixlen = strlen (temp) + 1;
247
          if (prefixlen < 2)
248
            prefixlen = 2;
249
 
250
          nstore = (char *) alloca (prefixlen + strlen (progname) + 1);
251
 
252
          startp = endp = temp;
253
          while (1)
254
            {
255
              if (*endp == PATH_SEPARATOR || *endp == 0)
256
                {
257
                  if (endp == startp)
258
                    {
259
                      nstore[0] = '.';
260
                      nstore[1] = DIR_SEPARATOR;
261
                      nstore[2] = '\0';
262
                    }
263
                  else
264
                    {
265
                      strncpy (nstore, startp, endp - startp);
266
                      if (! IS_DIR_SEPARATOR (endp[-1]))
267
                        {
268
                          nstore[endp - startp] = DIR_SEPARATOR;
269
                          nstore[endp - startp + 1] = 0;
270
                        }
271
                      else
272
                        nstore[endp - startp] = 0;
273
                    }
274
                  strcat (nstore, progname);
275
                  if (! access (nstore, X_OK)
276
#ifdef HAVE_HOST_EXECUTABLE_SUFFIX
277
                      || ! access (strcat (nstore, HOST_EXECUTABLE_SUFFIX), X_OK)
278
#endif
279
                      )
280
                    {
281
                      progname = nstore;
282
                      break;
283
                    }
284
 
285
                  if (*endp == 0)
286
                    break;
287
                  endp = startp = endp + 1;
288
                }
289
              else
290
                endp++;
291
            }
292
        }
293
    }
294
 
295
  if (resolve_links)
296
    full_progname = lrealpath (progname);
297
  else
298
    full_progname = strdup (progname);
299
  if (full_progname == NULL)
300
    return NULL;
301
 
302
  prog_dirs = split_directories (full_progname, &prog_num);
303
  free (full_progname);
304
  if (prog_dirs == NULL)
305
    return NULL;
306
 
307
  bin_dirs = split_directories (bin_prefix, &bin_num);
308
  if (bin_dirs == NULL)
309
    goto bailout;
310
 
311
  /* Remove the program name from comparison of directory names.  */
312
  prog_num--;
313
 
314
  /* If we are still installed in the standard location, we don't need to
315
     specify relative directories.  Also, if argv[0] still doesn't contain
316
     any directory specifiers after the search above, then there is not much
317
     we can do.  */
318
  if (prog_num == bin_num)
319
    {
320
      for (i = 0; i < bin_num; i++)
321
        {
322
          if (strcmp (prog_dirs[i], bin_dirs[i]) != 0)
323
            break;
324
        }
325
 
326
      if (prog_num <= 0 || i == bin_num)
327
        goto bailout;
328
    }
329
 
330
  prefix_dirs = split_directories (prefix, &prefix_num);
331
  if (prefix_dirs == NULL)
332
    goto bailout;
333
 
334
  /* Find how many directories are in common between bin_prefix & prefix.  */
335
  n = (prefix_num < bin_num) ? prefix_num : bin_num;
336
  for (common = 0; common < n; common++)
337
    {
338
      if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0)
339
        break;
340
    }
341
 
342
  /* If there are no common directories, there can be no relative prefix.  */
343
  if (common == 0)
344
    goto bailout;
345
 
346
  /* Two passes: first figure out the size of the result string, and
347
     then construct it.  */
348
  needed_len = 0;
349
  for (i = 0; i < prog_num; i++)
350
    needed_len += strlen (prog_dirs[i]);
351
  needed_len += sizeof (DIR_UP) * (bin_num - common);
352
  for (i = common; i < prefix_num; i++)
353
    needed_len += strlen (prefix_dirs[i]);
354
  needed_len += 1; /* Trailing NUL.  */
355
 
356
  ret = (char *) malloc (needed_len);
357
  if (ret == NULL)
358
    goto bailout;
359
 
360
  /* Build up the pathnames in argv[0].  */
361
  *ret = '\0';
362
  for (i = 0; i < prog_num; i++)
363
    strcat (ret, prog_dirs[i]);
364
 
365
  /* Now build up the ..'s.  */
366
  ptr = ret + strlen(ret);
367
  for (i = common; i < bin_num; i++)
368
    {
369
      strcpy (ptr, DIR_UP);
370
      ptr += sizeof (DIR_UP) - 1;
371
      *(ptr++) = DIR_SEPARATOR;
372
    }
373
  *ptr = '\0';
374
 
375
  /* Put in directories to move over to prefix.  */
376
  for (i = common; i < prefix_num; i++)
377
    strcat (ret, prefix_dirs[i]);
378
 
379
 bailout:
380
  free_split_directories (prog_dirs);
381
  free_split_directories (bin_dirs);
382
  free_split_directories (prefix_dirs);
383
 
384
  return ret;
385
}
386
 
387
 
388
/* Do the full job, including symlink resolution.
389
   This path will find files installed in the same place as the
390
   program even when a soft link has been made to the program
391
   from somwhere else. */
392
 
393
char *
394
make_relative_prefix (const char *progname, const char *bin_prefix,
395
                      const char *prefix)
396
{
397
  return make_relative_prefix_1 (progname, bin_prefix, prefix, 1);
398
}
399
 
400
/* Make the relative pathname without attempting to resolve any links.
401
   '..' etc may also be left in the pathname.
402
   This will find the files the user meant the program to find if the
403
   installation is patched together with soft links. */
404
 
405
char *
406
make_relative_prefix_ignore_links (const char *progname,
407
                                   const char *bin_prefix,
408
                                   const char *prefix)
409
{
410
  return make_relative_prefix_1 (progname, bin_prefix, prefix, 0);
411
}
412
 

powered by: WebSVN 2.1.0

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