Update the auto* tools: autoconf 2.60, libtool 1.5.22, automake 1.9.6.

Update ltld.[ch] to version 1.5.22.
Correct the notes about updating these tools (autoconf/README.TXT)
Add configure options for getting the correct option for including a whole
archive when linking.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@29529 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 188 insertions, 163 deletions

diff --git a/lib/System/ltdl.c b/lib/System/ltdl.c
index 60bbec1..67631be 100644
--- a/lib/System/ltdl.c
+++ b/lib/System/ltdl.c
@@ -1,5 +1,5 @@
 /* ltdl.c -- system independent dlopen wrapper
-   Copyright (C) 1998, 1999, 2000, 2004 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2000, 2004, 2005  Free Software Foundation, Inc.
    Originally by Thomas Tanner <tanner@ffii.org>
    This file is part of GNU Libtool.
 
@@ -20,17 +20,16 @@ Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-02111-1307  USA
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301  USA
 
 */
 
 #include "llvm/Config/config.h"
-/*
- #if HAVE_CONFIG_H
- #  include <config.h>
- #endif
-*/
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
 
 #if HAVE_UNISTD_H
 #  include <unistd.h>
@@ -460,7 +459,9 @@ opendir (path)
   DIR *entry;
 
   assert(path != (char *) NULL);
-  (void) strncpy(file_specification,path,LT_FILENAME_MAX-1);
+  /* allow space for: path + '\\' '\\' '*' '.' '*' + '\0' */
+  (void) strncpy (file_specification, path, LT_FILENAME_MAX-6);
+  file_specification[LT_FILENAME_MAX-6] = LT_EOS_CHAR;
   (void) strcat(file_specification,"\\");
   entry = LT_DLMALLOC (DIR,sizeof(DIR));
   if (entry != (DIR *) 0)
@@ -501,6 +502,7 @@ static struct dirent *readdir(entry)
   entry->firsttime = FALSE;
   (void) strncpy(entry->file_info.d_name,entry->Win32FindData.cFileName,
     LT_FILENAME_MAX-1);
+  entry->file_info.d_name[LT_FILENAME_MAX - 1] = LT_EOS_CHAR;
   entry->file_info.d_namlen = strlen(entry->file_info.d_name);
   return(&entry->file_info);
 }
@@ -625,7 +627,7 @@ argz_create_sep (str, delim, pargz, pargz_len)
   assert (pargz);
   assert (pargz_len);
 
-  /* Make a copy of STR, but replacing each occurence of
+  /* Make a copy of STR, but replacing each occurrence of
      DELIM with '\0'.  */
   argz_len = 1+ LT_STRLEN (str);
   if (argz_len)
@@ -1165,7 +1167,7 @@ static struct lt_user_dlloader sys_dl =
 
 /* --- SHL_LOAD() INTERFACE LOADER --- */
 
-#if HAVE_SHL_LOAD && !defined(__llvm__)
+#if HAVE_SHL_LOAD
 
 /* dynamic linking with shl_load (HP-UX) (comments from gmodule) */
 
@@ -1348,15 +1350,27 @@ sys_wll_open (loader_data, filename)
   if (!searchname)
     return 0;
 
-#if __CYGWIN__
   {
-    char wpath[MAX_PATH];
-    cygwin_conv_to_full_win32_path(searchname, wpath);
-    module = LoadLibrary(wpath);
-  }
+    /* Silence dialog from LoadLibrary on some failures.
+       No way to get the error mode, but to set it,
+       so set it twice to preserve any previous flags. */
+    UINT errormode = SetErrorMode(SEM_FAILCRITICALERRORS);
+    SetErrorMode(errormode | SEM_FAILCRITICALERRORS);
+
+#if defined(__CYGWIN__)
+    {
+      char wpath[MAX_PATH];
+      cygwin_conv_to_full_win32_path (searchname, wpath);
+      module = LoadLibrary (wpath);
+    }
 #else
