X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fprefix.c;h=476e9969936e340346efb5d4bbe5af635e560ede;hb=347465629f7e2933e5a091261fdcffbecf9718f9;hp=b949fce4e41e9b221654dbadc6e674785da31c76;hpb=4a7d7a8b8e7463d645033554f142adb4ad165165;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/prefix.c b/gcc/prefix.c index b949fce4e41..476e9969936 100644 --- a/gcc/prefix.c +++ b/gcc/prefix.c @@ -1,12 +1,13 @@ /* Utility to update paths from internal to external forms. - Copyright (C) 1997, 1998 Free Software Foundation, Inc. + Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 + Free Software Foundation, Inc. -This file is part of GNU CC. +This file is part of GCC. -GNU CC is free software; you can redistribute it and/or -modify it under the terms of the GNU Library General Public -License as published by the Free Software Foundation; either -version 2 of the License, or (at your option) any later version. +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU Library General Public License as published by +the Free Software Foundation; either version 2 of the License, or (at +your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -15,8 +16,8 @@ Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, Inc., 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +Boston, MA 02110-1301, USA. */ /* This file contains routines to update a path, both to canonicalize the directory format and to handle any prefix translation. @@ -42,11 +43,12 @@ Boston, MA 02111-1307, USA. */ be considered a "key" and looked up as follows: -- If this is a Win32 OS, then the Registry will be examined for - an entry of "key" in + an entry of "key" in - HKEY_LOCAL_MACHINE\SOFTWARE\Free Software Foundation\ + HKEY_LOCAL_MACHINE\SOFTWARE\Free Software Foundation\ - if found, that value will be used. + if found, that value will be used. defaults to GCC version + string, but can be overridden at configuration time. -- If not found (or not a Win32 OS), the environment variable key_ROOT (the value of "key" concatenated with the constant "_ROOT") @@ -57,7 +59,7 @@ Boston, MA 02111-1307, USA. */ as an environment variable, whose value will be returned. Once all this is done, any '/' will be converted to DIR_SEPARATOR, - if they are different. + if they are different. NOTE: using resolve_keyed_path under Win32 requires linking with advapi32.dll. */ @@ -65,37 +67,39 @@ Boston, MA 02111-1307, USA. */ #include "config.h" #include "system.h" -#ifdef _WIN32 +#include "coretypes.h" +#include "tm.h" +#if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY) #include #endif +#include "prefix.h" -static char *std_prefix = PREFIX; +static const char *std_prefix = PREFIX; -static char *get_key_value PROTO((char *)); -static char *translate_name PROTO((char *)); -static char *concat PVPROTO((char *, ...)); -static char *save_string PROTO((char *, int)); +static const char *get_key_value (char *); +static char *translate_name (char *); +static char *save_string (const char *, int); +static void tr (char *, int, int); -#ifdef _WIN32 -static char *lookup_key PROTO((char *)); +#if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY) +static char *lookup_key (char *); static HKEY reg_key = (HKEY) INVALID_HANDLE_VALUE; #endif /* Given KEY, as above, return its value. */ -static char * -get_key_value (key) - char *key; +static const char * +get_key_value (char *key) { - char *prefix = 0; + const char *prefix = 0; char *temp = 0; -#ifdef _WIN32 +#if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY) prefix = lookup_key (key); #endif if (prefix == 0) - prefix = getenv (temp = concat (key, "_ROOT", NULL_PTR)); + prefix = getenv (temp = concat (key, "_ROOT", NULL)); if (prefix == 0) prefix = std_prefix; @@ -106,83 +110,28 @@ get_key_value (key) return prefix; } -/* Concatenate a sequence of strings, returning the result. - - This function is based on the one in libiberty. */ - -static char * -concat VPROTO((char *first, ...)) -{ - register int length; - register char *newstr; - register char *end; - register char *arg; - va_list args; -#ifndef __STDC__ - char *first; -#endif - - /* First compute the size of the result and get sufficient memory. */ - - VA_START (args, first); -#ifndef __STDC__ - first = va_arg (args, char *); -#endif - - arg = first; - length = 0; - - while (arg != 0) - { - length += strlen (arg); - arg = va_arg (args, char *); - } - - newstr = (char *) malloc (length + 1); - va_end (args); - - /* Now copy the individual pieces to the result string. */ - - VA_START (args, first); -#ifndef __STDC__ - first = va_arg (args, char *); -#endif - - end = newstr; - arg = first; - while (arg != 0) - { - while (*arg) - *end++ = *arg++; - arg = va_arg (args, char *); - } - *end = '\000'; - va_end (args); - - return (newstr); -} - /* Return a copy of a string that has been placed in the heap. */ static char * -save_string (s, len) - char *s; - int len; +save_string (const char *s, int len) { - register char *result = (char *) malloc (len + 1); + char *result = xmalloc (len + 1); - bcopy (s, result, len); + memcpy (result, s, len); result[len] = 0; return result; } -#ifdef _WIN32 +#if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY) + +#ifndef WIN32_REGISTRY_KEY +# define WIN32_REGISTRY_KEY BASEVER +#endif /* Look up "key" in the registry, as above. */ static char * -lookup_key (key) - char *key; +lookup_key (char *key) { char *dst; DWORD size; @@ -198,21 +147,25 @@ lookup_key (key) res = RegOpenKeyExA (reg_key, "Free Software Foundation", 0, KEY_READ, ®_key); + if (res == ERROR_SUCCESS) + res = RegOpenKeyExA (reg_key, WIN32_REGISTRY_KEY, 0, + KEY_READ, ®_key); + if (res != ERROR_SUCCESS) - { - reg_key = (HKEY) INVALID_HANDLE_VALUE; - return 0; - } + { + reg_key = (HKEY) INVALID_HANDLE_VALUE; + return 0; + } } size = 32; - dst = (char *) malloc (size); + dst = xmalloc (size); - res = RegQueryValueExA (reg_key, key, 0, &type, dst, &size); + res = RegQueryValueExA (reg_key, key, 0, &type, (LPBYTE) dst, &size); if (res == ERROR_MORE_DATA && type == REG_SZ) { - dst = (char *) realloc (dst, size); - res = RegQueryValueExA (reg_key, key, 0, &type, dst, &size); + dst = xrealloc (dst, size); + res = RegQueryValueExA (reg_key, key, 0, &type, (LPBYTE) dst, &size); } if (type != REG_SZ || res != ERROR_SUCCESS) @@ -225,100 +178,180 @@ lookup_key (key) } #endif -/* If NAME starts with a '@' or '$', apply the translation rules above - and return a new name. Otherwise, return the given name. */ +/* If NAME, a malloc-ed string, starts with a '@' or '$', apply the + translation rules above and return a newly malloc-ed name. + Otherwise, return the given name. */ static char * -translate_name (name) - char *name; +translate_name (char *name) { - char code = name[0]; - char *key, *prefix = 0; + char code; + char *key, *old_name; + const char *prefix; int keylen; - if (code != '@' && code != '$') - return name; - - for (keylen = 0; - (name[keylen + 1] != 0 && name[keylen + 1] != '/' -#ifdef DIR_SEPARATOR - && name[keylen + 1] != DIR_SEPARATOR -#endif - ); - keylen++) - ; + for (;;) + { + code = name[0]; + if (code != '@' && code != '$') + break; + + for (keylen = 0; + (name[keylen + 1] != 0 && !IS_DIR_SEPARATOR (name[keylen + 1])); + keylen++) + ; + + key = alloca (keylen + 1); + strncpy (key, &name[1], keylen); + key[keylen] = 0; + + if (code == '@') + { + prefix = get_key_value (key); + if (prefix == 0) + prefix = std_prefix; + } + else + prefix = getenv (key); - key = (char *) alloca (keylen + 1); - strncpy (key, &name[1], keylen); - key[keylen] = 0; + if (prefix == 0) + prefix = PREFIX; - name = &name[keylen + 1]; + /* We used to strip trailing DIR_SEPARATORs here, but that can + sometimes yield a result with no separator when one was coded + and intended by the user, causing two path components to run + together. */ - if (code == '@') - { - prefix = get_key_value (key); - if (prefix == 0) - prefix = std_prefix; + old_name = name; + name = concat (prefix, &name[keylen + 1], NULL); + free (old_name); } - else - prefix = getenv (key); - if (prefix == 0) - prefix = PREFIX; + return name; +} - /* Remove any trailing directory separator from what we got. */ - if (prefix[strlen (prefix) - 1] == '/' -#ifdef DIR_SEPARATOR - || prefix[strlen (prefix) - 1] == DIR_SEPARATOR -#endif - ) +/* In a NUL-terminated STRING, replace character C1 with C2 in-place. */ +static void +tr (char *string, int c1, int c2) +{ + do { - prefix = save_string (prefix, strlen (prefix)); - prefix[strlen (prefix) - 1] = 0; + if (*string == c1) + *string = c2; } - - return concat (prefix, name, NULL_PTR); + while (*string++); } -/* Update PATH using KEY if PATH starts with PREFIX. */ +/* Update PATH using KEY if PATH starts with PREFIX as a directory. + The returned string is always malloc-ed, and the caller is + responsible for freeing it. */ char * -update_path (path, key) - char *path; - char *key; +update_path (const char *path, const char *key) { - if (! strncmp (path, std_prefix, strlen (std_prefix)) && key != 0) + char *result, *p; + const int len = strlen (std_prefix); + + if (! strncmp (path, std_prefix, len) + && (IS_DIR_SEPARATOR(path[len]) + || path[len] == '\0') + && key != 0) { + bool free_key = false; + if (key[0] != '$') - key = concat ("@", key, NULL_PTR); + { + key = concat ("@", key, NULL); + free_key = true; + } + + result = concat (key, &path[len], NULL); + if (free_key) + free ((char *) key); + result = translate_name (result); + } + else + result = xstrdup (path); - path = concat (key, &path[strlen (std_prefix)], NULL_PTR); +#ifndef ALWAYS_STRIP_DOTDOT +#define ALWAYS_STRIP_DOTDOT 0 +#endif - while (path[0] == '@' || path[0] == '$') - path = translate_name (path); - } - -#ifdef DIR_SEPARATOR - if (DIR_SEPARATOR != '/') + p = result; + while (1) { - int i; - int len = strlen (path); - - path = save_string (path, len); - for (i = 0; i < len; i++) - if (path[i] == '/') - path[i] = DIR_SEPARATOR; + char *src, *dest; + + p = strchr (p, '.'); + if (p == NULL) + break; + /* Look for `/../' */ + if (p[1] == '.' + && IS_DIR_SEPARATOR (p[2]) + && (p != result && IS_DIR_SEPARATOR (p[-1]))) + { + *p = 0; + if (!ALWAYS_STRIP_DOTDOT && access (result, X_OK) == 0) + { + *p = '.'; + break; + } + else + { + /* We can't access the dir, so we won't be able to + access dir/.. either. Strip out `dir/../'. If `dir' + turns out to be `.', strip one more path component. */ + dest = p; + do + { + --dest; + while (dest != result && IS_DIR_SEPARATOR (*dest)) + --dest; + while (dest != result && !IS_DIR_SEPARATOR (dest[-1])) + --dest; + } + while (dest != result && *dest == '.'); + /* If we have something like `./..' or `/..', don't + strip anything more. */ + if (*dest == '.' || IS_DIR_SEPARATOR (*dest)) + { + *p = '.'; + break; + } + src = p + 3; + while (IS_DIR_SEPARATOR (*src)) + ++src; + p = dest; + while ((*dest++ = *src++) != 0) + ; + } + } + else + ++p; } + +#ifdef UPDATE_PATH_HOST_CANONICALIZE + /* Perform host dependent canonicalization when needed. */ + UPDATE_PATH_HOST_CANONICALIZE (result); #endif - return path; +#ifdef DIR_SEPARATOR_2 + /* Convert DIR_SEPARATOR_2 to DIR_SEPARATOR. */ + if (DIR_SEPARATOR_2 != DIR_SEPARATOR) + tr (result, DIR_SEPARATOR_2, DIR_SEPARATOR); +#endif + +#if defined (DIR_SEPARATOR) && !defined (DIR_SEPARATOR_2) + if (DIR_SEPARATOR != '/') + tr (result, '/', DIR_SEPARATOR); +#endif + + return result; } -/* Reset the standard prefix */ +/* Reset the standard prefix. */ void -set_std_prefix (prefix, len) - char *prefix; - int len; +set_std_prefix (const char *prefix, int len) { std_prefix = save_string (prefix, len); }