diff options
Diffstat (limited to 'PATCHES/0002-Relocate-libintl.patch')
| -rw-r--r-- | PATCHES/0002-Relocate-libintl.patch | 855 |
1 files changed, 855 insertions, 0 deletions
diff --git a/PATCHES/0002-Relocate-libintl.patch b/PATCHES/0002-Relocate-libintl.patch new file mode 100644 index 0000000..0d44a6e --- /dev/null +++ b/PATCHES/0002-Relocate-libintl.patch @@ -0,0 +1,855 @@ +From b00d99e8c5b045acdacae73d946dd8147a8885c8 Mon Sep 17 00:00:00 2001 +From: Erwin Waterlander <waterlan@xs4all.nl> +Date: Wed, 5 Aug 2015 23:36:03 +0100 +Subject: [PATCH 02/15] Relocate libintl + +The relocatex-libintl patch adds builtin relocation for executables to the +libintl dll. With this patch the programs are automatically relocatable. There +is no need anymore to add relocation code to your program when you use this +libintl DLL. + +The patch was ported from the GnuWin32 port of libintl, which has also builtin +relacation support. + +At the moment the relocation support is only active if you compile with MinGW +for Windows. If you compile for Unix/Linux/Cygwin the functionality is +unchanged. + +See also: +http://waterlan.home.xs4all.nl/libintl.html +http://sourceforge.net/tracker/?func=detail&atid=302435&aid=3003879&group_id=2435 +GnuWin32: http://gnuwin32.sourceforge.net/ + +Great thanks to GnuWin32 maintainer Kees Zeelenberg. + +Erwin Waterlander +waterlan@xs4all.nl +http://waterlan.home.xs4all.nl/ + +Additional "bogus paths for *nix-style paths" fix by Alexey Pavlov + +[jes: fix for 64-bit] + +Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> +--- + intl/Makefile.in | 8 +- + intl/bindtextdom.c | 22 ++++ + intl/canonicalize.c | 343 ++++++++++++++++++++++++++++++++++++++++++++++++++++ + intl/canonicalize.h | 18 +++ + intl/relocatex.c | 284 +++++++++++++++++++++++++++++++++++++++++++ + intl/relocatex.h | 41 +++++++ + 6 files changed, 715 insertions(+), 1 deletion(-) + create mode 100644 intl/canonicalize.c + create mode 100644 intl/canonicalize.h + create mode 100644 intl/relocatex.c + create mode 100644 intl/relocatex.h + +diff --git a/intl/Makefile.in b/intl/Makefile.in +index 3dd0b7f..e2b8666 100644 +--- a/intl/Makefile.in ++++ b/intl/Makefile.in +@@ -53,6 +53,7 @@ DEFS = -DHAVE_CONFIG_H + COMPILE = $(CC) -c $(CPPFLAGS) $(CFLAGS) $(DEFS) $(DEFS-$@) $(INCLUDES) + + HEADERS = \ ++ canonicalize.h \ + gmo.h \ + gettextP.h \ + hash-string.h \ +@@ -61,6 +62,7 @@ HEADERS = \ + eval-plural.h \ + localcharset.h \ + relocatable.h \ ++ relocatex.h \ + libgnuintl.h + SOURCES = \ + bindtextdom.c \ +@@ -81,6 +83,8 @@ SOURCES = \ + plural-exp.c \ + localcharset.c \ + relocatable.c \ ++ relocatex.c \ ++ canonicalize.c \ + localename.c \ + log.c \ + osdep.c \ +@@ -104,6 +108,8 @@ OBJECTS = \ + plural-exp.o \ + localcharset.o \ + relocatable.o \ ++ relocatex.o \ ++ canonicalize.o \ + localename.o \ + log.o \ + osdep.o \ +@@ -158,7 +164,7 @@ install-info install-dvi install-ps install-pdf install-html: + $(OBJECTS): config.h libintl.h + bindtextdom.o dcgettext.o dcigettext.o dcngettext.o dgettext.o \ + dngettext.o finddomain.o gettext.o intl-compat.o loadmsgcat.o \ +-localealias.o ngettext.o textdomain.o: gettextP.h gmo.h loadinfo.h ++localealias.o ngettext.o textdomain.o: gettextP.h gmo.h loadinfo.h relocatex.h + dcigettext.o loadmsgcat.o: hash-string.h + explodename.o l10nflist.o: loadinfo.h + dcigettext.o loadmsgcat.o plural.o plural-exp.o: plural-exp.h +diff --git a/intl/bindtextdom.c b/intl/bindtextdom.c +index 6faac57..b7a62d5 100644 +--- a/intl/bindtextdom.c ++++ b/intl/bindtextdom.c +@@ -23,6 +23,7 @@ + #include <stddef.h> + #include <stdlib.h> + #include <string.h> ++#include <unistd.h> + + #ifdef _LIBC + # include <libintl.h> +@@ -91,6 +92,12 @@ static void set_binding_values PARAMS ((const char *domainname, + const char **dirnamep, + const char **codesetp)); + ++#if ENABLE_RELOCATABLE ++# include "relocatex.h" ++#else ++# define relocate(pathname) (pathname) ++#endif ++ + /* Specifies the directory name *DIRNAMEP and the output codeset *CODESETP + to be used for the DOMAINNAME message catalog. + If *DIRNAMEP or *CODESETP is NULL, the corresponding attribute is not +@@ -352,8 +359,23 @@ BINDTEXTDOMAIN (domainname, dirname) + const char *domainname; + const char *dirname; + { ++/* + set_binding_values (domainname, &dirname, NULL); + return (char *) dirname; ++*/ ++ if (!access (dirname, R_OK)) { ++ set_binding_values (domainname, &dirname, NULL); ++ return (char *) dirname; ++ } else { ++ char *locale_dirname, *installdir = strdup (dirname), *s; ++ if ((s = strrchr (installdir, '/'))) *s = '\0'; ++ if ((s = strrchr (installdir, '/'))) *s = '\0'; ++ locale_dirname = relocatex (installdir, dirname); ++ set_binding_values (domainname, (const char **) &locale_dirname, NULL); ++ if (installdir) ++ free (installdir); ++ return (char *) locale_dirname; ++ } + } + + /* Specify the character encoding in which the messages from the +diff --git a/intl/canonicalize.c b/intl/canonicalize.c +new file mode 100644 +index 0000000..5217f30 +--- /dev/null ++++ b/intl/canonicalize.c +@@ -0,0 +1,343 @@ ++/* Return the canonical absolute name of a given file. ++ Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#include <stdlib.h> ++#include <string.h> ++#include <unistd.h> ++#include <limits.h> ++#include <sys/param.h> ++#include <sys/stat.h> ++#include <errno.h> ++#include <stddef.h> ++#include <malloc.h> ++#ifdef __WIN32__ ++# include <stdio.h> ++# include <windows.h> ++//# include <gw32.h> ++#endif /* __WIN32__ */ ++#include "canonicalize.h" ++ ++#ifndef MAXSYMLINKS ++# define MAXSYMLINKS 20 ++#endif ++ ++#ifndef __set_errno ++# define __set_errno(Val) errno = (Val) ++#endif ++ ++# ifdef VMS ++ /* We want the directory in Unix syntax, not in VMS syntax. */ ++# define __getcwd(buf, max) getcwd (buf, max, 0) ++# else ++# define __getcwd getcwd ++# endif ++ ++#define weak_alias(local, symbol) ++ ++#if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__ ++ /* Win32, Cygwin, OS/2, DOS */ ++# define ISDIRSEP(C) ((C) == '/' || (C) == '\\') ++#else ++ /* Unix */ ++# define ISDIRSEP(C) ((C) == '/') ++#endif ++ ++#ifdef __WIN32__ ++char *win2unixpath (char *FileName) ++{ ++ char *s = FileName; ++ while (*s) { ++ if (*s == '\\') ++ *s = '/'; ++ *s++; ++ } ++ return FileName; ++} ++#endif ++ ++/* Return the canonical absolute name of file NAME. A canonical name ++ does not contain any `.', `..' components nor any repeated path ++ separators ('/') or symlinks. All path components must exist. If ++ RESOLVED is null, the result is malloc'd; otherwise, if the ++ canonical name is PATH_MAX chars or more, returns null with `errno' ++ set to ENAMETOOLONG; if the name fits in fewer than PATH_MAX chars, ++ returns the name in RESOLVED. If the name cannot be resolved and ++ RESOLVED is non-NULL, it contains the path of the first component ++ that cannot be resolved. If the path can be resolved, RESOLVED ++ holds the same value as the value returned. ++ RESOLVED must be at least PATH_MAX long */ ++ ++static char * ++canonicalize (const char *name, char *resolved) ++{ ++ char *rpath, *dest, *extra_buf = NULL; ++ const char *start, *end, *rpath_limit; ++ long int path_max; ++ int num_links = 0, old_errno; ++ ++ if (name == NULL) ++ { ++ /* As per Single Unix Specification V2 we must return an error if ++ either parameter is a null pointer. We extend this to allow ++ the RESOLVED parameter to be NULL in case the we are expected to ++ allocate the room for the return value. */ ++ __set_errno (EINVAL); ++ return NULL; ++ } ++ ++ if (name[0] == '\0') ++ { ++ /* As per Single Unix Specification V2 we must return an error if ++ the name argument points to an empty string. */ ++ __set_errno (ENOENT); ++ return NULL; ++ } ++#ifdef __WIN32__ ++ { ++ char *lpFilePart; ++ int len; ++// fprintf(stderr, "name: %s\n", name); ++ rpath = resolved ? __builtin_alloca (MAX_PATH) : malloc (MAX_PATH); ++// unix2winpath (name); ++// fprintf(stderr, "name: %s\n", name); ++len = GetFullPathName(name, MAX_PATH, rpath, &lpFilePart); ++/* GetFullPathName returns bogus paths for *nix-style paths, like ++ * /foo/bar - it just prepends current drive to them. Keep them ++ * intact (they need to be for relocation to work!). ++ */ ++if (name[0] == '/') { ++ strncpy (rpath, name, MAX_PATH - 1); ++ rpath[MAX_PATH - 1] = '\0'; ++ len = strlen (rpath); ++} ++// fprintf(stderr, "rpath: %s\n", rpath); ++ if (len == 0) { ++ //set_werrno; ++ return NULL; ++ } ++ if (len > MAX_PATH) { ++ if (resolved) ++ __set_errno(ENAMETOOLONG); ++ else { ++ rpath = realloc(rpath, len + 2); ++ GetFullPathName(name, len, rpath, &lpFilePart); ++// fprintf(stderr, "rpath: %s\n", rpath); ++ } ++ } ++// if ( ISDIRSEP(name[strlen(name)]) && !ISDIRSEP(rpath[len]) ) { ++// rpath[len] = '\\'; ++// rpath[len + 1] = 0; ++// } ++ old_errno = errno; ++ //if (!access (rpath, D_OK) && !ISDIRSEP(rpath[len - 1]) ){ ++ if (!access (rpath, R_OK) && !ISDIRSEP(rpath[len - 1]) ){ ++ rpath[len] = '\\'; ++ rpath[len + 1] = 0; ++ } ++ errno = old_errno; ++ win2unixpath (rpath); ++// fprintf(stderr, "rpath: %s\n", rpath); ++ return resolved ? strcpy(resolved, rpath) : rpath ; ++ } ++#else /* __WIN32__ */ ++ ++#ifdef PATH_MAX ++ path_max = PATH_MAX; ++#else ++ path_max = pathconf (name, _PC_PATH_MAX); ++ if (path_max <= 0) ++ path_max = 1024; ++#endif ++ ++ rpath = resolved ? __builtin_alloca (path_max) : malloc (path_max); ++ rpath_limit = rpath + path_max; ++ ++ if (name[0] != '/') ++ { ++ if (!__getcwd (rpath, path_max)) ++ { ++ rpath[0] = '\0'; ++ goto error; ++ } ++ dest = strchr (rpath, '\0'); ++ } ++ else ++ { ++ rpath[0] = '/'; ++ dest = rpath + 1; ++ } ++ ++ for (start = end = name; *start; start = end) ++ { ++#ifdef _LIBC ++ struct stat64 st; ++#else ++ struct stat st; ++#endif ++ int n; ++ ++ /* Skip sequence of multiple path-separators. */ ++ while (*start == '/') ++ ++start; ++ ++ /* Find end of path component. */ ++ for (end = start; *end && *end != '/'; ++end) ++ /* Nothing. */; ++ ++ if (end - start == 0) ++ break; ++ else if (end - start == 1 && start[0] == '.') ++ /* nothing */; ++ else if (end - start == 2 && start[0] == '.' && start[1] == '.') ++ { ++ /* Back up to previous component, ignore if at root already. */ ++ if (dest > rpath + 1) ++ while ((--dest)[-1] != '/'); ++ } ++ else ++ { ++ size_t new_size; ++ ++ if (dest[-1] != '/') ++ *dest++ = '/'; ++ ++ if (dest + (end - start) >= rpath_limit) ++ { ++ ptrdiff_t dest_offset = dest - rpath; ++ ++ if (resolved) ++ { ++ __set_errno (ENAMETOOLONG); ++ if (dest > rpath + 1) ++ dest--; ++ *dest = '\0'; ++ goto error; ++ } ++ new_size = rpath_limit - rpath; ++ if (end - start + 1 > path_max) ++ new_size += end - start + 1; ++ else ++ new_size += path_max; ++ rpath = realloc (rpath, new_size); ++ rpath_limit = rpath + new_size; ++ if (rpath == NULL) ++ return NULL; ++ ++ dest = rpath + dest_offset; ++ } ++ ++#ifdef _LIBC ++ dest = __mempcpy (dest, start, end - start); ++#else ++ memcpy (dest, start, end - start); ++ dest += end - start; ++#endif ++ *dest = '\0'; ++ ++#ifdef _LIBC ++ if (__lxstat64 (_STAT_VER, rpath, &st) < 0) ++#else ++ if (lstat (rpath, &st) < 0) ++#endif ++ goto error; ++ ++#if HAVE_READLINK ++ if (S_ISLNK (st.st_mode)) ++ { ++ char *buf = __builtin_alloca (path_max); ++ size_t len; ++ ++ if (++num_links > MAXSYMLINKS) ++ { ++ __set_errno (ELOOP); ++ goto error; ++ } ++ ++ n = __readlink (rpath, buf, path_max); ++ if (n < 0) ++ goto error; ++ buf[n] = '\0'; ++ ++ if (!extra_buf) ++ extra_buf = __builtin_alloca (path_max); ++ ++ len = strlen (end); ++ if ((long int) (n + len) >= path_max) ++ { ++ __set_errno (ENAMETOOLONG); ++ goto error; ++ } ++ ++ /* Careful here, end may be a pointer into extra_buf... */ ++ memmove (&extra_buf[n], end, len + 1); ++ name = end = memcpy (extra_buf, buf, n); ++ ++ if (buf[0] == '/') ++ dest = rpath + 1; /* It's an absolute symlink */ ++ else ++ /* Back up to previous component, ignore if at root already: */ ++ if (dest > rpath + 1) ++ while ((--dest)[-1] != '/'); ++ } ++#endif ++ } ++ } ++ if (dest > rpath + 1 && dest[-1] == '/') ++ --dest; ++ *dest = '\0'; ++ ++ return resolved ? memcpy (resolved, rpath, dest - rpath + 1) : rpath; ++ ++error: ++ if (resolved) ++ strcpy (resolved, rpath); ++ else ++ free (rpath); ++ return NULL; ++ ++#endif /* __WIN32__ */ ++} ++ ++ ++char * ++__realpath (const char *name, char *resolved) ++{ ++ if (resolved == NULL) ++ { ++ __set_errno (EINVAL); ++ return NULL; ++ } ++ ++ return canonicalize (name, resolved); ++} ++weak_alias (__realpath, realpath) ++ ++ ++char * ++__canonicalize_file_name (const char *name) ++{ ++ return canonicalize (name, NULL); ++} ++weak_alias (__canonicalize_file_name, canonicalize_file_name) ++ ++char * ++canonicalize_file_name (const char *name) ++{ ++ return canonicalize (name, NULL); ++} +diff --git a/intl/canonicalize.h b/intl/canonicalize.h +new file mode 100644 +index 0000000..ea707bf +--- /dev/null ++++ b/intl/canonicalize.h +@@ -0,0 +1,18 @@ ++#ifndef __CANONICALIZE_H__ ++#define __CANONICALIZE_H__ 1 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++char *canonicalize_file_name (const char *name); ++ ++#ifdef __WIN32__ ++char *win2unixpath (char *path); ++#endif ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* __CANONICALIZE_H__ */ +diff --git a/intl/relocatex.c b/intl/relocatex.c +new file mode 100644 +index 0000000..a2b7438 +--- /dev/null ++++ b/intl/relocatex.c +@@ -0,0 +1,284 @@ ++/* Provide relocatable packages. ++ Copyright (C) 2003 Free Software Foundation, Inc. ++ Written by Bruno Haible <bruno@clisp.org>, 2003. ++ ++ This program 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, or (at your option) ++ any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Library General Public License for more details. ++ ++ You should have received a copy of the GNU Library General Public ++ License along with this program; if not, write to the Free Software ++ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, ++ USA. */ ++ ++ ++/* Specification. */ ++#include <errno.h> ++#define _GNU_SOURCE ++#include <stdlib.h> ++#include <string.h> ++#include <stdio.h> ++#include <unistd.h> ++/* #include <path.h> */ ++#include "relocatex.h" ++#include "canonicalize.h" ++/* #include <gw32.h> */ ++ ++ ++#if defined _WIN32 || defined __WIN32__ ++# define WIN32_LEAN_AND_MEAN ++# include <windows.h> ++//# define __GW32__ ++//# include <winx/errnox.h> ++#endif ++#define set_werrno ++ ++#if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__ ++ /* Win32, Cygwin, OS/2, DOS */ ++# define ISDIRSEP(C) ((C) == '/' || (C) == '\\') ++#else ++ /* Unix */ ++# define ISDIRSEP(C) ((C) == '/') ++#endif ++ ++/* Original installation prefix. */ ++static char *orig_prefix = NULL; ++static size_t orig_prefix_len = 0; ++/* Current installation prefix. */ ++static char *curr_prefix = NULL; ++static size_t curr_prefix_len = 0; ++/* These prefixes do not end in a slash. Anything that will be concatenated ++ to them must start with a slash. */ ++ ++ ++int win2posixpath (const char *winpath, char *posixpath) ++{ ++ strcpy (posixpath, winpath); ++ win2unixpath (posixpath); ++ return 0; ++} ++ ++ ++/* Sets the original and the current installation prefix of this module. ++ Relocation simply replaces a pathname starting with the original prefix ++ by the corresponding pathname with the current prefix instead. Both ++ prefixes should be directory names without trailing slash (i.e. use "" ++ instead of "/"). */ ++static char * ++set_orig_prefix (const char *orig_prefix_arg) ++{ ++ char *memory; ++// printf ("orig_prefix_arg: %s\n", orig_prefix_arg); ++ if (!orig_prefix_arg) { ++ orig_prefix = NULL; ++ orig_prefix_len = 0; ++ return NULL; ++ } ++ if (orig_prefix) ++ free (orig_prefix); ++ ++ memory = canonicalize_file_name (orig_prefix_arg); ++// printf ("memory: %s\n", memory); ++// memory = (char *) malloc (orig_prefix_len + 1); ++ if (!memory) { ++ set_werrno; ++ orig_prefix = NULL; ++ orig_prefix_len = 0; ++ return NULL; ++ } ++ win2unixpath (memory); ++// win2posixpath (orig_prefix_arg, memory); ++ orig_prefix = memory; ++ orig_prefix_len = strlen (orig_prefix); ++// printf ("orig_prefix: %s\n", orig_prefix); ++ if (ISDIRSEP (orig_prefix[orig_prefix_len-1])) { ++ orig_prefix[orig_prefix_len-1] = '\0'; ++ orig_prefix_len--; ++ } ++// printf ("orig_prefix: %s\n", orig_prefix); ++// printf ("orig_prefix_len: %d\n", orig_prefix_len); ++ return orig_prefix; ++} ++ ++#if defined __WIN32__ ++static char * ++set_current_prefix (const char *ModuleName) ++{ ++ LPTSTR curr_prefix_arg, q, lpFilePart; ++ DWORD len; ++ int nDIRSEP = 0; ++ ++ if (curr_prefix) ++ free (curr_prefix); ++ curr_prefix_arg = malloc (MAX_PATH * sizeof (TCHAR)); ++ if (!curr_prefix_arg) { ++ set_werrno; ++ curr_prefix = NULL; ++ curr_prefix_len = 0; ++ return NULL; ++ } ++ if (ModuleName) { ++// printf ("ModuleName: %s\n", ModuleName); ++ len = SearchPath (NULL, ModuleName, ".DLL", MAX_PATH, curr_prefix_arg, &lpFilePart); ++ if (len) { ++// printf ("ModulePath: %s\n", curr_prefix_arg); ++// printf ("FilePart: %s\n", lpFilePart); ++ } ++ } ++ if (!ModuleName || !len) { ++ len = GetModuleFileName (NULL, curr_prefix_arg, MAX_PATH); ++ if (!len) { ++ set_werrno; ++ curr_prefix = NULL; ++ curr_prefix_len = 0; ++ return NULL; ++ } ++ } ++// strncpy (curr_prefix_arg, ModuleName, MAX_PATH); ++// printf ("curr_prefix_arg: %s\n", curr_prefix_arg); ++ win2posixpath (curr_prefix_arg, curr_prefix_arg); ++ curr_prefix = curr_prefix_arg; ++ q = curr_prefix_arg + len - 1; ++ /* strip name of executable and its directory */ ++ while (!ISDIRSEP (*q) && (q > curr_prefix_arg) && nDIRSEP < 2) { ++ q--; ++ if (ISDIRSEP (*q)) { ++ *q = '\0'; ++ nDIRSEP++; ++ } ++ } ++ curr_prefix_len = q - curr_prefix_arg; ++// printf ("curr_prefix: %s\n", curr_prefix); ++// printf ("curr_prefix_len: %d\n", curr_prefix_len); ++ return curr_prefix; ++} ++ ++char *getshortpath (const char *longpath) ++{ ++ char *shortpath = NULL; ++ DWORD len, res; ++ ++// printf ("longpath: %s\n", longpath); ++ len = GetShortPathName(longpath, shortpath, 0); ++// printf ("len: %ld\n", len); ++ if (!len) { ++// WinErr ("getshortpath: len = 0"); ++ set_werrno; ++ return (char *) longpath; ++ } ++ shortpath = (char *) malloc (len + 1); ++ if (!shortpath) { ++// WinErr ("getshortpath: malloc"); ++ set_werrno; ++ return (char *) longpath; ++ } ++ res = GetShortPathName(longpath, shortpath, len); ++// printf ("res: %ld\n", res); ++ if (!res) { ++// WinErr ("getshortpath: res = 0"); ++ free (shortpath); ++ set_werrno; ++ return (char *) longpath; ++ } ++// printf ("shortpath: %s\n", shortpath); ++ return shortpath; ++} ++ ++char *relocaten (const char *ModuleName, const char *path) ++{ ++ char *relative_path, *relocated_path, *relocated_short_path; ++ int relative_path_len; ++ ++ if (!curr_prefix) ++ set_current_prefix (ModuleName); ++// printf ("path: %s\n", path); ++// printf ("orig_prefix: %s\n", orig_prefix); ++// printf ("curr_prefix: %s\n", curr_prefix); ++// if (strncmp (orig_prefix, path, orig_prefix_len)) ++// if (strcmp (orig_prefix, path)) ++// return (char *) path; ++ relative_path = (char *) path + orig_prefix_len; ++// printf ("relative_path: %s\n", relative_path); ++ relative_path_len = strlen (relative_path); ++ relocated_path = malloc (curr_prefix_len + relative_path_len + 1); ++ strcpy (relocated_path, curr_prefix); ++ strcat (relocated_path, relative_path); ++// printf ("relocated_path: %s\n", relocated_path); ++ relocated_short_path = getshortpath (relocated_path); ++// printf ("relocated_short_path: %s\n", relocated_short_path); ++ if (relocated_short_path) { ++ if (relocated_short_path != relocated_path) ++ free (relocated_path); ++ return relocated_short_path; ++ } else ++ return relocated_path; ++} ++ ++#else // __WIN32__ ++char *relocaten (const char *ModuleName, const char *path) ++{ ++ // dummy function for Unix/Linux ++ return (char *)path; ++} ++#endif ++ ++char *relocaten2 (const char *ModuleName, const char *installdir, const char *path) ++{ ++ set_orig_prefix (installdir); ++ return relocaten (ModuleName, path); ++} ++ ++char *relocatenx (const char *ModuleName, const char *installdir, const char *path) ++{ ++ char *p; ++ ++ set_orig_prefix (installdir); ++ if (access (path, R_OK)) ++ p = relocaten (ModuleName, path); ++ else ++ p = (char *) path; ++// printf ("relocatenx: %s\n", p); ++ return p; ++} ++ ++char *relocate2 (const char *installdir, const char *path) ++{ ++ return relocaten2 (NULL, installdir, path); ++} ++ ++char *relocatex (const char *installdir, const char *path) ++{ ++ return relocatenx (NULL, installdir, path); ++} ++ ++char *relocatepx (const char *cprefix, const char *installdir, const char *path) ++{ ++ if (curr_prefix) ++ free (curr_prefix); ++ curr_prefix = strdup (cprefix); ++ return relocatex (installdir, path); ++} ++ ++static char *get_orig_prefix (void) ++{ ++ return orig_prefix; ++} ++ ++static char *get_curr_prefix (void) ++{ ++ return curr_prefix; ++} ++ ++static char *set_curr_prefix (const char *ModuleName) ++{ ++ if (curr_prefix) ++ free (curr_prefix); ++ set_current_prefix (ModuleName); ++ return curr_prefix; ++} +diff --git a/intl/relocatex.h b/intl/relocatex.h +new file mode 100644 +index 0000000..5cc7c51 +--- /dev/null ++++ b/intl/relocatex.h +@@ -0,0 +1,41 @@ ++/* ++ Copyright (C) 2006 Free Software Foundation, Inc. ++ This file is part of the GnuWin C Library. ++ ++ The GnuWin C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GnuWin C Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GnuWin32 C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#ifndef __RELOCATE_H__ ++#define __RELOCATE_H__ 1 ++ ++/* #include <libc-dll.h> */ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++char *relocaten (const char *ModuleName, const char *path); ++char *relocaten2 (const char *ModuleName, const char *installdir, const char *path); ++char *relocatenx (const char *ModuleName, const char *installdir, const char *path); ++char *relocate2 (const char *installdir, const char *path); ++char *relocatex (const char *installdir, const char *path); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++//#endif /* __GW32__ */ ++ ++#endif /* __RELOCATE_H__ */ +-- +2.8.1 + |