-  module = LoadLibrary (searchname);
+    module = LoadLibrary (searchname);
 #endif
+
+    /* Restore the error mode. */
+    SetErrorMode(errormode);
+  }
+
   LT_DLFREE (searchname);
 
   /* libltdl expects this function to fail if it is unable
@@ -2214,7 +2228,7 @@ lt_dlinit ()
 #if HAVE_LIBDL
       errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dl, "dlopen");
 #endif
-#if HAVE_SHL_LOAD && !defined(__llvm__)
+#if HAVE_SHL_LOAD
       errors += lt_dlloader_add (lt_dlloader_next (0), &sys_shl, "dlopen");
 #endif
 #ifdef __WINDOWS__
@@ -2541,8 +2555,8 @@ find_module (handle, dir, libdir, dlname, old_name, installed)
 
       /* maybe it was moved to another directory */
       {
-	  if (tryall_dlopen_module (handle,
-				    (const char *) 0, dir, dlname) == 0)
+	  if (dir && (tryall_dlopen_module (handle,
+				    (const char *) 0, dir, dlname) == 0))
 	    return 0;
       }
     }
@@ -2869,12 +2883,6 @@ load_deplibs (handle, deplibs)
 	}
     }
 
-  /* restore the old search path */
-  LT_DLFREE (user_search_path);
-  user_search_path = save_search_path;
-
-  LT_DLMUTEX_UNLOCK ();
-
   if (!depcount)
     {
       errors = 0;
@@ -2961,6 +2969,13 @@ load_deplibs (handle, deplibs)
 
  cleanup:
   LT_DLFREE (names);
+  /* restore the old search path */
+  if (user_search_path) {
+    LT_DLFREE (user_search_path);
+    user_search_path = save_search_path;
+  }
+  LT_DLMUTEX_UNLOCK ();
+
 #endif
 
   return errors;
@@ -3000,6 +3015,9 @@ trim (dest, str)
 
   LT_DLFREE (*dest);
 
+  if (!end)
+    return 1;
+
   if (len > 3 && str[0] == '\'')
     {
       tmp = LT_EMALLOC (char, end - str);
@@ -3104,7 +3122,7 @@ try_dlopen (phandle, filename)
       ++base_name;
     }
   else
-    LT_DLMEM_REASSIGN (base_name, canonical);
+    base_name = canonical;
 
   assert (base_name && *base_name);
 
@@ -3537,7 +3555,14 @@ lt_argz_insert (pargz, pargz_len, before, entry)
 {
   error_t error;
 
-  if ((error = argz_insert (pargz, pargz_len, before, entry)))
+  /* Prior to Sep 8, 2005, newlib had a bug where argz_insert(pargz,
+     pargz_len, NULL, entry) failed with EINVAL.  */
+  if (before)
+    error = argz_insert (pargz, pargz_len, before, entry);
+  else
+    error = argz_append (pargz, pargz_len, entry, 1 + LT_STRLEN (entry));
+
+  if (error)
     {
       switch (error)
 	{
@@ -3989,7 +4014,7 @@ lt_dlpath_insertdir (ppath, before, dir)
   if (before)
     {
       assert (*ppath <= before);
-      assert (before - *ppath <= (int)strlen (*ppath));
+      assert ((size_t)(before - *ppath) <= strlen (*ppath));
 
       before = before - *ppath + argz;
     }
diff --git a/lib/System/ltdl.h b/lib/System/ltdl.h
index 8bf255b..8aaf342 100644
--- a/lib/System/ltdl.h
+++ b/lib/System/ltdl.h
@@ -20,32 +20,32 @@ Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; 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
 */
 
 /* Only include this header file once. */
 #ifndef LTDL_H
 #define LTDL_H 1
 
-#include <sys/types.h>          /* for size_t declaration */
+#include <sys/types.h>		/* for size_t declaration */
 
 
 /* --- MACROS FOR PORTABILITY --- */
 
 
 /* Saves on those hard to debug '\0' typos....  */
-#define LT_EOS_CHAR     '\0'
+#define LT_EOS_CHAR	'\0'
 
 /* LTDL_BEGIN_C_DECLS should be used at the beginning of your declarations,
    so that C++ compilers don't mangle their names.  Use LTDL_END_C_DECLS at
    the end of C declarations. */
 #ifdef __cplusplus
-# define LT_BEGIN_C_DECLS       extern "C" {
-# define LT_END_C_DECLS         }
+# define LT_BEGIN_C_DECLS	extern "C" {
+# define LT_END_C_DECLS		}
 #else
-# define LT_BEGIN_C_DECLS       /* empty */
-# define LT_END_C_DECLS         /* empty */
+# define LT_BEGIN_C_DECLS	/* empty */
+# define LT_END_C_DECLS		/* empty */
 #endif
 
 LT_BEGIN_C_DECLS
@@ -55,11 +55,11 @@ LT_BEGIN_C_DECLS
    that don't understand ANSI C prototypes still work, and ANSI C
    compilers can issue warnings about type mismatches.  */
 #if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(WIN32) || defined(__cplusplus)
-# define LT_PARAMS(protos)      protos
-# define lt_ptr         void*
+# define LT_PARAMS(protos)	protos
+# define lt_ptr		void*
 #else
-# define LT_PARAMS(protos)      ()
-# define lt_ptr         char*
+# define LT_PARAMS(protos)	()
+# define lt_ptr		char*
 #endif
 
 /* LT_STMT_START/END are used to create macros which expand to a
@@ -80,13 +80,13 @@ LT_BEGIN_C_DECLS
 /* LT_CONC creates a new concatenated symbol for the compiler
    in a portable way.  */
 #if defined(__STDC__) || defined(__cplusplus) || defined(_MSC_VER)
-#  define LT_CONC(s,t)  s##t
+#  define LT_CONC(s,t)	s##t
 #else
-#  define LT_CONC(s,t)  s/**/t
+#  define LT_CONC(s,t)	s/**/t
 #endif
 
 /* LT_STRLEN can be used safely on NULL pointers.  */
-#define LT_STRLEN(s)    (((s) && (s)[0]) ? strlen (s) : 0)
+#define LT_STRLEN(s)	(((s) && (s)[0]) ? strlen (s) : 0)
 
 
 
@@ -116,27 +116,27 @@ LT_BEGIN_C_DECLS
 #  ifndef __CYGWIN__
 /* LT_DIRSEP_CHAR is accepted *in addition* to '/' as a directory
    separator when it is set. */
-#    define LT_DIRSEP_CHAR      '\\'
-#    define LT_PATHSEP_CHAR     ';'
+#    define LT_DIRSEP_CHAR	'\\'
+#    define LT_PATHSEP_CHAR	';'
 #  endif
 #endif
 #ifndef LT_PATHSEP_CHAR
-#  define LT_PATHSEP_CHAR       ':'
+#  define LT_PATHSEP_CHAR	':'
 #endif
 
 /* DLL building support on win32 hosts;  mostly to workaround their
    ridiculous implementation of data symbol exporting. */
 #ifndef LT_SCOPE
 #  ifdef __WINDOWS__
-#    ifdef DLL_EXPORT           /* defined by libtool (if required) */
-#      define LT_SCOPE  __declspec(dllexport)
+#    ifdef DLL_EXPORT		/* defined by libtool (if required) */
+#      define LT_SCOPE	__declspec(dllexport)
 #    endif
-#    ifdef LIBLTDL_DLL_IMPORT   /* define if linking with this dll */
-#      define LT_SCOPE  extern __declspec(dllimport)
+#    ifdef LIBLTDL_DLL_IMPORT	/* define if linking with this dll */
+#      define LT_SCOPE	extern __declspec(dllimport)
 #    endif
 #  endif
-#  ifndef LT_SCOPE              /* static linking or !__WINDOWS__ */
-#    define LT_SCOPE    extern
+#  ifndef LT_SCOPE		/* static linking or !__WINDOWS__ */
+#    define LT_SCOPE	extern
 #  endif
 #endif
 
@@ -150,34 +150,34 @@ LT_BEGIN_C_DECLS
 /* --- DYNAMIC MODULE LOADING API --- */
 
 
-typedef struct lt_dlhandle_struct *lt_dlhandle; /* A loaded module.  */
+typedef	struct lt_dlhandle_struct *lt_dlhandle;	/* A loaded module.  */
 
 /* Initialisation and finalisation functions for libltdl. */
-LT_SCOPE        int         lt_dlinit           LT_PARAMS((void));
-LT_SCOPE        int         lt_dlexit           LT_PARAMS((void));
+LT_SCOPE	int	    lt_dlinit		LT_PARAMS((void));
+LT_SCOPE	int	    lt_dlexit		LT_PARAMS((void));
 
 /* Module search path manipulation.  */
-LT_SCOPE        int         lt_dladdsearchdir    LT_PARAMS((const char *search_dir));
-LT_SCOPE        int         lt_dlinsertsearchdir LT_PARAMS((const char *before,
-                                                    const char *search_dir));
-LT_SCOPE        int         lt_dlsetsearchpath   LT_PARAMS((const char *search_path));
-LT_SCOPE        const char *lt_dlgetsearchpath   LT_PARAMS((void));
-LT_SCOPE        int         lt_dlforeachfile     LT_PARAMS((
-                        const char *search_path,
-                        int (*func) (const char *filename, lt_ptr data),
-                        lt_ptr data));
+LT_SCOPE	int	    lt_dladdsearchdir	 LT_PARAMS((const char *search_dir));
+LT_SCOPE	int	    lt_dlinsertsearchdir LT_PARAMS((const char *before,
+						    const char *search_dir));
+LT_SCOPE	int 	    lt_dlsetsearchpath	 LT_PARAMS((const char *search_path));
+LT_SCOPE	const char *lt_dlgetsearchpath	 LT_PARAMS((void));
+LT_SCOPE	int	    lt_dlforeachfile	 LT_PARAMS((
+			const char *search_path,
+			int (*func) (const char *filename, lt_ptr data),
+			lt_ptr data));
 
 /* Portable libltdl versions of the system dlopen() API. */
-LT_SCOPE        lt_dlhandle lt_dlopen           LT_PARAMS((const char *filename));
-LT_SCOPE        lt_dlhandle lt_dlopenext        LT_PARAMS((const char *filename));
-LT_SCOPE        lt_ptr      lt_dlsym            LT_PARAMS((lt_dlhandle handle,
-                                                     const char *name));
-LT_SCOPE        const char *lt_dlerror          LT_PARAMS((void));
-LT_SCOPE        int         lt_dlclose          LT_PARAMS((lt_dlhandle handle));
+LT_SCOPE	lt_dlhandle lt_dlopen		LT_PARAMS((const char *filename));
+LT_SCOPE	lt_dlhandle lt_dlopenext	LT_PARAMS((const char *filename));
+LT_SCOPE	lt_ptr	    lt_dlsym		LT_PARAMS((lt_dlhandle handle,
+						     const char *name));
+LT_SCOPE	const char *lt_dlerror		LT_PARAMS((void));
+LT_SCOPE	int	    lt_dlclose		LT_PARAMS((lt_dlhandle handle));
 
 /* Module residency management. */
-LT_SCOPE        int         lt_dlmakeresident   LT_PARAMS((lt_dlhandle handle));
-LT_SCOPE        int         lt_dlisresident     LT_PARAMS((lt_dlhandle handle));
+LT_SCOPE	int	    lt_dlmakeresident	LT_PARAMS((lt_dlhandle handle));
+LT_SCOPE	int	    lt_dlisresident	LT_PARAMS((lt_dlhandle handle));
 
 
 
@@ -185,15 +185,15 @@ LT_SCOPE        int         lt_dlisresident     LT_PARAMS((lt_dlhandle handle));
 /* --- MUTEX LOCKING --- */
 
 
-typedef void    lt_dlmutex_lock         LT_PARAMS((void));
-typedef void    lt_dlmutex_unlock       LT_PARAMS((void));
-typedef void    lt_dlmutex_seterror     LT_PARAMS((const char *errmsg));
-typedef const char *lt_dlmutex_geterror LT_PARAMS((void));
+typedef void	lt_dlmutex_lock		LT_PARAMS((void));
+typedef void	lt_dlmutex_unlock	LT_PARAMS((void));
+typedef void	lt_dlmutex_seterror	LT_PARAMS((const char *errmsg));
+typedef const char *lt_dlmutex_geterror	LT_PARAMS((void));
 
-LT_SCOPE        int     lt_dlmutex_register     LT_PARAMS((lt_dlmutex_lock *lock,
-                                            lt_dlmutex_unlock *unlock,
-                                            lt_dlmutex_seterror *seterror,
-                                            lt_dlmutex_geterror *geterror));
+LT_SCOPE	int	lt_dlmutex_register	LT_PARAMS((lt_dlmutex_lock *lock,
+					    lt_dlmutex_unlock *unlock,
+					    lt_dlmutex_seterror *seterror,
+					    lt_dlmutex_geterror *geterror));
 
 
 
@@ -206,9 +206,9 @@ LT_SCOPE        int     lt_dlmutex_register     LT_PARAMS((lt_dlmutex_lock *lock
    libltdl relies on a featureful realloc, but if you are sure yours
    has the right semantics then you can assign it directly.  Generally,
    it is safe to assign just a malloc() and a free() function.  */
-LT_SCOPE  lt_ptr   (*lt_dlmalloc)       LT_PARAMS((size_t size));
-LT_SCOPE  lt_ptr   (*lt_dlrealloc)      LT_PARAMS((lt_ptr ptr, size_t size));
-LT_SCOPE  void     (*lt_dlfree)         LT_PARAMS((lt_ptr ptr));
+LT_SCOPE  lt_ptr   (*lt_dlmalloc)	LT_PARAMS((size_t size));
+LT_SCOPE  lt_ptr   (*lt_dlrealloc)	LT_PARAMS((lt_ptr ptr, size_t size));
+LT_SCOPE  void	   (*lt_dlfree)		LT_PARAMS((lt_ptr ptr));
 
 
 
@@ -223,14 +223,14 @@ typedef struct {
   lt_ptr      address;
 } lt_dlsymlist;
 
-LT_SCOPE        int     lt_dlpreload    LT_PARAMS((const lt_dlsymlist *preloaded));
-LT_SCOPE        int     lt_dlpreload_default
-                                LT_PARAMS((const lt_dlsymlist *preloaded));
+LT_SCOPE	int	lt_dlpreload	LT_PARAMS((const lt_dlsymlist *preloaded));
+LT_SCOPE	int	lt_dlpreload_default
+				LT_PARAMS((const lt_dlsymlist *preloaded));
 
-#define LTDL_SET_PRELOADED_SYMBOLS()            LT_STMT_START{  \
-        extern const lt_dlsymlist lt_preloaded_symbols[];               \
-        lt_dlpreload_default(lt_preloaded_symbols);                     \
-                                                }LT_STMT_END
+#define LTDL_SET_PRELOADED_SYMBOLS() 		LT_STMT_START{	\
+	extern const lt_dlsymlist lt_preloaded_symbols[];		\
+	lt_dlpreload_default(lt_preloaded_symbols);			\
+						}LT_STMT_END
 
 
 
@@ -239,67 +239,67 @@ LT_SCOPE        int     lt_dlpreload_default
 
 
 /* Read only information pertaining to a loaded module. */
-typedef struct {
-  char  *filename;              /* file name */
-  char  *name;                  /* module name */
-  int   ref_count;              /* number of times lt_dlopened minus
-                                   number of times lt_dlclosed. */
+typedef	struct {
+  char	*filename;		/* file name */
+  char	*name;			/* module name */
+  int	ref_count;		/* number of times lt_dlopened minus
+				   number of times lt_dlclosed. */
 } lt_dlinfo;
 
-LT_SCOPE        const lt_dlinfo *lt_dlgetinfo       LT_PARAMS((lt_dlhandle handle));
-LT_SCOPE        lt_dlhandle     lt_dlhandle_next    LT_PARAMS((lt_dlhandle place));
-LT_SCOPE        int             lt_dlforeach        LT_PARAMS((
-                                int (*func) (lt_dlhandle handle, lt_ptr data),
-                                lt_ptr data));
+LT_SCOPE	const lt_dlinfo	*lt_dlgetinfo	    LT_PARAMS((lt_dlhandle handle));
+LT_SCOPE	lt_dlhandle	lt_dlhandle_next    LT_PARAMS((lt_dlhandle place));
+LT_SCOPE	int		lt_dlforeach	    LT_PARAMS((
+				int (*func) (lt_dlhandle handle, lt_ptr data),
+				lt_ptr data));
 
 /* Associating user data with loaded modules. */
 typedef unsigned lt_dlcaller_id;
 
-LT_SCOPE        lt_dlcaller_id  lt_dlcaller_register  LT_PARAMS((void));
-LT_SCOPE        lt_ptr          lt_dlcaller_set_data  LT_PARAMS((lt_dlcaller_id key,
-                                                lt_dlhandle handle,
-                                                lt_ptr data));
-LT_SCOPE        lt_ptr          lt_dlcaller_get_data  LT_PARAMS((lt_dlcaller_id key,
-                                                lt_dlhandle handle));
+LT_SCOPE	lt_dlcaller_id	lt_dlcaller_register  LT_PARAMS((void));
+LT_SCOPE	lt_ptr		lt_dlcaller_set_data  LT_PARAMS((lt_dlcaller_id key,
+						lt_dlhandle handle,
+						lt_ptr data));
+LT_SCOPE	lt_ptr		lt_dlcaller_get_data  LT_PARAMS((lt_dlcaller_id key,
+						lt_dlhandle handle));
 
 
 
 /* --- USER MODULE LOADER API --- */
 
 
-typedef struct lt_dlloader      lt_dlloader;
-typedef lt_ptr                  lt_user_data;
-typedef lt_ptr                  lt_module;
+typedef	struct lt_dlloader	lt_dlloader;
+typedef lt_ptr			lt_user_data;
+typedef lt_ptr			lt_module;
 
 /* Function pointer types for creating user defined module loaders. */
-typedef lt_module   lt_module_open      LT_PARAMS((lt_user_data loader_data,
-                                            const char *filename));
-typedef int         lt_module_close     LT_PARAMS((lt_user_data loader_data,
-                                            lt_module handle));
-typedef lt_ptr      lt_find_sym         LT_PARAMS((lt_user_data loader_data,
-                                            lt_module handle,
-                                            const char *symbol));
-typedef int         lt_dlloader_exit    LT_PARAMS((lt_user_data loader_data));
+typedef lt_module   lt_module_open	LT_PARAMS((lt_user_data loader_data,
+					    const char *filename));
+typedef int	    lt_module_close	LT_PARAMS((lt_user_data loader_data,
+					    lt_module handle));
+typedef lt_ptr	    lt_find_sym		LT_PARAMS((lt_user_data loader_data,
+					    lt_module handle,
+					    const char *symbol));
+typedef int	    lt_dlloader_exit	LT_PARAMS((lt_user_data loader_data));
 
 struct lt_user_dlloader {
-  const char           *sym_prefix;
+  const char	       *sym_prefix;
   lt_module_open       *module_open;
   lt_module_close      *module_close;
-  lt_find_sym          *find_sym;
+  lt_find_sym	       *find_sym;
   lt_dlloader_exit     *dlloader_exit;
-  lt_user_data          dlloader_data;
+  lt_user_data		dlloader_data;
 };
 
-LT_SCOPE        lt_dlloader    *lt_dlloader_next    LT_PARAMS((lt_dlloader *place));
-LT_SCOPE        lt_dlloader    *lt_dlloader_find    LT_PARAMS((
-                                                const char *loader_name));
-LT_SCOPE        const char     *lt_dlloader_name    LT_PARAMS((lt_dlloader *place));
-LT_SCOPE        lt_user_data   *lt_dlloader_data    LT_PARAMS((lt_dlloader *place));
-LT_SCOPE        int             lt_dlloader_add     LT_PARAMS((lt_dlloader *place,
-                                const struct lt_user_dlloader *dlloader,
-                                const char *loader_name));
-LT_SCOPE        int             lt_dlloader_remove  LT_PARAMS((
-                                                const char *loader_name));
+LT_SCOPE	lt_dlloader    *lt_dlloader_next    LT_PARAMS((lt_dlloader *place));
+LT_SCOPE	lt_dlloader    *lt_dlloader_find    LT_PARAMS((
+						const char *loader_name));
+LT_SCOPE	const char     *lt_dlloader_name    LT_PARAMS((lt_dlloader *place));
+LT_SCOPE	lt_user_data   *lt_dlloader_data    LT_PARAMS((lt_dlloader *place));
+LT_SCOPE	int		lt_dlloader_add     LT_PARAMS((lt_dlloader *place,
+				const struct lt_user_dlloader *dlloader,
+				const char *loader_name));
+LT_SCOPE	int		lt_dlloader_remove  LT_PARAMS((
+						const char *loader_name));
 
 
 
@@ -310,39 +310,39 @@ LT_SCOPE        int             lt_dlloader_remove  LT_PARAMS((
    this way allows us to expand the macro in different contexts with
    confidence that the enumeration of symbolic names will map correctly
    onto the table of error strings.  */
-#define lt_dlerror_table                                                \
-    LT_ERROR(UNKNOWN,               "unknown error")                    \
-    LT_ERROR(DLOPEN_NOT_SUPPORTED,  "dlopen support not available")     \
-    LT_ERROR(INVALID_LOADER,        "invalid loader")                   \
-    LT_ERROR(INIT_LOADER,           "loader initialization failed")     \
-    LT_ERROR(REMOVE_LOADER,         "loader removal failed")            \
-    LT_ERROR(FILE_NOT_FOUND,        "file not found")                   \
-    LT_ERROR(DEPLIB_NOT_FOUND,      "dependency library not found")     \
-    LT_ERROR(NO_SYMBOLS,            "no symbols defined")               \
-    LT_ERROR(CANNOT_OPEN,           "can't open the module")            \
-    LT_ERROR(CANNOT_CLOSE,          "can't close the module")           \
-    LT_ERROR(SYMBOL_NOT_FOUND,      "symbol not found")                 \
-    LT_ERROR(NO_MEMORY,             "not enough memory")                \
-    LT_ERROR(INVALID_HANDLE,        "invalid module handle")            \
-    LT_ERROR(BUFFER_OVERFLOW,       "internal buffer overflow")         \
-    LT_ERROR(INVALID_ERRORCODE,     "invalid errorcode")                \
-    LT_ERROR(SHUTDOWN,              "library already shutdown")         \
-    LT_ERROR(CLOSE_RESIDENT_MODULE, "can't close resident module")      \
+#define lt_dlerror_table						\
+    LT_ERROR(UNKNOWN,		    "unknown error")			\
+    LT_ERROR(DLOPEN_NOT_SUPPORTED,  "dlopen support not available")	\
+    LT_ERROR(INVALID_LOADER,	    "invalid loader")			\
+    LT_ERROR(INIT_LOADER,	    "loader initialization failed")	\
+    LT_ERROR(REMOVE_LOADER,	    "loader removal failed")		\
+    LT_ERROR(FILE_NOT_FOUND,	    "file not found")			\
+    LT_ERROR(DEPLIB_NOT_FOUND,      "dependency library not found")	\
+    LT_ERROR(NO_SYMBOLS,	    "no symbols defined")		\
+    LT_ERROR(CANNOT_OPEN,	    "can't open the module")		\
+    LT_ERROR(CANNOT_CLOSE,	    "can't close the module")		\
+    LT_ERROR(SYMBOL_NOT_FOUND,      "symbol not found")			\
+    LT_ERROR(NO_MEMORY,		    "not enough memory")		\
+    LT_ERROR(INVALID_HANDLE,	    "invalid module handle")		\
+    LT_ERROR(BUFFER_OVERFLOW,	    "internal buffer overflow")		\
+    LT_ERROR(INVALID_ERRORCODE,     "invalid errorcode")		\
+    LT_ERROR(SHUTDOWN,		    "library already shutdown")		\
+    LT_ERROR(CLOSE_RESIDENT_MODULE, "can't close resident module")	\
     LT_ERROR(INVALID_MUTEX_ARGS,    "invalid mutex handler registration") \
-    LT_ERROR(INVALID_POSITION,      "invalid search path insert position")
+    LT_ERROR(INVALID_POSITION,	    "invalid search path insert position")
 
 /* Enumerate the symbolic error names. */
 enum {
-#define LT_ERROR(name, diagnostic)      LT_CONC(LT_ERROR_, name),
-        lt_dlerror_table
+#define LT_ERROR(name, diagnostic)	LT_CONC(LT_ERROR_, name),
+	lt_dlerror_table
 #undef LT_ERROR
 
-        LT_ERROR_MAX
+	LT_ERROR_MAX
 };
 
 /* These functions are only useful from inside custom module loaders. */
-LT_SCOPE        int     lt_dladderror   LT_PARAMS((const char *diagnostic));
-LT_SCOPE        int     lt_dlseterror   LT_PARAMS((int errorcode));
+LT_SCOPE	int	lt_dladderror	LT_PARAMS((const char *diagnostic));
+LT_SCOPE	int	lt_dlseterror	LT_PARAMS((int errorcode));
 
 
 
@@ -351,14 +351,14 @@ LT_SCOPE        int     lt_dlseterror   LT_PARAMS((int errorcode));
 
 
 #ifdef LT_NON_POSIX_NAMESPACE
-#  define lt_ptr_t              lt_ptr
-#  define lt_module_t           lt_module
-#  define lt_module_open_t      lt_module_open
-#  define lt_module_close_t     lt_module_close
-#  define lt_find_sym_t         lt_find_sym
-#  define lt_dlloader_exit_t    lt_dlloader_exit
-#  define lt_dlloader_t         lt_dlloader
-#  define lt_dlloader_data_t    lt_user_data
+#  define lt_ptr_t		lt_ptr
+#  define lt_module_t		lt_module
+#  define lt_module_open_t	lt_module_open
+#  define lt_module_close_t	lt_module_close
+#  define lt_find_sym_t		lt_find_sym
+#  define lt_dlloader_exit_t	lt_dlloader_exit
+#  define lt_dlloader_t		lt_dlloader
+#  define lt_dlloader_data_t	lt_user_data
 #endif
 
 LT_END_C_DECLS