Ignore:
Timestamp:
Jun 29, 2003, 2:42:21 PM (17 years ago)
Author:
ranger
Message:

more fixes for cvs-built kde

Location:
trunk/dports/audio/arts
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/dports/audio/arts/Portfile

    r2970 r2983  
    1 # $Id: Portfile,v 1.13 2003/06/27 18:40:07 ranger Exp $
     1# $Id: Portfile,v 1.14 2003/06/29 14:42:19 ranger Exp $
    22
    33PortSystem 1.0
     
    9393                        current/patch-arts-flow-Makefile.am.diff \
    9494                        current/patch-arts-libltdl-ltdl.c.diff \
     95                        current/patch-arts-libltdl-ltdl.h.diff \
    9596                        current/patch-arts-libltdl-ltdl.m4.diff \
    9697                        current/patch-arts-soundserver-artsd.cc.diff \
     
    121122                --with-qt-dir='${prefix}' --with-qt-includes='${prefix}/include/qt3' \
    122123                --enable-rpath --with-pic --enable-shared=yes --enable-static=no \
    123                 --libexecdir='${prefix}/lib' --with-xinerama --with-pam --enable-final \
     124                --libexecdir='${prefix}/lib' --with-xinerama --with-pam --disable-final \
    124125                --disable-dependency-tracking
    125126
  • trunk/dports/audio/arts/files/current/patch-arts-configure.in.in.diff

    r2795 r2983  
    33RCS file: /home/kde/arts/configure.in.in,v
    44retrieving revision 1.92
    5 diff -u -b -u -r1.92 configure.in.in
     5diff -u -u -r1.92 configure.in.in
    66--- configure.in.in     17 Mar 2003 21:21:50 -0000      1.92
    7 +++ configure.in.in     16 Jun 2003 01:56:40 -0000
    8 @@ -212,6 +212,35 @@
    9    LDFLAGS="$ac_ldflags_save"
    10  ])
    11  
    12 +dnl Check for libesd (for EsounD support)
    13 +AC_DEFUN([AC_CHECK_LIBESD],
    14 +[
    15 +  ac_ldflags_save="$LDFLAGS"
    16 +  ac_CPPFLAGS_save="$CPPFLAGS"
    17 +  LDFLAGS="$all_libraries $LDFLAGS"
    18 +  CPPFLAGS="$CPPFLAGS $all_includes"
    19 +
    20 +  AC_LANG_SAVE
    21 +  AC_LANG_C
    22 +  arts_libaudionas_include=no
    23 +  AC_CHECK_HEADER(esd.h,
    24 +  [
    25 +    arts_libesd_include=yes
    26 +  ])
    27 +  if test "x$arts_libesd_include" = "xyes"; then
    28 +    AC_CHECK_LIB(esd,esd_open_sound,[
    29 +     dnl LDFLAGS in case it's in KDEDIR/lib
    30 +     LIBESD="$LDFLAGS -lesd"
    31 +     AC_DEFINE(HAVE_LIBESD, 1,
    32 +        [Define if you have libesd (required if you want EsounD support)])
    33 +   ])
    34 +  fi
    35 +  AC_SUBST(LIBESD)
    36 +  AC_LANG_RESTORE
    37 +  CPPFLAGS="$ac_CPPFLAGS_save"
    38 +  LDFLAGS="$ac_ldflags_save"
    39 +])
    40 +
    41  dnl libaudiofile is used for loading wave files
    42  AC_DEFUN([AC_CHECK_LIBAUDIOFILE],
    43  [
    44 @@ -312,6 +341,19 @@
     7+++ configure.in.in     28 Jun 2003 17:54:27 -0000
     8@@ -312,6 +312,19 @@
    459 fi
    4610 ])
     
    6226 dnl not required for Linux vs. FreeBSD (for which this test was written), and
    6327 dnl that only the Linux documentation claims that it has an "int" as second
    64 @@ -464,9 +506,11 @@
    65  AC_CHECK_LIBAUDIOIO
    66  AC_CHECK_LIBAUDIONAS
    67  AC_CHECK_LIBESD
    68 +AC_CHECK_LIBESD
     28@@ -467,6 +480,7 @@
    6929 AC_CHECK_LIBAUDIOFILE
    7030 AC_CHECK_SGILIBAUDIO
     
    7434 AC_CHECK_IOCTL_TYPE
    7535 AC_CHECK_X86_FLOAT_INT
    76 @@ -645,6 +689,27 @@
     36@@ -645,6 +659,27 @@
    7737 AC_CHECK_HEADERS(soundcard.h)
    7838 AC_CHECK_LIB(ossaudio, _oss_ioctl, [LIBOSSAUDIO="-lossaudio"])
  • trunk/dports/audio/arts/files/current/patch-arts-libltdl-ltdl.c.diff

    r2795 r2983  
    22===================================================================
    33RCS file: /home/kde/kdelibs/libltdl/ltdl.c,v
    4 retrieving revision 1.23
    5 diff -u -b -u -r1.23 ltdl.c
    6 --- libltdl/ltdl.c      6 Jun 2002 18:52:47 -0000       1.23
    7 +++ libltdl/ltdl.c      16 Jun 2003 01:59:18 -0000
    8 @@ -1544,11 +1544,14 @@
    9    /* try to open the old library first; if it was dlpreopened,
     4retrieving revision 1.24
     5diff -u -u -r1.24 ltdl.c
     6--- libltdl/ltdl.c      26 Jun 2003 23:46:28 -0000      1.24
     7+++ libltdl/ltdl.c      29 Jun 2003 05:08:46 -0000
     8@@ -29,6 +29,10 @@
     9 #  include <config.h>
     10 #endif
     11 
     12+#if HAVE_UNISTD_H
     13+#  include <unistd.h>
     14+#endif
     15+
     16 #if HAVE_STDIO_H
     17 #  include <stdio.h>
     18 #endif
     19@@ -57,19 +61,75 @@
     20 #  include <memory.h>
     21 #endif
     22 
     23-#ifdef _AIX
     24-#include <errno.h>
     25-#include <strings.h>
     26-#include <sys/ldr.h>
     27-#endif /* _AIX */
     28+#if HAVE_ERRNO_H
     29+#  include <errno.h>
     30+#endif
     31+
     32+
     33+#ifndef __WINDOWS__
     34+#  ifdef __WIN32__
     35+#    define __WINDOWS__
     36+#  endif
     37+#endif
     38+
     39+
     40+#undef LT_USE_POSIX_DIRENT
     41+#ifdef HAVE_CLOSEDIR
     42+#  ifdef HAVE_OPENDIR
     43+#    ifdef HAVE_READDIR
     44+#      ifdef HAVE_DIRENT_H
     45+#        define LT_USE_POSIX_DIRENT
     46+#      endif /* HAVE_DIRENT_H */
     47+#    endif /* HAVE_READDIR */
     48+#  endif /* HAVE_OPENDIR */
     49+#endif /* HAVE_CLOSEDIR */
     50+
     51+
     52+#undef LT_USE_WINDOWS_DIRENT_EMULATION
     53+#ifndef LT_USE_POSIX_DIRENT
     54+#  ifdef __WINDOWS__
     55+#    define LT_USE_WINDOWS_DIRENT_EMULATION
     56+#  endif /* __WINDOWS__ */
     57+#endif /* LT_USE_POSIX_DIRENT */
     58+
     59+
     60+#ifdef LT_USE_POSIX_DIRENT
     61+#  include <dirent.h>
     62+#  define LT_D_NAMLEN(dirent) (strlen((dirent)->d_name))
     63+#else
     64+#  ifdef LT_USE_WINDOWS_DIRENT_EMULATION
     65+#    define LT_D_NAMLEN(dirent) (strlen((dirent)->d_name))
     66+#  else
     67+#    define dirent direct
     68+#    define LT_D_NAMLEN(dirent) ((dirent)->d_namlen)
     69+#    if HAVE_SYS_NDIR_H
     70+#      include <sys/ndir.h>
     71+#    endif
     72+#    if HAVE_SYS_DIR_H
     73+#      include <sys/dir.h>
     74+#    endif
     75+#    if HAVE_NDIR_H
     76+#      include <ndir.h>
     77+#    endif
     78+#  endif
     79+#endif
     80+
     81+#if HAVE_ARGZ_H
     82+#  include <argz.h>
     83+#endif
     84+
     85+#if HAVE_ASSERT_H
     86+#  include <assert.h>
     87+#else
     88+#  define assert(arg)  ((void) 0)
     89+#endif
     90 
     91 #include "ltdl.h"
     92 
     93-/* Bah.  We don't want inline.  Needs autoconf check, which we don't want.  */
     94-#ifdef inline
     95-#  undef inline
     96+#if WITH_DMALLOC
     97+#  include <dmalloc.h>
     98 #endif
     99-#define inline
     100+
     101 
     102 
     103 
     104
     105@@ -90,12 +150,41 @@
     106 #  define LT_READTEXT_MODE "r"
     107 #endif
     108 
     109+#ifdef LT_USE_WINDOWS_DIRENT_EMULATION
     110+
     111+#include <windows.h>
     112+
     113+#define dirent lt_dirent
     114+#define DIR lt_DIR
     115+
     116+struct dirent
     117+{
     118+  char d_name[2048];
     119+  int  d_namlen;
     120+};
     121+
     122+typedef struct _DIR
     123+{
     124+  HANDLE hSearch;
     125+  WIN32_FIND_DATA Win32FindData;
     126+  BOOL firsttime;
     127+  struct dirent file_info;
     128+} DIR;
     129 
     130+#endif /* LT_USE_WINDOWS_DIRENT_EMULATION */
     131 
     132 
     133
     134 /* --- MANIFEST CONSTANTS --- */
     135 
     136 
     137+/* Standard libltdl search path environment variable name  */
     138+#undef  LTDL_SEARCHPATH_VAR
     139+#define LTDL_SEARCHPATH_VAR    "LTDL_LIBRARY_PATH"
     140+
     141+/* Standard libtool archive file extension.  */
     142+#undef  LTDL_ARCHIVE_EXT
     143+#define LTDL_ARCHIVE_EXT       ".la"
     144+
     145 /* max. filename length */
     146 #ifndef LT_FILENAME_MAX
     147 #  define LT_FILENAME_MAX      1024
     148@@ -112,6 +201,593 @@
     149 
     150 
     151 
     152
     153+/* --- MEMORY HANDLING --- */
     154+
     155+
     156+/* These are the functions used internally.  In addition to making
     157+   use of the associated function pointers above, they also perform
     158+   error handling.  */
     159+static char   *lt_estrdup      LT_PARAMS((const char *str));
     160+static lt_ptr lt_emalloc       LT_PARAMS((size_t size));
     161+static lt_ptr lt_erealloc      LT_PARAMS((lt_ptr addr, size_t size));
     162+
     163+/* static lt_ptr rpl_realloc   LT_PARAMS((lt_ptr ptr, size_t size)); */
     164+#define rpl_realloc realloc
     165+
     166+/* These are the pointers that can be changed by the caller:  */
     167+LT_GLOBAL_DATA lt_ptr (*lt_dlmalloc)   LT_PARAMS((size_t size))
     168+                       = (lt_ptr (*) LT_PARAMS((size_t))) malloc;
     169+LT_GLOBAL_DATA lt_ptr (*lt_dlrealloc)  LT_PARAMS((lt_ptr ptr, size_t size))
     170+                       = (lt_ptr (*) LT_PARAMS((lt_ptr, size_t))) rpl_realloc;
     171+LT_GLOBAL_DATA void   (*lt_dlfree)     LT_PARAMS((lt_ptr ptr))
     172+                       = (void (*) LT_PARAMS((lt_ptr))) free;
     173+
     174+/* The following macros reduce the amount of typing needed to cast
     175+   assigned memory.  */
     176+#if WITH_DMALLOC
     177+
     178+#define LT_DLMALLOC(tp, n)     ((tp *) xmalloc ((n) * sizeof(tp)))
     179+#define LT_DLREALLOC(tp, p, n) ((tp *) xrealloc ((p), (n) * sizeof(tp)))
     180+#define LT_DLFREE(p)                                           \
     181+       LT_STMT_START { if (p) (p) = (xfree (p), (lt_ptr) 0); } LT_STMT_END
     182+
     183+#define LT_EMALLOC(tp, n)      ((tp *) xmalloc ((n) * sizeof(tp)))
     184+#define LT_EREALLOC(tp, p, n)  ((tp *) xrealloc ((p), (n) * sizeof(tp)))
     185+
     186+#else
     187+
     188+#define LT_DLMALLOC(tp, n)     ((tp *) lt_dlmalloc ((n) * sizeof(tp)))
     189+#define LT_DLREALLOC(tp, p, n) ((tp *) rpl_realloc ((p), (n) * sizeof(tp)))
     190+#define LT_DLFREE(p)                                           \
     191+       LT_STMT_START { if (p) (p) = (lt_dlfree (p), (lt_ptr) 0); } LT_STMT_END
     192+
     193+#define LT_EMALLOC(tp, n)      ((tp *) lt_emalloc ((n) * sizeof(tp)))
     194+#define LT_EREALLOC(tp, p, n)  ((tp *) lt_erealloc ((p), (n) * sizeof(tp)))
     195+
     196+#endif
     197+
     198+#define LT_DLMEM_REASSIGN(p, q)                        LT_STMT_START { \
     199+       if ((p) != (q)) { if (p) lt_dlfree (p); (p) = (q); (q) = 0; }   \
     200+                                               } LT_STMT_END
     201+
     202+
     203
     204+/* --- REPLACEMENT FUNCTIONS --- */
     205+
     206+
     207+#undef strdup
     208+#define strdup rpl_strdup
     209+
     210+static char *strdup LT_PARAMS((const char *str));
     211+
     212+static char *
     213+strdup(str)
     214+     const char *str;
     215+{
     216+  char *tmp = 0;
     217+
     218+  if (str)
     219+    {
     220+      tmp = LT_DLMALLOC (char, 1+ strlen (str));
     221+      if (tmp)
     222+       {
     223+         strcpy(tmp, str);
     224+       }
     225+    }
     226+
     227+  return tmp;
     228+}
     229+
     230+
     231+#if ! HAVE_STRCMP
     232+
     233+#undef strcmp
     234+#define strcmp rpl_strcmp
     235+
     236+static int strcmp LT_PARAMS((const char *str1, const char *str2));
     237+
     238+static int
     239+strcmp (str1, str2)
     240+     const char *str1;
     241+     const char *str2;
     242+{
     243+  if (str1 == str2)
     244+    return 0;
     245+  if (str1 == 0)
     246+    return -1;
     247+  if (str2 == 0)
     248+    return 1;
     249+
     250+  for (;*str1 && *str2; ++str1, ++str2)
     251+    {
     252+      if (*str1 != *str2)
     253+       break;
     254+    }
     255+
     256+  return (int)(*str1 - *str2);
     257+}
     258+#endif
     259+
     260+
     261+#if ! HAVE_STRCHR
     262+
     263+#  if HAVE_INDEX
     264+#    define strchr index
     265+#  else
     266+#    define strchr rpl_strchr
     267+
     268+static const char *strchr LT_PARAMS((const char *str, int ch));
     269+
     270+static const char*
     271+strchr(str, ch)
     272+     const char *str;
     273+     int ch;
     274+{
     275+  const char *p;
     276+
     277+  for (p = str; *p != (char)ch && *p != LT_EOS_CHAR; ++p)
     278+    /*NOWORK*/;
     279+
     280+  return (*p == (char)ch) ? p : 0;
     281+}
     282+
     283+#  endif
     284+#endif /* !HAVE_STRCHR */
     285+
     286+
     287+#if ! HAVE_STRRCHR
     288+
     289+#  if HAVE_RINDEX
     290+#    define strrchr rindex
     291+#  else
     292+#    define strrchr rpl_strrchr
     293+
     294+static const char *strrchr LT_PARAMS((const char *str, int ch));
     295+
     296+static const char*
     297+strrchr(str, ch)
     298+     const char *str;
     299+     int ch;
     300+{
     301+  const char *p, *q = 0;
     302+
     303+  for (p = str; *p != LT_EOS_CHAR; ++p)
     304+    {
     305+      if (*p == (char) ch)
     306+       {
     307+         q = p;
     308+       }
     309+    }
     310+
     311+  return q;
     312+}
     313+
     314+# endif
     315+#endif
     316+
     317+/* NOTE:  Neither bcopy nor the memcpy implementation below can
     318+          reliably handle copying in overlapping areas of memory.  Use
     319+          memmove (for which there is a fallback implmentation below)
     320+         if you need that behaviour.  */
     321+#if ! HAVE_MEMCPY
     322+
     323+#  if HAVE_BCOPY
     324+#    define memcpy(dest, src, size)    bcopy (src, dest, size)
     325+#  else
     326+#    define memcpy rpl_memcpy
     327+
     328+static lt_ptr memcpy LT_PARAMS((lt_ptr dest, const lt_ptr src, size_t size));
     329+
     330+static lt_ptr
     331+memcpy (dest, src, size)
     332+     lt_ptr dest;
     333+     const lt_ptr src;
     334+     size_t size;
     335+{
     336+  size_t i = 0;
     337+
     338+  for (i = 0; i < size; ++i)
     339+    {
     340+      dest[i] = src[i];
     341+    }
     342+
     343+  return dest;
     344+}
     345+
     346+#  endif /* !HAVE_BCOPY */
     347+#endif   /* !HAVE_MEMCPY */
     348+
     349+#if ! HAVE_MEMMOVE
     350+#  define memmove rpl_memmove
     351+
     352+static lt_ptr memmove LT_PARAMS((lt_ptr dest, const lt_ptr src, size_t size));
     353+
     354+static lt_ptr
     355+memmove (dest, src, size)
     356+     lt_ptr dest;
     357+     const lt_ptr src;
     358+     size_t size;
     359+{
     360+  size_t i;
     361+
     362+  if (dest < src)
     363+    for (i = 0; i < size; ++i)
     364+      {
     365+       dest[i] = src[i];
     366+      }
     367+  else if (dest > src)
     368+    for (i = size -1; i >= 0; --i)
     369+      {
     370+       dest[i] = src[i];
     371+      }
     372+
     373+  return dest;
     374+}
     375+
     376+#endif /* !HAVE_MEMMOVE */
     377+
     378+#ifdef LT_USE_WINDOWS_DIRENT_EMULATION
     379+
     380+static void closedir LT_PARAMS((DIR *entry));
     381+
     382+static void
     383+closedir(entry)
     384+  DIR *entry;
     385+{
     386+  assert(entry != (DIR *) NULL);
     387+  FindClose(entry->hSearch);
     388+  lt_dlfree((lt_ptr)entry);
     389+}
     390+
     391+
     392+static DIR * opendir LT_PARAMS((const char *path));
     393+
     394+static DIR*
     395+opendir (path)
     396+  const char *path;
     397+{
     398+  char file_specification[LT_FILENAME_MAX];
     399+  DIR *entry;
     400+
     401+  assert(path != (char *) NULL);
     402+  (void) strncpy(file_specification,path,LT_FILENAME_MAX-1);
     403+  (void) strcat(file_specification,"\\");
     404+  entry = LT_DLMALLOC (DIR,sizeof(DIR));
     405+  if (entry != (DIR *) 0)
     406+    {
     407+      entry->firsttime = TRUE;
     408+      entry->hSearch = FindFirstFile(file_specification,&entry->Win32FindData);
     409+    }
     410+  if (entry->hSearch == INVALID_HANDLE_VALUE)
     411+    {
     412+      (void) strcat(file_specification,"\\*.*");
     413+      entry->hSearch = FindFirstFile(file_specification,&entry->Win32FindData);
     414+      if (entry->hSearch == INVALID_HANDLE_VALUE)
     415+        {
     416+          LT_DLFREE (entry);
     417+          return (DIR *) 0;
     418+        }
     419+    }
     420+  return(entry);
     421+}
     422+
     423+
     424+static struct dirent *readdir LT_PARAMS((DIR *entry));
     425+
     426+static struct dirent *readdir(entry)
     427+  DIR *entry;
     428+{
     429+  int
     430+    status;
     431+
     432+  if (entry == (DIR *) 0)
     433+    return((struct dirent *) 0);
     434+  if (!entry->firsttime)
     435+    {
     436+      status = FindNextFile(entry->hSearch,&entry->Win32FindData);
     437+      if (status == 0)
     438+        return((struct dirent *) 0);
     439+    }
     440+  entry->firsttime = FALSE;
     441+  (void) strncpy(entry->file_info.d_name,entry->Win32FindData.cFileName,
     442+    LT_FILENAME_MAX-1);
     443+  entry->file_info.d_namlen = strlen(entry->file_info.d_name);
     444+  return(&entry->file_info);
     445+}
     446+
     447+#endif /* LT_USE_WINDOWS_DIRENT_EMULATION */
     448+
     449+/* According to Alexandre Oliva <oliva@lsd.ic.unicamp.br>,
     450+    ``realloc is not entirely portable''
     451+   In any case we want to use the allocator supplied by the user without
     452+   burdening them with an lt_dlrealloc function pointer to maintain.
     453+   Instead implement our own version (with known boundary conditions)
     454+   using lt_dlmalloc and lt_dlfree. */
     455+
     456+/* #undef realloc
     457+   #define realloc rpl_realloc
     458+*/
     459+#if 0
     460+  /* You can't (re)define realloc unless you also (re)define malloc.
     461+     Right now, this code uses the size of the *destination* to decide
     462+     how much to copy.  That's not right, but you can't know the size
     463+     of the source unless you know enough about, or wrote malloc.  So
     464+     this code is disabled... */
     465+
     466+static lt_ptr
     467+realloc (ptr, size)
     468+     lt_ptr ptr;
     469+     size_t size;
     470+{
     471+  if (size == 0)
     472+    {
     473+      /* For zero or less bytes, free the original memory */
     474+      if (ptr != 0)
     475+       {
     476+         lt_dlfree (ptr);
     477+       }
     478+
     479+      return (lt_ptr) 0;
     480+    }
     481+  else if (ptr == 0)
     482+    {
     483+      /* Allow reallocation of a NULL pointer.  */
     484+      return lt_dlmalloc (size);
     485+    }
     486+  else
     487+    {
     488+      /* Allocate a new block, copy and free the old block.  */
     489+      lt_ptr mem = lt_dlmalloc (size);
     490+
     491+      if (mem)
     492+       {
     493+         memcpy (mem, ptr, size);
     494+         lt_dlfree (ptr);
     495+       }
     496+
     497+      /* Note that the contents of PTR are not damaged if there is
     498+        insufficient memory to realloc.  */
     499+      return mem;
     500+    }
     501+}
     502+#endif
     503+
     504+
     505+#if ! HAVE_ARGZ_APPEND
     506+#  define argz_append rpl_argz_append
     507+
     508+static error_t argz_append LT_PARAMS((char **pargz, size_t *pargz_len,
     509+                                       const char *buf, size_t buf_len));
     510+
     511+static error_t
     512+argz_append (pargz, pargz_len, buf, buf_len)
     513+     char **pargz;
     514+     size_t *pargz_len;
     515+     const char *buf;
     516+     size_t buf_len;
     517+{
     518+  size_t argz_len;
     519+  char  *argz;
     520+
     521+  assert (pargz);
     522+  assert (pargz_len);
     523+  assert ((*pargz && *pargz_len) || (!*pargz && !*pargz_len));
     524+
     525+  /* If nothing needs to be appended, no more work is required.  */
     526+  if (buf_len == 0)
     527+    return 0;
     528+
     529+  /* Ensure there is enough room to append BUF_LEN.  */
     530+  argz_len = *pargz_len + buf_len;
     531+  argz = LT_DLREALLOC (char, *pargz, argz_len);
     532+  if (!argz)
     533+    return ENOMEM;
     534+
     535+  /* Copy characters from BUF after terminating '\0' in ARGZ.  */
     536+  memcpy (argz + *pargz_len, buf, buf_len);
     537+
     538+  /* Assign new values.  */
     539+  *pargz = argz;
     540+  *pargz_len = argz_len;
     541+
     542+  return 0;
     543+}
     544+#endif /* !HAVE_ARGZ_APPEND */
     545+
     546+
     547+#if ! HAVE_ARGZ_CREATE_SEP
     548+#  define argz_create_sep rpl_argz_create_sep
     549+
     550+static error_t argz_create_sep LT_PARAMS((const char *str, int delim,
     551+                                           char **pargz, size_t *pargz_len));
     552+
     553+static error_t
     554+argz_create_sep (str, delim, pargz, pargz_len)
     555+     const char *str;
     556+     int delim;
     557+     char **pargz;
     558+     size_t *pargz_len;
     559+{
     560+  size_t argz_len;
     561+  char *argz = 0;
     562+
     563+  assert (str);
     564+  assert (pargz);
     565+  assert (pargz_len);
     566+
     567+  /* Make a copy of STR, but replacing each occurence of
     568+     DELIM with '\0'.  */
     569+  argz_len = 1+ LT_STRLEN (str);
     570+  if (argz_len)
     571+    {
     572+      const char *p;
     573+      char *q;
     574+
     575+      argz = LT_DLMALLOC (char, argz_len);
     576+      if (!argz)
     577+       return ENOMEM;
     578+
     579+      for (p = str, q = argz; *p != LT_EOS_CHAR; ++p)
     580+       {
     581+         if (*p == delim)
     582+           {
     583+             /* Ignore leading delimiters, and fold consecutive
     584+                delimiters in STR into a single '\0' in ARGZ.  */
     585+             if ((q > argz) && (q[-1] != LT_EOS_CHAR))
     586+               *q++ = LT_EOS_CHAR;
     587+             else
     588+               --argz_len;
     589+           }
     590+         else
     591+           *q++ = *p;
     592+       }
     593+      /* Copy terminating LT_EOS_CHAR.  */
     594+      *q = *p;
     595+    }
     596+
     597+  /* If ARGZ_LEN has shrunk to nothing, release ARGZ's memory.  */
     598+  if (!argz_len)
     599+    LT_DLFREE (argz);
     600+
     601+  /* Assign new values.  */
     602+  *pargz = argz;
     603+  *pargz_len = argz_len;
     604+
     605+  return 0;
     606+}
     607+#endif /* !HAVE_ARGZ_CREATE_SEP */
     608+
     609+
     610+#if ! HAVE_ARGZ_INSERT
     611+#  define argz_insert rpl_argz_insert
     612+
     613+static error_t argz_insert LT_PARAMS((char **pargz, size_t *pargz_len,
     614+                                       char *before, const char *entry));
     615+
     616+static error_t
     617+argz_insert (pargz, pargz_len, before, entry)
     618+     char **pargz;
     619+     size_t *pargz_len;
     620+     char *before;
     621+     const char *entry;
     622+{
     623+  assert (pargz);
     624+  assert (pargz_len);
     625+  assert (entry && *entry);
     626+
     627+  /* No BEFORE address indicates ENTRY should be inserted after the
     628+     current last element.  */
     629+  if (!before)
     630+    return argz_append (pargz, pargz_len, entry, 1+ LT_STRLEN (entry));
     631+
     632+  /* This probably indicates a programmer error, but to preserve
     633+     semantics, scan back to the start of an entry if BEFORE points
     634+     into the middle of it.  */
     635+  while ((before > *pargz) && (before[-1] != LT_EOS_CHAR))
     636+    --before;
     637+
     638+  {
     639+    size_t entry_len   = 1+ LT_STRLEN (entry);
     640+    size_t argz_len    = *pargz_len + entry_len;
     641+    size_t offset      = before - *pargz;
     642+    char   *argz       = LT_DLREALLOC (char, *pargz, argz_len);
     643+
     644+    if (!argz)
     645+      return ENOMEM;
     646+
     647+    /* Make BEFORE point to the equivalent offset in ARGZ that it
     648+       used to have in *PARGZ incase realloc() moved the block.  */
     649+    before = argz + offset;
     650+
     651+    /* Move the ARGZ entries starting at BEFORE up into the new
     652+       space at the end -- making room to copy ENTRY into the
     653+       resulting gap.  */
     654+    memmove (before + entry_len, before, *pargz_len - offset);
     655+    memcpy  (before, entry, entry_len);
     656+
     657+    /* Assign new values.  */
     658+    *pargz = argz;
     659+    *pargz_len = argz_len;
     660+  }
     661+
     662+  return 0;
     663+}
     664+#endif /* !HAVE_ARGZ_INSERT */
     665+
     666+
     667+#if ! HAVE_ARGZ_NEXT
     668+#  define argz_next rpl_argz_next
     669+
     670+static char *argz_next LT_PARAMS((char *argz, size_t argz_len,
     671+                                   const char *entry));
     672+
     673+static char *
     674+argz_next (argz, argz_len, entry)
     675+     char *argz;
     676+     size_t argz_len;
     677+     const char *entry;
     678+{
     679+  assert ((argz && argz_len) || (!argz && !argz_len));
     680+
     681+  if (entry)
     682+    {
     683+      /* Either ARGZ/ARGZ_LEN is empty, or ENTRY points into an address
     684+        within the ARGZ vector.  */
     685+      assert ((!argz && !argz_len)
     686+             || ((argz <= entry) && (entry < (argz + argz_len))));
     687+
     688+      /* Move to the char immediately after the terminating
     689+        '\0' of ENTRY.  */
     690+      entry = 1+ strchr (entry, LT_EOS_CHAR);
     691+
     692+      /* Return either the new ENTRY, or else NULL if ARGZ is
     693+        exhausted.  */
     694+      return (entry >= argz + argz_len) ? 0 : (char *) entry;
     695+    }
     696+  else
     697+    {
     698+      /* This should probably be flagged as a programmer error,
     699+        since starting an argz_next loop with the iterator set
     700+        to ARGZ is safer.  To preserve semantics, handle the NULL
     701+        case by returning the start of ARGZ (if any).  */
     702+      if (argz_len > 0)
     703+       return argz;
     704+      else
     705+       return 0;
     706+    }
     707+}
     708+#endif /* !HAVE_ARGZ_NEXT */
     709+
     710+
     711+
     712+#if ! HAVE_ARGZ_STRINGIFY
     713+#  define argz_stringify rpl_argz_stringify
     714+
     715+static void argz_stringify LT_PARAMS((char *argz, size_t argz_len,
     716+                                      int sep));
     717+
     718+static void
     719+argz_stringify (argz, argz_len, sep)
     720+     char *argz;
     721+     size_t argz_len;
     722+     int sep;
     723+{
     724+  assert ((argz && argz_len) || (!argz && !argz_len));
     725+
     726+  if (sep)
     727+    {
     728+      --argz_len;              /* don't stringify the terminating EOS */
     729+      while (--argz_len > 0)
     730+       {
     731+         if (argz[argz_len] == LT_EOS_CHAR)
     732+           argz[argz_len] = sep;
     733+       }
     734+    }
     735+}
     736+#endif /* !HAVE_ARGZ_STRINGIFY */
     737+
     738+
     739+
     740+
     741
     742 /* --- TYPE DEFINITIONS -- */
     743 
     744 
     745@@ -128,7 +804,7 @@
     746 
     747 
     748 /* Extract the diagnostic strings from the error table macro in the same
     749-   order as the enumberated indices in ltdl.h. */
     750+   order as the enumerated indices in ltdl.h. */
     751 
     752 static const char *lt_dlerror_strings[] =
     753   {
     754@@ -169,10 +845,6 @@
     755 #define LT_DLSET_FLAG(handle, flag) ((handle)->flags |= (flag))
     756 
     757 #define LT_DLRESIDENT_FLAG         (0x01 << 0)
     758-#ifdef _AIX
     759-#define LT_DLNOTFOUND_FLAG         (0x01 << 1) /* may be linked statically */
     760-#define LT_DLMEMBER_FLAG           RTLD_MEMBER
     761-#endif /* _AIX */
     762 /* ...add more flags here... */
     763 
     764 #define LT_DLIS_RESIDENT(handle)    LT_DLGET_FLAG(handle, LT_DLRESIDENT_FLAG)
     765@@ -181,6 +853,7 @@
     766 #define LT_DLSTRERROR(name)    lt_dlerror_strings[LT_CONC(LT_ERROR_,name)]
     767 
     768 static const char      objdir[]                = LTDL_OBJDIR;
     769+static const char      archive_ext[]           = LTDL_ARCHIVE_EXT;
     770 #ifdef LTDL_SHLIB_EXT
     771 static const char      shlib_ext[]             = LTDL_SHLIB_EXT;
     772 #endif
     773@@ -194,29 +867,33 @@
     774 /* --- MUTEX LOCKING --- */
     775 
     776 
     777-/* Macros to make it easier to run the lock functions only if they have
     778+/* Macros to make it easier to run the lock functions only if they have
     779    been registered.  The reason for the complicated lock macro is to
     780-   ensure that the stored error message from the last error is not
     781+   ensure that the stored error message from the last error is not
     782    accidentally erased if the current function doesn't generate an
     783    error of its own.  */
     784-#define MUTEX_LOCK()                           LT_STMT_START { \
     785-       if (mutex_lock) (*mutex_lock)();        } LT_STMT_END
     786-#define MUTEX_UNLOCK()                         LT_STMT_START { \
     787-       if (mutex_unlock) (*mutex_unlock)();    } LT_STMT_END
     788-#define MUTEX_SETERROR(errormsg)               LT_STMT_START { \
     789-       if (mutex_seterror) (*mutex_seterror) (errormsg);       \
     790-       else last_error = (errormsg);           } LT_STMT_END
     791-#define MUTEX_GETERROR(errormsg)               LT_STMT_START { \
     792-       if (mutex_seterror) errormsg = (*mutex_geterror)();     \
     793-       else (errormsg) = last_error;           } LT_STMT_END
     794+#define LT_DLMUTEX_LOCK()                      LT_STMT_START { \
     795+       if (lt_dlmutex_lock_func) (*lt_dlmutex_lock_func)();    \
     796+                                               } LT_STMT_END
     797+#define LT_DLMUTEX_UNLOCK()                    LT_STMT_START { \
     798+       if (lt_dlmutex_unlock_func) (*lt_dlmutex_unlock_func)();\
     799+                                               } LT_STMT_END
     800+#define LT_DLMUTEX_SETERROR(errormsg)          LT_STMT_START { \
     801+       if (lt_dlmutex_seterror_func)                           \
     802+               (*lt_dlmutex_seterror_func) (errormsg);         \
     803+       else    lt_dllast_error = (errormsg);   } LT_STMT_END
     804+#define LT_DLMUTEX_GETERROR(errormsg)          LT_STMT_START { \
     805+       if (lt_dlmutex_seterror_func)                           \
     806+               (errormsg) = (*lt_dlmutex_geterror_func) ();    \
     807+       else    (errormsg) = lt_dllast_error;   } LT_STMT_END
     808 
     809 /* The mutex functions stored here are global, and are necessarily the
     810    same for all threads that wish to share access to libltdl.  */
     811-static lt_dlmutex_lock     *mutex_lock     = 0;
     812-static lt_dlmutex_unlock   *mutex_unlock   = 0;
     813-static lt_dlmutex_seterror *mutex_seterror = 0;
     814-static lt_dlmutex_geterror *mutex_geterror = 0;
     815-static const char          *last_error     = 0;
     816+static lt_dlmutex_lock     *lt_dlmutex_lock_func     = 0;
     817+static lt_dlmutex_unlock   *lt_dlmutex_unlock_func   = 0;
     818+static lt_dlmutex_seterror *lt_dlmutex_seterror_func = 0;
     819+static lt_dlmutex_geterror *lt_dlmutex_geterror_func = 0;
     820+static const char          *lt_dllast_error          = 0;
     821 
     822 
     823 /* Either set or reset the mutex functions.  Either all the arguments must
     824@@ -230,295 +907,129 @@
     825      lt_dlmutex_seterror *seterror;
     826      lt_dlmutex_geterror *geterror;
     827 {
     828-  lt_dlmutex_unlock *old_unlock = unlock;
     829-  int               errors     = 0;
     830-
     831-  /* Lock using the old lock() callback, if any.  */
     832-  MUTEX_LOCK ();
     833-
     834-  if ((lock && unlock && seterror && geterror)
     835-      || !(lock || unlock || seterror || geterror))
     836-    {
     837-      mutex_lock     = lock;
     838-      mutex_unlock   = unlock;
     839-      mutex_geterror = geterror;
     840-    }
     841-  else
     842-    {
     843-      MUTEX_SETERROR (LT_DLSTRERROR (INVALID_MUTEX_ARGS));
     844-      ++errors;
     845-    }
     846-
     847-  /* Use the old unlock() callback we saved earlier, if any.  Otherwise
     848-     record any errors using internal storage.  */
     849-  if (old_unlock)
     850-    (*old_unlock) ();
     851-
     852-  /* Return the number of errors encountered during the execution of
     853-     this function.  */
     854-  return errors;
     855-}
     856-
     857-
     858-
     859-
     860
     861-/* --- MEMORY HANDLING --- */
     862-
     863-
     864-LT_GLOBAL_DATA    lt_ptr       (*lt_dlmalloc)  LT_PARAMS((size_t size))
     865-                                   = (lt_ptr (*) LT_PARAMS((size_t))) malloc;
     866-LT_GLOBAL_DATA    void         (*lt_dlfree)    LT_PARAMS((lt_ptr ptr))
     867-                                   = (void (*) LT_PARAMS((lt_ptr))) free;
     868-
     869-static           lt_ptr        rpl_realloc     LT_PARAMS((lt_ptr ptr,
     870-                                                          size_t size));
     871-
     872-#define LT_DLMALLOC(tp, n)     ((tp *) lt_dlmalloc ((n) * sizeof(tp)))
     873-#define LT_DLREALLOC(tp, p, n) ((tp *) rpl_realloc ((p), (n) * sizeof(tp)))
     874-#define LT_DLFREE(p)                                           \
     875-       LT_STMT_START { if (p) (p) = (lt_dlfree (p), (lt_ptr) 0); } LT_STMT_END
     876-
     877-#define LT_DLMEM_REASSIGN(p, q)                        LT_STMT_START { \
     878-       if ((p) != (q)) { lt_dlfree (p); (p) = (q); }           \
     879-                                               } LT_STMT_END
     880-
     881-
     882-
     883
     884-/* --- ERROR MESSAGES --- */
     885-
     886-
     887-static const char    **user_error_strings      = 0;
     888-static int             errorcount              = LT_ERROR_MAX;
     889-
     890-int
     891-lt_dladderror (diagnostic)
     892-     const char *diagnostic;
     893-{
     894-  int          _index   = 0;
     895-  int          result   = -1;
     896-  const char  **temp     = (const char **) 0;
     897-
     898-  MUTEX_LOCK ();
     899-
     900-  _index        = errorcount - LT_ERROR_MAX;
     901-  temp = LT_DLREALLOC (const char *, user_error_strings, 1 + _index);
     902-  if (temp == 0)
     903-    {
     904-      MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     905-    }
     906-  else
     907-    {
     908-      user_error_strings       = temp;
     909-      user_error_strings[_index] = diagnostic;
     910-      result                   = errorcount++;
     911-    }
     912-
     913-  MUTEX_UNLOCK ();
     914-
     915-  return result;
     916-}
     917-
     918-int
     919-lt_dlseterror (_index)
     920-     int _index;
     921-{
     922-  int          errors   = 0;
     923-
     924-  MUTEX_LOCK ();
     925-
     926-  if (_index >= errorcount || _index < 0)
     927-    {
     928-      /* Ack!  Error setting the error message! */
     929-      MUTEX_SETERROR (LT_DLSTRERROR (INVALID_ERRORCODE));
     930-      ++errors;
     931-    }
     932-  else if (_index < LT_ERROR_MAX)
     933-    {
     934-      /* No error setting the error message! */
     935-      MUTEX_SETERROR (lt_dlerror_strings[errorcount]);
     936-    }
     937-  else
     938-    {
     939-      /* No error setting the error message! */
     940-      MUTEX_SETERROR (user_error_strings[errorcount - LT_ERROR_MAX]);
     941-    }
     942-
     943-  MUTEX_UNLOCK ();
     944-
     945-  return errors;
     946-}
     947-
     948-
     949-
     950-
     951
     952-/* --- REPLACEMENT FUNCTIONS --- */
     953-
     954-
     955-#undef strdup
     956-#define strdup rpl_strdup
     957-
     958-static inline char *
     959-strdup(str)
     960-     const char *str;
     961-{
     962-  char *tmp = 0;
     963-
     964-  if (str)
     965-    {
     966-      tmp = LT_DLMALLOC (char, 1+ strlen (str));
     967-      if (tmp)
     968-       {
     969-         strcpy(tmp, str);
     970-       }
     971-    }
     972-
     973-  return tmp;
     974-}
     975-
     976-
     977-#if ! HAVE_STRCMP
     978-
     979-#undef strcmp
     980-#define strcmp rpl_strcmp
     981-
     982-static inline int
     983-strcmp (str1, str2)
     984-     const char *str1;
     985-     const char *str2;
     986-{
     987-  if (str1 == str2)
     988-    return 0;
     989-  if (str1 == 0)
     990-    return -1;
     991-  if (str2 == 0)
     992-    return 1;
     993+  lt_dlmutex_unlock *old_unlock = unlock;
     994+  int               errors     = 0;
     995 
     996-  for (;*str1 && *str2; ++str1, ++str2)
     997+  /* Lock using the old lock() callback, if any.  */
     998+  LT_DLMUTEX_LOCK ();
     999+
     1000+  if ((lock && unlock && seterror && geterror)
     1001+      || !(lock || unlock || seterror || geterror))
     1002     {
     1003-      if (*str1 != *str2)
     1004-       break;
     1005+      lt_dlmutex_lock_func     = lock;
     1006+      lt_dlmutex_unlock_func   = unlock;
     1007+      lt_dlmutex_geterror_func = geterror;
     1008+    }
     1009+  else
     1010+    {
     1011+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_MUTEX_ARGS));
     1012+      ++errors;
     1013     }
     1014 
     1015-  return (int)(*str1 - *str2);
     1016-}
     1017-#endif
     1018-
     1019+  /* Use the old unlock() callback we saved earlier, if any.  Otherwise
     1020+     record any errors using internal storage.  */
     1021+  if (old_unlock)
     1022+    (*old_unlock) ();
     1023 
     1024-#if ! HAVE_STRCHR
     1025+  /* Return the number of errors encountered during the execution of
     1026+     this function.  */
     1027+  return errors;
     1028+}
     1029 
     1030-#  if HAVE_INDEX
     1031-#    define strchr index
     1032-#  else
     1033-#    define strchr rpl_strchr
     1034 
     1035-static inline const char*
     1036-strchr(str, ch)
     1037-     const char *str;
     1038-     int ch;
     1039-{
     1040-  const char *p;
     1041 
     1042-  for (p = str; *p != (char)ch && *p != '\0'; ++p)
     1043-    /*NOWORK*/;
     1044+
     1045
     1046+/* --- ERROR HANDLING --- */
     1047 
     1048-  return (*p == (char)ch) ? p : 0;
     1049-}
     1050 
     1051-#  endif
     1052-#endif /* !HAVE_STRCHR */
     1053+static const char    **user_error_strings      = 0;
     1054+static int             errorcount              = LT_ERROR_MAX;
     1055 
     1056-#if ! HAVE_STRRCHR
     1057+int
     1058+lt_dladderror (diagnostic)
     1059+     const char *diagnostic;
     1060+{
     1061+  int          errindex = 0;
     1062+  int          result   = -1;
     1063+  const char  **temp     = (const char **) 0;
     1064 
     1065-#  if HAVE_RINDEX
     1066-#    define strrchr rindex
     1067-#  else
     1068-#    define strrchr rpl_strrchr
     1069+  assert (diagnostic);
     1070 
     1071-static inline const char*
     1072-strrchr(str, ch)
     1073-     const char *str;
     1074-     int ch;
     1075-{
     1076-  const char *p, *q = 0;
     1077+  LT_DLMUTEX_LOCK ();
     1078 
     1079-  for (p = str; *p != '\0'; ++p)
     1080+  errindex = errorcount - LT_ERROR_MAX;
     1081+  temp = LT_EREALLOC (const char *, user_error_strings, 1 + errindex);
     1082+  if (temp)
     1083     {
     1084-      if (*p == (char) ch)
     1085-       {
     1086-         q = p;
     1087-       }
     1088+      user_error_strings               = temp;
     1089+      user_error_strings[errindex]     = diagnostic;
     1090+      result                           = errorcount++;
     1091     }
     1092 
     1093-  return q;
     1094-}
     1095-
     1096-# endif
     1097-#endif
     1098-
     1099-/* NOTE:  Neither bcopy nor the memcpy implementation below can
     1100-          reliably handle copying in overlapping areas of memory, so
     1101-          do not rely on this behaviour when invoking memcpy later.  */
     1102-#if ! HAVE_MEMCPY
     1103+  LT_DLMUTEX_UNLOCK ();
     1104 
     1105-#  if HAVE_BCOPY
     1106-#    define memcpy(dest, src, size)    bcopy (src, dest, size)
     1107-#  else
     1108-#    define memcpy rpl_memcpy
     1109+  return result;
     1110+}
     1111 
     1112-static inline char *
     1113-memcpy (dest, src, size)
     1114-     char *dest;
     1115-     const char *src;
     1116-     size_t size;
     1117+int
     1118+lt_dlseterror (errindex)
     1119+     int errindex;
     1120 {
     1121-  size_t i = 0;
     1122+  int          errors   = 0;
     1123 
     1124-  for (i = 0; i < size; ++i)
     1125+  LT_DLMUTEX_LOCK ();
     1126+
     1127+  if (errindex >= errorcount || errindex < 0)
     1128     {
     1129-      dest[i] = src[i];
     1130+      /* Ack!  Error setting the error message! */
     1131+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_ERRORCODE));
     1132+      ++errors;
     1133+    }
     1134+  else if (errindex < LT_ERROR_MAX)
     1135+    {
     1136+      /* No error setting the error message! */
     1137+      LT_DLMUTEX_SETERROR (lt_dlerror_strings[errindex]);
     1138+    }
     1139+  else
     1140+    {
     1141+      /* No error setting the error message! */
     1142+      LT_DLMUTEX_SETERROR (user_error_strings[errindex - LT_ERROR_MAX]);
     1143     }
     1144 
     1145-  return dest;
     1146-}
     1147+  LT_DLMUTEX_UNLOCK ();
     1148 
     1149-#  endif
     1150-#endif
     1151+  return errors;
     1152+}
     1153 
     1154-/* According to Alexandre Oliva <oliva@lsd.ic.unicamp.br>,
     1155-    ``realloc is not entirely portable''
     1156-   In any case we want to use the allocator supplied by the user without
     1157-   burdening them with an lt_dlrealloc function pointer to maintain.
     1158-   Instead implement our own version (with known boundary conditions)
     1159-   using lt_dlmalloc and lt_dlfree. */
     1160 static lt_ptr
     1161-rpl_realloc (ptr, size)
     1162-     lt_ptr ptr;
     1163+lt_emalloc (size)
     1164      size_t size;
     1165 {
     1166-  if (size < 1)
     1167-    {
     1168-      /* For zero or less bytes, free the original memory */
     1169-      if (ptr != 0)
     1170-       {
     1171-         lt_dlfree (ptr);
     1172-       }
     1173+  lt_ptr mem = lt_dlmalloc (size);
     1174+  if (size && !mem)
     1175+    LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     1176+  return mem;
     1177+}
     1178 
     1179-      return (lt_ptr) 0;
     1180-    }
     1181-  else if (ptr == 0)
     1182-    {
     1183-      /* Allow reallocation of a NULL pointer.  */
     1184-      return lt_dlmalloc (size);
     1185-    }
     1186-  else
     1187-    {
     1188-      /* Allocate a new block, copy and free the old block.  */
     1189-      lt_ptr mem = (lt_ptr) realloc (ptr, size);
     1190+static lt_ptr
     1191+lt_erealloc (addr, size)
     1192+     lt_ptr addr;
     1193+     size_t size;
     1194+{
     1195+  lt_ptr mem = realloc (addr, size);
     1196+  if (size && !mem)
     1197+    LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     1198+  return mem;
     1199+}
     1200 
     1201-      /* Note that the contents of PTR are not damaged if there is
     1202-        insufficient memory to realloc.  */
     1203-      return mem;
     1204-    }
     1205+static char *
     1206+lt_estrdup (str)
     1207+     const char *str;
     1208+{
     1209+  char *copy = strdup (str);
     1210+  if (LT_STRLEN (str) && !copy)
     1211+    LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     1212+  return copy;
     1213 }
     1214 
     1215 
     1216@@ -526,11 +1037,8 @@
     1217 
     1218
     1219 /* --- DLOPEN() INTERFACE LOADER --- */
     1220 
     1221-/* The Cygwin dlopen implementation prints a spurious error message to
     1222-   stderr if its call to LoadLibrary() fails for any reason.  We can
     1223-   mitigate this by not using the Cygwin implementation, and falling
     1224-   back to our own LoadLibrary() wrapper. */
     1225-#if HAVE_LIBDL && !defined(__CYGWIN__)
     1226+
     1227+#if HAVE_LIBDL
     1228 
     1229 /* dynamic linking with dlopen/dlsym */
     1230 
     1231@@ -538,6 +1046,10 @@
     1232 #  include <dlfcn.h>
     1233 #endif
     1234 
     1235+#if HAVE_SYS_DL_H
     1236+#  include <sys/dl.h>
     1237+#endif
     1238+
     1239 #ifdef RTLD_GLOBAL
     1240 #  define LT_GLOBAL            RTLD_GLOBAL
     1241 #else
     1242@@ -579,40 +1091,16 @@
     1243 #  define DLERROR(arg) LT_DLSTRERROR (arg)
     1244 #endif
     1245 
     1246-int lt_dlopen_flag = LT_LAZY_OR_NOW;
     1247-
     1248-#ifdef _AIX
     1249-/*------------------------------------------------------------------*/
     1250-/* implementations found at the end                                 */
     1251-/*------------------------------------------------------------------*/
     1252-
     1253-static void
     1254-sys_dl_init( );
     1255-
     1256-static lt_dlhandle
     1257-sys_dl_search_by_name( const char* name );
     1258-
     1259-static void
     1260-sys_dl_not_found_entry( const char* tmp );
     1261-#endif /* _AIX */
     1262-
     1263 static lt_module
     1264 sys_dl_open (loader_data, filename)
     1265      lt_user_data loader_data;
     1266      const char *filename;
     1267 {
     1268-  lt_module module;
     1269-#ifdef _AIX
     1270-  /* If the basename is of the form "libname.a(member)",
     1271-     set the appropriate flag. */
     1272-  if (strrchr(filename, '('))
     1273-    lt_dlopen_flag |= LT_DLMEMBER_FLAG;
     1274-#endif
     1275-  module = dlopen (filename, lt_dlopen_flag);
     1276+  lt_module   module   = dlopen (filename, LT_GLOBAL | LT_LAZY_OR_NOW);
     1277 
     1278   if (!module)
     1279     {
     1280-      MUTEX_SETERROR (DLERROR (CANNOT_OPEN));
     1281+      LT_DLMUTEX_SETERROR (DLERROR (CANNOT_OPEN));
     1282     }
     1283 
     1284   return module;
     1285@@ -627,7 +1115,7 @@
     1286 
     1287   if (dlclose (module) != 0)
     1288     {
     1289-      MUTEX_SETERROR (DLERROR (CANNOT_CLOSE));
     1290+      LT_DLMUTEX_SETERROR (DLERROR (CANNOT_CLOSE));
     1291       ++errors;
     1292     }
     1293 
     1294@@ -644,7 +1132,7 @@
     1295 
     1296   if (!address)
     1297     {
     1298-      MUTEX_SETERROR (DLERROR (SYMBOL_NOT_FOUND));
     1299+      LT_DLMUTEX_SETERROR (DLERROR (SYMBOL_NOT_FOUND));
     1300     }
     1301 
     1302   return address;
     1303@@ -659,8 +1147,7 @@
     1304 #  endif
     1305     sys_dl_open, sys_dl_close, sys_dl_sym, 0, 0 };
     1306 
     1307-#else
     1308-int lt_dlopen_flag = 0;
     1309+
     1310 #endif /* HAVE_LIBDL */
     1311 
     1312 
     1313@@ -720,20 +1207,33 @@
     1314      lt_user_data loader_data;
     1315      const char *filename;
     1316 {
     1317-  /* A NULL handle is used to get symbols from self and everything
     1318-     else already loaded that was exported with -E compiler flag.  */
     1319-  lt_module module = (lt_module) 0;
     1320+  static shl_t self = (shl_t) 0;
     1321+  lt_module module = shl_load (filename, LT_BIND_FLAGS, 0L);
     1322 
     1323-  if (filename)
     1324+  /* Since searching for a symbol against a NULL module handle will also
     1325+     look in everything else that was already loaded and exported with
     1326+     the -E compiler flag, we always cache a handle saved before any
     1327+     modules are loaded.  */
     1328+  if (!self)
     1329+    {
     1330+      lt_ptr address;
     1331+      shl_findsym (&self, "main", TYPE_UNDEFINED, &address);
     1332+    }
     1333+
     1334+  if (!filename)
     1335+    {
     1336+      module = self;
     1337+    }
     1338+  else
     1339     {
     1340       module = shl_load (filename, LT_BIND_FLAGS, 0L);
     1341 
     1342       if (!module)
     1343        {
     1344-         MUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN));
     1345+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN));
     1346        }
     1347     }
     1348
     1349+
     1350   return module;
     1351 }
     1352 
     1353@@ -746,7 +1246,7 @@
     1354 
     1355   if (module && (shl_unload ((shl_t) (module)) != 0))
     1356     {
     1357-      MUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE));
     1358+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE));
     1359       ++errors;
     1360     }
     1361 
     1362@@ -759,23 +1259,20 @@
     1363      lt_module module;
     1364      const char *symbol;
     1365 {
     1366-  int    is_module_self = (module == (lt_module) 0);
     1367-  lt_ptr address        = 0;
     1368+  lt_ptr address = 0;
     1369 
     1370-  /* shl_findsym considers zero valued MODULE as an indicator to search
     1371-     for a symbol among all loaded (and exported) symbols including those
     1372-     in the main executable.  However, it sets MODULE to a valid module
     1373-     address which breaks the semantics of libltdl's module management.  */
     1374-  if (shl_findsym ((shl_t*) &module, symbol, TYPE_UNDEFINED, &address) == 0)
     1375+  /* sys_shl_open should never return a NULL module handle */
     1376+  if (module == (lt_module) 0)
     1377+  {
     1378+    LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE));
     1379+  }
     1380+  else if (!shl_findsym((shl_t*) &module, symbol, TYPE_UNDEFINED, &address))
     1381     {
     1382       if (!address)
     1383        {
     1384-         MUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND));
     1385+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND));
     1386        }
     1387     }
     1388
     1389-  if (is_module_self)
     1390-    module = (lt_module) 0;
     1391 
     1392   return address;
     1393 }
     1394@@ -827,21 +1324,18 @@
     1395   if (ext)
     1396     {
     1397       /* FILENAME already has an extension. */
     1398-      searchname = strdup (filename);
     1399+      searchname = lt_estrdup (filename);
     1400     }
     1401   else
     1402     {
     1403       /* Append a `.' to stop Windows from adding an
     1404         implicit `.dll' extension. */
     1405-      searchname = LT_DLMALLOC (char, 2+ strlen (filename));
     1406-      if (!searchname)
     1407-       {
     1408-         MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     1409-         return 0;
     1410-       }
     1411-      strcpy (searchname, filename);
     1412-      strcat (searchname, ".");
     1413+      searchname = LT_EMALLOC (char, 2+ LT_STRLEN (filename));
     1414+      if (searchname)
     1415+       sprintf (searchname, "%s.", filename);
     1416     }
     1417+  if (!searchname)
     1418+    return 0;
     1419 
     1420 #if __CYGWIN__
     1421   {
     1422@@ -862,7 +1356,7 @@
     1423      We check whether LoadLibrary is returning a handle to
     1424      an already loaded module, and simulate failure if we
     1425      find one. */
     1426-  MUTEX_LOCK ();
     1427+  LT_DLMUTEX_LOCK ();
     1428   cur = handles;
     1429   while (cur)
     1430     {
     1431@@ -879,11 +1373,11 @@
     1432 
     1433       cur = cur->next;
     1434   }
     1435-  MUTEX_UNLOCK ();
     1436+  LT_DLMUTEX_UNLOCK ();
     1437 
     1438   if (cur || !module)
     1439     {
     1440-      MUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN));
     1441+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN));
     1442       module = 0;
     1443     }
     1444 
     1445@@ -899,7 +1393,7 @@
     1446 
     1447   if (FreeLibrary(module) == 0)
     1448     {
     1449-      MUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE));
     1450+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE));
     1451       ++errors;
     1452     }
     1453 
     1454@@ -916,7 +1410,7 @@
     1455 
     1456   if (!address)
     1457     {
     1458-      MUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND));
     1459+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND));
     1460     }
     1461 
     1462   return address;
     1463@@ -961,7 +1455,7 @@
     1464 
     1465   if (image <= 0)
     1466     {
     1467-      MUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN));
     1468+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN));
     1469       image = 0;
     1470     }
     1471 
     1472@@ -977,7 +1471,7 @@
     1473 
     1474   if (unload_add_on ((image_id) module) != B_OK)
     1475     {
     1476-      MUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE));
     1477+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE));
     1478       ++errors;
     1479     }
     1480 
     1481@@ -995,7 +1489,7 @@
     1482 
     1483   if (get_image_symbol (image, symbol, B_SYMBOL_TYPE_ANY, address) != B_OK)
     1484     {
     1485-      MUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND));
     1486+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND));
     1487       address = 0;
     1488     }
     1489 
     1490@@ -1014,79 +1508,417 @@
     1491 /* --- DLD_LINK() INTERFACE LOADER --- */
     1492 
     1493 
     1494-#if HAVE_DLD
     1495+#if HAVE_DLD
     1496+
     1497+/* dynamic linking with dld */
     1498+
     1499+#if HAVE_DLD_H
     1500+#include <dld.h>
     1501+#endif
     1502+
     1503+static lt_module
     1504+sys_dld_open (loader_data, filename)
     1505+     lt_user_data loader_data;
     1506+     const char *filename;
     1507+{
     1508+  lt_module module = strdup (filename);
     1509+
     1510+  if (dld_link (filename) != 0)
     1511+    {
     1512+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN));
     1513+      LT_DLFREE (module);
     1514+      module = 0;
     1515+    }
     1516+
     1517+  return module;
     1518+}
     1519+
     1520+static int
     1521+sys_dld_close (loader_data, module)
     1522+     lt_user_data loader_data;
     1523+     lt_module module;
     1524+{
     1525+  int errors = 0;
     1526+
     1527+  if (dld_unlink_by_file ((char*)(module), 1) != 0)
     1528+    {
     1529+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE));
     1530+      ++errors;
     1531+    }
     1532+  else
     1533+    {
     1534+      LT_DLFREE (module);
     1535+    }
     1536+
     1537+  return errors;
     1538+}
     1539+
     1540+static lt_ptr
     1541+sys_dld_sym (loader_data, module, symbol)
     1542+     lt_user_data loader_data;
     1543+     lt_module module;
     1544+     const char *symbol;
     1545+{
     1546+  lt_ptr address = dld_get_func (symbol);
     1547+
     1548+  if (!address)
     1549+    {
     1550+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND));
     1551+    }
     1552+
     1553+  return address;
     1554+}
     1555+
     1556+static struct lt_user_dlloader sys_dld = {
     1557+  0, sys_dld_open, sys_dld_close, sys_dld_sym, 0, 0
     1558+};
     1559+
     1560+#endif /* HAVE_DLD */
     1561+
     1562+/* --- DYLD() MACOSX/DARWIN INTERFACE LOADER --- */
     1563+#if HAVE_DYLD
     1564+
     1565+
     1566+#if HAVE_MACH_O_DYLD_H
     1567+#if !defined(__APPLE_CC__) && !defined(__MWERKS__) && !defined(__private_extern__)
     1568+/* Is this correct? Does it still function properly? */
     1569+#define __private_extern__ extern
     1570+#endif
     1571+# include <mach-o/dyld.h>
     1572+#endif
     1573+#include <mach-o/getsect.h>
     1574+
     1575+/* We have to put some stuff here that isn't in older dyld.h files */
     1576+#ifndef ENUM_DYLD_BOOL
     1577+# define ENUM_DYLD_BOOL
     1578+# undef FALSE
     1579+# undef TRUE
     1580+ enum DYLD_BOOL {
     1581+    FALSE,
     1582+    TRUE
     1583+ };
     1584+#endif
     1585+#ifndef LC_REQ_DYLD
     1586+# define LC_REQ_DYLD 0x80000000
     1587+#endif
     1588+#ifndef LC_LOAD_WEAK_DYLIB
     1589+# define LC_LOAD_WEAK_DYLIB (0x18 | LC_REQ_DYLD)
     1590+#endif
     1591+static const struct mach_header * (*ltdl_NSAddImage)(const char *image_name, unsigned long options) = 0;
     1592+static NSSymbol (*ltdl_NSLookupSymbolInImage)(const struct mach_header *image,const char *symbolName, unsigned long options) = 0;
     1593+static enum DYLD_BOOL (*ltdl_NSIsSymbolNameDefinedInImage)(const struct mach_header *image, const char *symbolName) = 0;
     1594+static enum DYLD_BOOL (*ltdl_NSMakePrivateModulePublic)(NSModule module) = 0;
     1595+
     1596+#ifndef NSADDIMAGE_OPTION_NONE
     1597+#define NSADDIMAGE_OPTION_NONE                          0x0
     1598+#endif
     1599+#ifndef NSADDIMAGE_OPTION_RETURN_ON_ERROR
     1600+#define NSADDIMAGE_OPTION_RETURN_ON_ERROR               0x1
     1601+#endif
     1602+#ifndef NSADDIMAGE_OPTION_WITH_SEARCHING
     1603+#define NSADDIMAGE_OPTION_WITH_SEARCHING                0x2
     1604+#endif
     1605+#ifndef NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED
     1606+#define NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED         0x4
     1607+#endif
     1608+#ifndef NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME
     1609+#define NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME 0x8
     1610+#endif
     1611+#ifndef NSLOOKUPSYMBOLINIMAGE_OPTION_BIND
     1612+#define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND            0x0
     1613+#endif
     1614+#ifndef NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW
     1615+#define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW        0x1
     1616+#endif
     1617+#ifndef NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY
     1618+#define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY      0x2
     1619+#endif
     1620+#ifndef NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR
     1621+#define NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR 0x4
     1622+#endif
     1623+
     1624+
     1625+static const char *
     1626+lt_int_dyld_error(othererror)
     1627+       char* othererror;
     1628+{
     1629+/* return the dyld error string, or the passed in error string if none */
     1630+       NSLinkEditErrors ler;
     1631+       int lerno;
     1632+       const char *errstr;
     1633+       const char *file;
     1634+       NSLinkEditError(&ler,&lerno,&file,&errstr);
     1635+       if (!errstr || !strlen(errstr)) errstr = othererror;
     1636+       return errstr;
     1637+}
     1638+
     1639+static const struct mach_header *
     1640+lt_int_dyld_get_mach_header_from_nsmodule(module)
     1641+       NSModule module;
     1642+{
     1643+/* There should probably be an apple dyld api for this */
     1644+       int i=_dyld_image_count();
     1645+       int j;
     1646+       const char *modname=NSNameOfModule(module);
     1647+       const struct mach_header *mh=NULL;
     1648+       if (!modname) return NULL;
     1649+       for (j = 0; j < i; j++)
     1650+       {
     1651+               if (!strcmp(_dyld_get_image_name(j),modname))
     1652+               {
     1653+                       mh=_dyld_get_image_header(j);
     1654+                       break;
     1655+               }
     1656+       }
     1657+       return mh;
     1658+}
     1659+
     1660+static const char* lt_int_dyld_lib_install_name(mh)
     1661+       const struct mach_header *mh;
     1662+{
     1663+/* NSAddImage is also used to get the loaded image, but it only works if the lib
     1664+   is installed, for uninstalled libs we need to check the install_names against
     1665+   each other. Note that this is still broken if DYLD_IMAGE_SUFFIX is set and a
     1666+   different lib was loaded as a result
     1667+*/
     1668+       int j;
     1669+       struct load_command *lc;
     1670+       unsigned long offset = sizeof(struct mach_header);
     1671+       const char* retStr=NULL;
     1672+       for (j = 0; j < mh->ncmds; j++)
     1673+       {
     1674+               lc = (struct load_command*)(((unsigned long)mh) + offset);
     1675+               if (LC_ID_DYLIB == lc->cmd)
     1676+               {
     1677+                       retStr=(char*)(((struct dylib_command*)lc)->dylib.name.offset +
     1678+                                                                       (unsigned long)lc);
     1679+               }
     1680+               offset += lc->cmdsize;
     1681+       }
     1682+       return retStr;
     1683+}
     1684+
     1685+static const struct mach_header *
     1686+lt_int_dyld_match_loaded_lib_by_install_name(const char *name)
     1687+{
     1688+       int i=_dyld_image_count();
     1689+       int j;
     1690+       const struct mach_header *mh=NULL;
     1691+       const char *id=NULL;
     1692+       for (j = 0; j < i; j++)
     1693+       {
     1694+               id=lt_int_dyld_lib_install_name(_dyld_get_image_header(j));
     1695+               if ((id) && (!strcmp(id,name)))
     1696+               {
     1697+                       mh=_dyld_get_image_header(j);
     1698+                       break;
     1699+               }
     1700+       }
     1701+       return mh;
     1702+}
     1703 
     1704-/* dynamic linking with dld */
     1705+static NSSymbol
     1706+lt_int_dyld_NSlookupSymbolInLinkedLibs(symbol,mh)
     1707+       const char *symbol;
     1708+       const struct mach_header *mh;
     1709+{
     1710+       /* Safe to assume our mh is good */
     1711+       int j;
     1712+       struct load_command *lc;
     1713+       unsigned long offset = sizeof(struct mach_header);
     1714+       NSSymbol retSym = 0;
     1715+       const struct mach_header *mh1;
     1716+       if ((ltdl_NSLookupSymbolInImage) && NSIsSymbolNameDefined(symbol) )
     1717+       {
     1718+               for (j = 0; j < mh->ncmds; j++)
     1719+               {
     1720+                       lc = (struct load_command*)(((unsigned long)mh) + offset);
     1721+                       if ((LC_LOAD_DYLIB == lc->cmd) || (LC_LOAD_WEAK_DYLIB == lc->cmd))
     1722+                       {
     1723+                               mh1=lt_int_dyld_match_loaded_lib_by_install_name((char*)(((struct dylib_command*)lc)->dylib.name.offset +
     1724+                                                                               (unsigned long)lc));
     1725+                               if (!mh1)
     1726+                               {
     1727+                                       /* Maybe NSAddImage can find it */
     1728+                                       mh1=ltdl_NSAddImage((char*)(((struct dylib_command*)lc)->dylib.name.offset +
     1729+                                                                               (unsigned long)lc),
     1730+                                                                               NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED +
     1731+                                                                               NSADDIMAGE_OPTION_WITH_SEARCHING +
     1732+                                                                               NSADDIMAGE_OPTION_RETURN_ON_ERROR );
     1733+                               }
     1734+                               if (mh1)
     1735+                               {
     1736+                                       retSym = ltdl_NSLookupSymbolInImage(mh1,
     1737+                                                                                       symbol,
     1738+                                                                                       NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW
     1739+                                                                                       | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR
     1740+                                                                                       );
     1741+                                       if (retSym) break;
     1742+                               }
     1743+                       }
     1744+                       offset += lc->cmdsize;
     1745+               }
     1746+       }
     1747+       return retSym;
     1748+}
     1749 
     1750-#if HAVE_DLD_H
     1751-#include <dld.h>
     1752-#endif
     1753+static int
     1754+sys_dyld_init()
     1755+{
     1756+       int retCode = 0;
     1757+       int err = 0;
     1758+       if (!_dyld_present()) {
     1759+               retCode=1;
     1760+       }
     1761+       else {
     1762+      err = _dyld_func_lookup("__dyld_NSAddImage",(unsigned long*)&ltdl_NSAddImage);
     1763+      err = _dyld_func_lookup("__dyld_NSLookupSymbolInImage",(unsigned long*)&ltdl_NSLookupSymbolInImage);
     1764+      err = _dyld_func_lookup("__dyld_NSIsSymbolNameDefinedInImage",(unsigned long*)&ltdl_NSIsSymbolNameDefinedInImage);
     1765+      err = _dyld_func_lookup("__dyld_NSMakePrivateModulePublic",(unsigned long*)&ltdl_NSMakePrivateModulePublic);
     1766+    }
     1767+ return retCode;
     1768+}
     1769 
     1770 static lt_module
     1771-sys_dld_open (loader_data, filename)
     1772+sys_dyld_open (loader_data, filename)
     1773      lt_user_data loader_data;
     1774      const char *filename;
     1775 {
     1776-  lt_module module = strdup (filename);
     1777-
     1778-  if (!module)
     1779-    {
     1780-      MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     1781-      module = 0;
     1782-    }
     1783-  else if (dld_link (filename) != 0)
     1784-    {
     1785-      MUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN));
     1786-      LT_DLFREE (module);
     1787-      module = 0;
     1788-    }
     1789-
     1790+       lt_module   module   = 0;
     1791+       NSObjectFileImage ofi = 0;
     1792+       NSObjectFileImageReturnCode ofirc;
     1793+
     1794+       if (!filename)
     1795+               return (lt_module)-1;
     1796+       ofirc = NSCreateObjectFileImageFromFile(filename, &ofi);
     1797+       switch (ofirc)
     1798+       {
     1799+               case NSObjectFileImageSuccess:
     1800+                       module = NSLinkModule(ofi, filename,
     1801+                                               NSLINKMODULE_OPTION_RETURN_ON_ERROR
     1802+                                                | NSLINKMODULE_OPTION_PRIVATE
     1803+                                                | NSLINKMODULE_OPTION_BINDNOW);
     1804+                       NSDestroyObjectFileImage(ofi);
     1805+                       if (module)
     1806+                               ltdl_NSMakePrivateModulePublic(module);
     1807+                       break;
     1808+               case NSObjectFileImageInappropriateFile:
     1809+                   if (ltdl_NSIsSymbolNameDefinedInImage && ltdl_NSLookupSymbolInImage)
     1810+                   {
     1811+                               module = (lt_module)ltdl_NSAddImage(filename, NSADDIMAGE_OPTION_RETURN_ON_ERROR);
     1812+                               break;
     1813+                       }
     1814+               default:
     1815+                       LT_DLMUTEX_SETERROR (lt_int_dyld_error(LT_DLSTRERROR(CANNOT_OPEN)));
     1816+                       return 0;
     1817+       }
     1818+       if (!module) LT_DLMUTEX_SETERROR (lt_int_dyld_error(LT_DLSTRERROR(CANNOT_OPEN)));
     1819   return module;
     1820 }
     1821 
     1822 static int
     1823-sys_dld_close (loader_data, module)
     1824+sys_dyld_close (loader_data, module)
     1825      lt_user_data loader_data;
     1826      lt_module module;
     1827 {
     1828-  int errors = 0;
     1829-
     1830-  if (dld_unlink_by_file ((char*)(module), 1) != 0)
     1831-    {
     1832-      MUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE));
     1833-      ++errors;
     1834-    }
     1835-  else
     1836-    {
     1837-      LT_DLFREE (module);
     1838-    }
     1839+       int retCode = 0;
     1840+       int flags = 0;
     1841+       if (module == (lt_module)-1) return 0;
     1842+#ifdef __BIG_ENDIAN__
     1843+       if (((struct mach_header *)module)->magic == MH_MAGIC)
     1844+#else
     1845+    if (((struct mach_header *)module)->magic == MH_CIGAM)
     1846+#endif
     1847+       {
     1848+         LT_DLMUTEX_SETERROR("Can not close a dylib");
     1849+         retCode = 1;
     1850+       }
     1851+       else
     1852+       {
     1853+#if 1
     1854+/* Currently, if a module contains c++ static destructors and it is unloaded, we
     1855+   get a segfault in atexit(), due to compiler and dynamic loader differences of
     1856+   opinion, this works around that.
     1857+*/
     1858+               if ((const struct section *)NULL !=
     1859+                  getsectbynamefromheader(lt_int_dyld_get_mach_header_from_nsmodule(module),
     1860+                  "__DATA","__mod_term_func"))
     1861+               {
     1862+                       flags += NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED;
     1863+               }
     1864+#endif
     1865+#ifdef __ppc__
     1866+                       flags += NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES;
     1867+#endif
     1868+               if (!NSUnLinkModule(module,flags))
     1869+               {
     1870+                       retCode=1;
     1871+                       LT_DLMUTEX_SETERROR (lt_int_dyld_error(LT_DLSTRERROR(CANNOT_CLOSE)));
     1872+               }
     1873+       }
     1874 
     1875-  return errors;
     1876+ return retCode;
     1877 }
     1878 
     1879 static lt_ptr
     1880-sys_dld_sym (loader_data, module, symbol)
     1881+sys_dyld_sym (loader_data, module, symbol)
     1882      lt_user_data loader_data;
     1883      lt_module module;
     1884      const char *symbol;
     1885 {
     1886-  lt_ptr address = dld_get_func (symbol);
     1887-
     1888-  if (!address)
     1889-    {
     1890-      MUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND));
     1891-    }
     1892+       lt_ptr address = 0;
     1893+       NSSymbol *nssym = 0;
     1894+       void *unused;
     1895+       const struct mach_header *mh=NULL;
     1896+       char saveError[256] = "Symbol not found";
     1897+       if (module == (lt_module)-1)
     1898+       {
     1899+               _dyld_lookup_and_bind(symbol,(unsigned long*)&address,&unused);
     1900+               return address;
     1901+       }
     1902+#ifdef __BIG_ENDIAN__
     1903+       if (((struct mach_header *)module)->magic == MH_MAGIC)
     1904+#else
     1905+    if (((struct mach_header *)module)->magic == MH_CIGAM)
     1906+#endif
     1907+       {
     1908+           if (ltdl_NSIsSymbolNameDefinedInImage && ltdl_NSLookupSymbolInImage)
     1909+           {
     1910+               mh=module;
     1911+                       if (ltdl_NSIsSymbolNameDefinedInImage((struct mach_header*)module,symbol))
     1912+                       {
     1913+                               nssym = ltdl_NSLookupSymbolInImage((struct mach_header*)module,
     1914+                                                                                       symbol,
     1915+                                                                                       NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW
     1916+                                                                                       | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR
     1917+                                                                                       );
     1918+                       }
     1919+           }
     1920 
     1921-  return address;
     1922+       }
     1923+  else {
     1924+       nssym = NSLookupSymbolInModule(module, symbol);
     1925+       }
     1926+       if (!nssym)
     1927+       {
     1928+               strncpy(saveError, lt_int_dyld_error(LT_DLSTRERROR(SYMBOL_NOT_FOUND)), 255);
     1929+               saveError[255] = 0;
     1930+               if (!mh) mh=lt_int_dyld_get_mach_header_from_nsmodule(module);
     1931+               nssym = lt_int_dyld_NSlookupSymbolInLinkedLibs(symbol,mh);
     1932+       }
     1933+       if (!nssym)
     1934+       {
     1935+               LT_DLMUTEX_SETERROR (saveError);
     1936+               return NULL;
     1937+       }
     1938+       return NSAddressOfSymbol(nssym);
     1939 }
     1940 
     1941-static struct lt_user_dlloader sys_dld = {
     1942-  0, sys_dld_open, sys_dld_close, sys_dld_sym, 0, 0
     1943-};
     1944-
     1945-#endif /* HAVE_DLD */
     1946+static struct lt_user_dlloader sys_dyld =
     1947+  { "_", sys_dyld_open, sys_dyld_close, sys_dyld_sym, 0, 0 };
     1948 
     1949 
     1950+#endif /* HAVE_DYLD */
     1951 
     1952 
     1953
     1954 /* --- DLPREOPEN() INTERFACE LOADER --- */
     1955@@ -1109,7 +1941,7 @@
     1956 {
     1957   int errors = 0;
     1958 
     1959-  MUTEX_LOCK ();
     1960+  LT_DLMUTEX_LOCK ();
     1961 
     1962   preloaded_symbols = 0;
     1963   if (default_preloaded_symbols)
     1964@@ -1117,7 +1949,7 @@
     1965       errors = lt_dlpreload (default_preloaded_symbols);
     1966     }
     1967 
     1968-  MUTEX_UNLOCK ();
     1969+  LT_DLMUTEX_UNLOCK ();
     1970 
     1971   return errors;
     1972 }
     1973@@ -1127,7 +1959,7 @@
     1974 {
     1975   lt_dlsymlists_t *lists;
     1976 
     1977-  MUTEX_LOCK ();
     1978+  LT_DLMUTEX_LOCK ();
     1979 
     1980   lists = preloaded_symbols;
     1981   while (lists)
     1982@@ -1139,7 +1971,7 @@
     1983     }
     1984   preloaded_symbols = 0;
     1985 
     1986-  MUTEX_UNLOCK ();
     1987+  LT_DLMUTEX_UNLOCK ();
     1988 
     1989   return 0;
     1990 }
     1991@@ -1160,7 +1992,7 @@
     1992   lt_dlsymlists_t *lists;
     1993   int             errors   = 0;
     1994 
     1995-  MUTEX_LOCK ();
     1996+  LT_DLMUTEX_LOCK ();
     1997 
     1998   lists = preloaded_symbols;
     1999   while (lists)
     2000@@ -1172,21 +2004,21 @@
     2001       lists = lists->next;
     2002     }
     2003 
     2004-  tmp = LT_DLMALLOC (lt_dlsymlists_t, 1);
     2005+  tmp = LT_EMALLOC (lt_dlsymlists_t, 1);
     2006   if (tmp)
     2007     {
     2008+      memset (tmp, 0, sizeof(lt_dlsymlists_t));
     2009       tmp->syms = preloaded;
     2010       tmp->next = preloaded_symbols;
     2011       preloaded_symbols = tmp;
     2012     }
     2013   else
     2014     {
     2015-      MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     2016       ++errors;
     2017     }
     2018 
     2019  done:
     2020-  MUTEX_UNLOCK ();
     2021+  LT_DLMUTEX_UNLOCK ();
     2022   return errors;
     2023 }
     2024 
     2025@@ -1198,15 +2030,19 @@
     2026   lt_dlsymlists_t *lists;
     2027   lt_module       module = (lt_module) 0;
     2028 
     2029-  MUTEX_LOCK ();
     2030+  LT_DLMUTEX_LOCK ();
     2031   lists = preloaded_symbols;
     2032 
     2033   if (!lists)
     2034     {
     2035-      MUTEX_SETERROR (LT_DLSTRERROR (NO_SYMBOLS));
     2036+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_SYMBOLS));
     2037       goto done;
     2038     }
     2039 
     2040+  /* Can't use NULL as the reflective symbol header, as NULL is
     2041+     used to mark the end of the entire symbol list.  Self-dlpreopened
     2042+     symbols follow this magic number, chosen to be an unlikely
     2043+     clash with a real module name.  */
     2044   if (!filename)
     2045     {
     2046       filename = "@PROGRAM@";
     2047@@ -1229,10 +2065,10 @@
     2048       lists = lists->next;
     2049     }
     2050 
     2051-  MUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND));
     2052+  LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND));
     2053 
     2054  done:
     2055-  MUTEX_UNLOCK ();
     2056+  LT_DLMUTEX_UNLOCK ();
     2057   return module;
     2058 }
     2059 
     2060@@ -1265,7 +2101,7 @@
     2061     ++syms;
     2062   }
     2063 
     2064-  MUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND));
     2065+  LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND));
     2066 
     2067   return 0;
     2068 }
     2069@@ -1281,6 +2117,70 @@
     2070 /* --- DYNAMIC MODULE LOADING --- */
     2071 
     2072 
     2073+/* The type of a function used at each iteration of  foreach_dirinpath().  */
     2074+typedef int    foreach_callback_func LT_PARAMS((char *filename, lt_ptr data1,
     2075+                                                lt_ptr data2));
     2076+
     2077+static int     foreach_dirinpath     LT_PARAMS((const char *search_path,
     2078+                                                const char *base_name,
     2079+                                                foreach_callback_func *func,
     2080+                                                lt_ptr data1, lt_ptr data2));
     2081+
     2082+static int     find_file_callback    LT_PARAMS((char *filename, lt_ptr data,
     2083+                                                lt_ptr ignored));
     2084+static int     find_handle_callback  LT_PARAMS((char *filename, lt_ptr data,
     2085+                                                lt_ptr ignored));
     2086+static int     foreachfile_callback  LT_PARAMS((char *filename, lt_ptr data1,
     2087+                                                lt_ptr data2));
     2088+
     2089+
     2090+static int     canonicalize_path     LT_PARAMS((const char *path,
     2091+                                                char **pcanonical));
     2092+static int     argzize_path          LT_PARAMS((const char *path,
     2093+                                                char **pargz,
     2094+                                                size_t *pargz_len));
     2095+static FILE   *find_file             LT_PARAMS((const char *search_path,
     2096+                                                const char *base_name,
     2097+                                                char **pdir));
     2098+static lt_dlhandle *find_handle      LT_PARAMS((const char *search_path,
     2099+                                                const char *base_name,
     2100+                                                lt_dlhandle *handle));
     2101+static int     find_module           LT_PARAMS((lt_dlhandle *handle,
     2102+                                                const char *dir,
     2103+                                                const char *libdir,
     2104+                                                const char *dlname,
     2105+                                                const char *old_name,
     2106+                                                int installed));
     2107+static int     free_vars             LT_PARAMS((char *dlname, char *oldname,
     2108+                                                char *libdir, char *deplibs));
     2109+static int     load_deplibs          LT_PARAMS((lt_dlhandle handle,
     2110+                                                char *deplibs));
     2111+static int     trim                  LT_PARAMS((char **dest,
     2112+                                                const char *str));
     2113+static int     try_dlopen            LT_PARAMS((lt_dlhandle *handle,
     2114+                                                const char *filename));
     2115+static int     tryall_dlopen         LT_PARAMS((lt_dlhandle *handle,
     2116+                                                const char *filename));
     2117+static int     unload_deplibs        LT_PARAMS((lt_dlhandle handle));
     2118+static int     lt_argz_insert        LT_PARAMS((char **pargz,
     2119+                                                size_t *pargz_len,
     2120+                                                char *before,
     2121+                                                const char *entry));
     2122+static int     lt_argz_insertinorder LT_PARAMS((char **pargz,
     2123+                                                size_t *pargz_len,
     2124+                                                const char *entry));
     2125+static int     lt_argz_insertdir     LT_PARAMS((char **pargz,
     2126+                                                size_t *pargz_len,
     2127+                                                const char *dirnam,
     2128+                                                struct dirent *dp));
     2129+static int     lt_dlpath_insertdir   LT_PARAMS((char **ppath,
     2130+                                                char *before,
     2131+                                                const char *dir));
     2132+static int     list_files_by_dir     LT_PARAMS((const char *dirnam,
     2133+                                                char **pargz,
     2134+                                                size_t *pargz_len));
     2135+static int     file_not_found        LT_PARAMS((void));
     2136+
     2137 static char           *user_search_path= 0;
     2138 static lt_dlloader    *loaders         = 0;
     2139 static lt_dlhandle     handles         = 0;
     2140@@ -1292,7 +2192,7 @@
     2141 {
     2142   int        errors   = 0;
     2143 
     2144-  MUTEX_LOCK ();
     2145+  LT_DLMUTEX_LOCK ();
     2146 
     2147   /* Initialize only at first call. */
     2148   if (++initialized == 1)
     2149@@ -1300,11 +2200,8 @@
     2150       handles = 0;
     2151       user_search_path = 0; /* empty search path */
     2152 
     2153-#if HAVE_LIBDL && !defined(__CYGWIN__)
     2154+#if HAVE_LIBDL
     2155       errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dl, "dlopen");
     2156-#ifdef _AIX
     2157-      sys_dl_init();
     2158-#endif /* _AIX */
     2159 #endif
     2160 #if HAVE_SHL_LOAD
     2161       errors += lt_dlloader_add (lt_dlloader_next (0), &sys_shl, "dlopen");
     2162@@ -1318,21 +2215,25 @@
     2163 #if HAVE_DLD
     2164       errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dld, "dld");
     2165 #endif
     2166+#if HAVE_DYLD
     2167+       errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dyld, "dyld");
     2168+       errors += sys_dyld_init();
     2169+#endif
     2170       errors += lt_dlloader_add (lt_dlloader_next (0), &presym, "dlpreload");
     2171 
     2172       if (presym_init (presym.dlloader_data))
     2173        {
     2174-         MUTEX_SETERROR (LT_DLSTRERROR (INIT_LOADER));
     2175+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INIT_LOADER));
     2176          ++errors;
     2177        }
     2178       else if (errors != 0)
     2179        {
     2180-         MUTEX_SETERROR (LT_DLSTRERROR (DLOPEN_NOT_SUPPORTED));
     2181+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (DLOPEN_NOT_SUPPORTED));
     2182          ++errors;
     2183        }
     2184     }
     2185 
     2186-  MUTEX_UNLOCK ();
     2187+  LT_DLMUTEX_UNLOCK ();
     2188 
     2189   return errors;
     2190 }
     2191@@ -1349,16 +2250,14 @@
     2192     }
     2193   else
     2194     {
     2195-      const char *errormsg = 0;
     2196-
     2197       presym_free_symlists();
     2198
     2199-      MUTEX_LOCK ();
     2200+
     2201+      LT_DLMUTEX_LOCK ();
     2202       if (default_preloaded_symbols)
     2203        {
     2204          errors = lt_dlpreload (default_preloaded_symbols);
     2205        }
     2206-      MUTEX_UNLOCK ();
     2207+      LT_DLMUTEX_UNLOCK ();
     2208     }
     2209 
     2210   return errors;
     2211@@ -1368,9 +2267,9 @@
     2212 lt_dlpreload_default (preloaded)
     2213      const lt_dlsymlist *preloaded;
     2214 {
     2215-  MUTEX_LOCK ();
     2216+  LT_DLMUTEX_LOCK ();
     2217   default_preloaded_symbols = preloaded;
     2218-  MUTEX_UNLOCK ();
     2219+  LT_DLMUTEX_UNLOCK ();
     2220   return 0;
     2221 }
     2222 
     2223@@ -1379,15 +2278,14 @@
     2224 {
     2225   /* shut down libltdl */
     2226   lt_dlloader *loader;
     2227-  const char  *errormsg;
     2228   int         errors   = 0;
     2229 
     2230-  MUTEX_LOCK ();
     2231+  LT_DLMUTEX_LOCK ();
     2232   loader = loaders;
     2233 
     2234   if (!initialized)
     2235     {
     2236-      MUTEX_SETERROR (LT_DLSTRERROR (SHUTDOWN));
     2237+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SHUTDOWN));
     2238       ++errors;
     2239       goto done;
     2240     }
     2241@@ -1406,11 +2304,14 @@
     2242       for (level = 1; handles; ++level)
     2243        {
     2244          lt_dlhandle cur = handles;
     2245+         int saw_nonresident = 0;
     2246 
     2247          while (cur)
     2248            {
     2249              lt_dlhandle tmp = cur;
     2250              cur = cur->next;
     2251+             if (!LT_DLIS_RESIDENT (tmp))
     2252+               saw_nonresident = 1;
     2253              if (!LT_DLIS_RESIDENT (tmp) && tmp->info.ref_count <= level)
     2254                {
     2255                  if (lt_dlclose (tmp))
     2256@@ -1419,6 +2320,9 @@
     2257                    }
     2258                }
     2259            }
     2260+         /* done if only resident modules are left */
     2261+         if (!saw_nonresident)
     2262+           break;
     2263        }
     2264 
     2265       /* close all loaders */
     2266@@ -1437,7 +2341,7 @@
     2267     }
     2268 
     2269  done:
     2270-  MUTEX_UNLOCK ();
     2271+  LT_DLMUTEX_UNLOCK ();
     2272   return errors;
     2273 }
     2274 
     2275@@ -1451,8 +2355,8 @@
     2276   const char   *saved_error;
     2277   int           errors         = 0;
     2278 
     2279-  MUTEX_GETERROR (saved_error);
     2280-  MUTEX_LOCK ();
     2281+  LT_DLMUTEX_GETERROR (saved_error);
     2282+  LT_DLMUTEX_LOCK ();
     2283 
     2284   cur   = handles;
     2285   loader = loaders;
     2286@@ -1485,18 +2389,27 @@
     2287   cur = *handle;
     2288   if (filename)
     2289     {
     2290-      LT_DLFREE( cur->info.filename );
     2291-      cur->info.filename = strdup (filename);
     2292+      /* Comment out the check of file permissions using access.
     2293+        This call seems to always return -1 with error EACCES.
     2294+      */
     2295+      /* We need to catch missing file errors early so that
     2296+        file_not_found() can detect what happened.
     2297+      if (access (filename, R_OK) != 0)
     2298+       {
     2299+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND));
     2300+         ++errors;
     2301+         goto done;
     2302+       } */
     2303+
     2304+      cur->info.filename = lt_estrdup (filename);
     2305       if (!cur->info.filename)
     2306        {
     2307-         MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     2308          ++errors;
     2309          goto done;
     2310        }
     2311     }
     2312   else
     2313     {
     2314-      LT_DLFREE( cur->info.filename );
     2315       cur->info.filename = 0;
     2316     }
     2317 
     2318@@ -1521,15 +2434,66 @@
     2319     }
     2320 
     2321   cur->loader  = loader;
     2322-  last_error   = saved_error;
     2323
     2324+  LT_DLMUTEX_SETERROR (saved_error);
     2325+
     2326  done:
     2327-  MUTEX_UNLOCK ();
     2328+  LT_DLMUTEX_UNLOCK ();
     2329 
     2330   return errors;
     2331 }
     2332 
     2333 static int
     2334+tryall_dlopen_module (handle, prefix, dirname, dlname)
     2335+     lt_dlhandle *handle;
     2336+     const char *prefix;
     2337+     const char *dirname;
     2338+     const char *dlname;
     2339+{
     2340+  int      error       = 0;
     2341+  char     *filename   = 0;
     2342+  size_t   filename_len        = 0;
     2343+  size_t   dirname_len = LT_STRLEN (dirname);
     2344+
     2345+  assert (handle);
     2346+  assert (dirname);
     2347+  assert (dlname);
     2348+#ifdef LT_DIRSEP_CHAR
     2349+  /* Only canonicalized names (i.e. with DIRSEP chars already converted)
     2350+     should make it into this function:  */
     2351+  assert (strchr (dirname, LT_DIRSEP_CHAR) == 0);
     2352+#endif
     2353+
     2354+  if (dirname_len > 0)
     2355+    if (dirname[dirname_len -1] == '/')
     2356+      --dirname_len;
     2357+  filename_len = dirname_len + 1 + LT_STRLEN (dlname);
     2358+
     2359+  /* Allocate memory, and combine DIRNAME and MODULENAME into it.
     2360+     The PREFIX (if any) is handled below.  */
     2361+  filename  = LT_EMALLOC (char, dirname_len + 1 + filename_len + 1);
     2362+  if (!filename)
     2363+    return 1;
     2364+
     2365+  sprintf (filename, "%.*s/%s", (int) dirname_len, dirname, dlname);
     2366+
     2367+  /* Now that we have combined DIRNAME and MODULENAME, if there is
     2368+     also a PREFIX to contend with, simply recurse with the arguments
     2369+     shuffled.  Otherwise, attempt to open FILENAME as a module.  */
     2370+  if (prefix)
     2371+    {
     2372+      error += tryall_dlopen_module (handle,
     2373+                                    (const char *) 0, prefix, filename);
     2374+    }
     2375+  else if (tryall_dlopen (handle, filename) != 0)
     2376+    {
     2377+      ++error;
     2378+    }
     2379+
     2380+  LT_DLFREE (filename);
     2381+  return error;
     2382+}
     2383+
     2384+static int
     2385 find_module (handle, dir, libdir, dlname, old_name, installed)
     2386      lt_dlhandle *handle;
     2387      const char *dir;
     2388@@ -1538,252 +2502,304 @@
     2389      const char *old_name;
     2390      int installed;
     2391 {
     2392-  int  error;
     2393-  char *filename;
     2394-
     2395-  /* try to open the old library first; if it was dlpreopened,
     2396+  /* Try to open the old library first; if it was dlpreopened,
    102397      we want the preopened version of it, even if a dlopenable
    11       module is available */
    12 +/*     HACKALERT: Why? Mac OS/Darwin can't open static libs, it is
    13 +       a waste to even try. Disabled for kde.  */
    14 +#if 0
    15    if (old_name && tryall_dlopen(handle, old_name) == 0)
     2398-     module is available */
     2399-  if (old_name && tryall_dlopen(handle, old_name) == 0)
     2400+     module is available.  */
     2401+  if (old_name && tryall_dlopen (handle, old_name) == 0)
    162402     {
    172403       return 0;
    182404     }
    19 -
     2405 
     2406-  /* try to open the dynamic library */
     2407+  /* Try to open the dynamic library.  */
     2408   if (dlname)
     2409     {
     2410-      size_t len;
     2411-
     2412       /* try to open the installed module */
     2413       if (installed && libdir)
     2414        {
     2415-         len       = strlen (libdir) + 1 + strlen (dlname);
     2416-         filename  = LT_DLMALLOC (char, 1+ len);
     2417-
     2418-         if (!filename)
     2419-           {
     2420-             MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     2421-             return 1;
     2422-           }
     2423-
     2424-         sprintf (filename, "%s/%s", libdir, dlname);
     2425-         error = (tryall_dlopen (handle, filename) != 0);
     2426-         LT_DLFREE (filename);
     2427-
     2428-         if (!error)
     2429-           {
     2430-             return 0;
     2431-           }
     2432+         if (tryall_dlopen_module (handle,
     2433+                                   (const char *) 0, libdir, dlname) == 0)
     2434+           return 0;
     2435        }
     2436 
     2437       /* try to open the not-installed module */
     2438       if (!installed)
     2439        {
     2440-         len = (dir ? strlen (dir) : 0) + strlen (objdir) + strlen (dlname);
     2441-         filename = LT_DLMALLOC (char, 1+ len);
     2442-
     2443-         if (!filename)
     2444-           {
     2445-             MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     2446-             return 1;
     2447-           }
     2448-
     2449-         if (dir)
     2450-           {
     2451-             strcpy (filename, dir);
     2452-           }
     2453-         else
     2454-           {
     2455-             *filename = 0;
     2456-           }
     2457-         strcat(filename, objdir);
     2458-         strcat(filename, dlname);
     2459-
     2460-         error = tryall_dlopen (handle, filename) != 0;
     2461-         LT_DLFREE (filename);
     2462-         if (!error)
     2463-           {
     2464-             return 0;
     2465-           }
     2466+         if (tryall_dlopen_module (handle, dir, objdir, dlname) == 0)
     2467+           return 0;
     2468        }
     2469 
     2470       /* maybe it was moved to another directory */
     2471       {
     2472-       len      = (dir ? strlen (dir) : 0) + strlen (dlname);
     2473-       filename = LT_DLMALLOC (char, 1+ len);
     2474+         if (tryall_dlopen_module (handle,
     2475+                                   (const char *) 0, dir, dlname) == 0)
     2476+           return 0;
     2477+      }
     2478+    }
     2479+
     2480+  return 1;
     2481+}
     2482 
     2483-       if (dir)
     2484+
     2485+static int
     2486+canonicalize_path (path, pcanonical)
     2487+     const char *path;
     2488+     char **pcanonical;
     2489+{
     2490+  char *canonical = 0;
     2491+
     2492+  assert (path && *path);
     2493+  assert (pcanonical);
     2494+
     2495+  canonical = LT_EMALLOC (char, 1+ LT_STRLEN (path));
     2496+  if (!canonical)
     2497+    return 1;
     2498+
     2499+  {
     2500+    size_t dest = 0;
     2501+    size_t src;
     2502+    for (src = 0; path[src] != LT_EOS_CHAR; ++src)
     2503+      {
     2504+       /* Path separators are not copied to the beginning or end of
     2505+          the destination, or if another separator would follow
     2506+          immediately.  */
     2507+       if (path[src] == LT_PATHSEP_CHAR)
     2508          {
     2509-           strcpy (filename, dir);
     2510+           if ((dest == 0)
     2511+               || (path[1+ src] == LT_PATHSEP_CHAR)
     2512+               || (path[1+ src] == LT_EOS_CHAR))
     2513+             continue;
     2514          }
     2515-       else
     2516+
     2517+       /* Anything other than a directory separator is copied verbatim.  */
     2518+       if ((path[src] != '/')
     2519+#ifdef LT_DIRSEP_CHAR
     2520+           && (path[src] != LT_DIRSEP_CHAR)
    202521+#endif
    21    /* try to open the dynamic library */
    22    if (dlname)
    23      {
     2522+           )
     2523          {
     2524-           *filename = 0;
     2525+           canonical[dest++] = path[src];
     2526          }
     2527-       strcat(filename, dlname);
     2528-
     2529-       error = (tryall_dlopen (handle, filename) != 0);
     2530-       LT_DLFREE (filename);
     2531-       if (!error)
     2532+       /* Directory separators are converted and copied only if they are
     2533+          not at the end of a path -- i.e. before a path separator or
     2534+          NULL terminator.  */
     2535+       else if ((path[1+ src] != LT_PATHSEP_CHAR)
     2536+                && (path[1+ src] != LT_EOS_CHAR)
     2537+#ifdef LT_DIRSEP_CHAR
     2538+                && (path[1+ src] != LT_DIRSEP_CHAR)
     2539+#endif
     2540+                && (path[1+ src] != '/'))
     2541          {
     2542-           return 0;
     2543+           canonical[dest++] = '/';
     2544          }
     2545       }
     2546-    }
     2547 
     2548-  return 1;
     2549+    /* Add an end-of-string marker at the end.  */
     2550+    canonical[dest] = LT_EOS_CHAR;
     2551+  }
     2552+
     2553+  /* Assign new value.  */
     2554+  *pcanonical = canonical;
     2555+
     2556+  return 0;
     2557 }
     2558 
     2559-static char*
     2560-canonicalize_path (path)
     2561+static int
     2562+argzize_path (path, pargz, pargz_len)
     2563      const char *path;
     2564+     char **pargz;
     2565+     size_t *pargz_len;
     2566 {
     2567-  char *canonical = 0;
     2568+  error_t error;
     2569 
     2570-  if (path && *path)
     2571-    {
     2572-      char *ptr = strdup (path);
     2573-      canonical = ptr;
     2574+  assert (path);
     2575+  assert (pargz);
     2576+  assert (pargz_len);
     2577 
     2578-#ifdef LT_DIRSEP_CHAR
     2579-      /* Avoid this overhead where '/' is the only separator. */
     2580-      while (ptr = strchr (ptr, LT_DIRSEP_CHAR))
     2581+  if ((error = argz_create_sep (path, LT_PATHSEP_CHAR, pargz, pargz_len)))
     2582+    {
     2583+      switch (error)
     2584        {
     2585-         *ptr++ = '/';
     2586+       case ENOMEM:
     2587+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     2588+         break;
     2589+       default:
     2590+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (UNKNOWN));
     2591+         break;
     2592        }
     2593-#endif
     2594+
     2595+      return 1;
     2596     }
     2597 
     2598-  return canonical;
     2599+  return 0;
     2600 }
     2601 
     2602-static lt_ptr
     2603-find_file (basename, search_path, pdir, handle)
     2604-     const char *basename;
     2605+/* Repeatedly call FUNC with each LT_PATHSEP_CHAR delimited element
     2606+   of SEARCH_PATH and references to DATA1 and DATA2, until FUNC returns
     2607+   non-zero or all elements are exhausted.  If BASE_NAME is non-NULL,
     2608+   it is appended to each SEARCH_PATH element before FUNC is called.  */
     2609+static int
     2610+foreach_dirinpath (search_path, base_name, func, data1, data2)
     2611      const char *search_path;
     2612-     char **pdir;
     2613-     lt_dlhandle *handle;
     2614-{
     2615-  /* When handle != NULL search a library, otherwise a file
     2616-     return NULL on failure, otherwise the file/handle.  */
     2617+     const char *base_name;
     2618+     foreach_callback_func *func;
     2619+     lt_ptr data1;
     2620+     lt_ptr data2;
     2621+{
     2622+  int   result         = 0;
     2623+  int   filenamesize   = 0;
     2624+  size_t lenbase       = LT_STRLEN (base_name);
     2625+  size_t argz_len      = 0;
     2626+  char *argz           = 0;
     2627+  char *filename       = 0;
     2628+  char *canonical      = 0;
     2629 
     2630-  lt_ptr    result     = 0;
     2631-  char    *filename    = 0;
     2632-  int      filenamesize= 0;
     2633-  int      lenbase     = strlen (basename);
     2634-  char    *canonical   = 0;
     2635-  char    *next        = 0;
     2636-
     2637-  MUTEX_LOCK ();
     2638+  LT_DLMUTEX_LOCK ();
     2639 
     2640   if (!search_path || !*search_path)
     2641     {
     2642-      MUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND));
     2643+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND));
     2644       goto cleanup;
     2645     }
     2646 
     2647-  canonical = canonicalize_path (search_path);
     2648-  if (!canonical)
     2649-    {
     2650-      MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     2651-      goto cleanup;
     2652-    }
     2653+  if (canonicalize_path (search_path, &canonical) != 0)
     2654+    goto cleanup;
     2655 
     2656-  next = canonical;
     2657-  while (next)
     2658-    {
     2659-      int lendir;
     2660-      char *cur = next;
     2661+  if (argzize_path (canonical, &argz, &argz_len) != 0)
     2662+    goto cleanup;
     2663 
     2664-      next = strchr (cur, LT_PATHSEP_CHAR);
     2665-      if (!next)
     2666-       {
     2667-         next = cur + strlen (cur);
     2668-       }
     2669+  {
     2670+    char *dir_name = 0;
     2671+    while ((dir_name = argz_next (argz, argz_len, dir_name)))
     2672+      {
     2673+       size_t lendir = LT_STRLEN (dir_name);
     2674 
     2675-      lendir = next - cur;
     2676-      if (*next == LT_PATHSEP_CHAR)
     2677+       if (lendir +1 +lenbase >= filenamesize)
     2678        {
     2679-         ++next;
     2680-       }
     2681-      else
     2682-       {
     2683-         next = 0;
     2684+         LT_DLFREE (filename);
     2685+         filenamesize  = lendir +1 +lenbase +1; /* "/d" + '/' + "f" + '\0' */
     2686+         filename      = LT_EMALLOC (char, filenamesize);
     2687+         if (!filename)
     2688+           goto cleanup;
     2689        }
     2690 
     2691-      if (lendir == 0)
     2692-       {
     2693-         continue;
     2694-       }
     2695+       assert (filenamesize > lendir);
     2696+       strcpy (filename, dir_name);
     2697 
     2698-      if (lendir + 1 + lenbase >= filenamesize)
     2699-       {
     2700-         LT_DLFREE (filename);
     2701-         filenamesize = lendir + 1 + lenbase + 1;
     2702-         filename = LT_DLMALLOC (char, filenamesize);
     2703+       if (base_name && *base_name)
     2704+         {
     2705+           if (filename[lendir -1] != '/')
     2706+             filename[lendir++] = '/';
     2707+           strcpy (filename +lendir, base_name);
     2708+         }
     2709 
     2710-         if (!filename)
     2711-           {
     2712-             MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     2713-             goto cleanup;
     2714-           }
     2715-       }
     2716+       if ((result = (*func) (filename, data1, data2)))
     2717+         {
     2718+           break;
     2719+         }
     2720+      }
     2721+  }
     2722 
     2723-      strncpy(filename, cur, lendir);
     2724-      if (filename[lendir-1] != '/')
     2725-       {
     2726-         filename[lendir++] = '/';
     2727-       }
     2728-      strcpy(filename+lendir, basename);
     2729-      if (handle)
     2730-       {
     2731-         if (tryall_dlopen (handle, filename) == 0)
     2732-           {
     2733-             result = (lt_ptr) handle;
     2734-             goto cleanup;
     2735-           }
     2736-       }
     2737-      else
     2738-       {
     2739-         FILE *file = fopen (filename, LT_READTEXT_MODE);
     2740-         if (file)
     2741-           {
     2742-             LT_DLFREE (*pdir);
     2743+ cleanup:
     2744+  LT_DLFREE (argz);
     2745+  LT_DLFREE (canonical);
     2746+  LT_DLFREE (filename);
     2747 
     2748-             filename[lendir] = '\0';
     2749-             *pdir = strdup(filename);
     2750-             if (!*pdir)
     2751-               {
     2752-                 /* We could have even avoided the strdup,
     2753-                    but there would be some memory overhead. */
     2754-                 *pdir = filename;
     2755-                 filename = 0;
     2756-               }
     2757+  LT_DLMUTEX_UNLOCK ();
     2758+
     2759+  return result;
     2760+}
     2761+
     2762+/* If FILEPATH can be opened, store the name of the directory component
     2763+   in DATA1, and the opened FILE* structure address in DATA2.  Otherwise
     2764+   DATA1 is unchanged, but DATA2 is set to a pointer to NULL.  */
     2765+static int
     2766+find_file_callback (filename, data1, data2)
     2767+     char *filename;
     2768+     lt_ptr data1;
     2769+     lt_ptr data2;
     2770+{
     2771+  char      **pdir     = (char **) data1;
     2772+  FILE      **pfile    = (FILE **) data2;
     2773+  int       is_done    = 0;
     2774+
     2775+  assert (filename && *filename);
     2776+  assert (pdir);
     2777+  assert (pfile);
     2778+
     2779+  if ((*pfile = fopen (filename, LT_READTEXT_MODE)))
     2780+    {
     2781+      char *dirend = strrchr (filename, '/');
     2782+
     2783+      if (dirend > filename)
     2784+       *dirend   = LT_EOS_CHAR;
     2785+
     2786+      LT_DLFREE (*pdir);
     2787+      *pdir   = lt_estrdup (filename);
     2788+      is_done = (*pdir == 0) ? -1 : 1;
     2789+    }
     2790+
     2791+  return is_done;
     2792+}
     2793+
     2794+static FILE *
     2795+find_file (search_path, base_name, pdir)
     2796+     const char *search_path;
     2797+     const char *base_name;
     2798+     char **pdir;
     2799+{
     2800+  FILE *file = 0;
     2801+
     2802+  foreach_dirinpath (search_path, base_name, find_file_callback, pdir, &file);
     2803+
     2804+  return file;
     2805+}
     2806+
     2807+static int
     2808+find_handle_callback (filename, data, ignored)
     2809+     char *filename;
     2810+     lt_ptr data;
     2811+     lt_ptr ignored;
     2812+{
     2813+  lt_dlhandle  *handle         = (lt_dlhandle *) data;
     2814+  int          notfound        = access (filename, R_OK);
     2815+
     2816+  /* Bail out if file cannot be read...  */
     2817+  if (notfound)
     2818+    return 0;
     2819 
     2820-             result = (lt_ptr) file;
     2821-             goto cleanup;
     2822-           }
     2823-       }
     2824-    }
     2825+  /* Try to dlopen the file, but do not continue searching in any
     2826+     case.  */
     2827+  if (tryall_dlopen (handle, filename) != 0)
     2828+    *handle = 0;
     2829 
     2830-  MUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND));
     2831+  return 1;
     2832+}
     2833 
     2834- cleanup:
     2835-  LT_DLFREE (filename);
     2836-  LT_DLFREE (canonical);
     2837+/* If HANDLE was found return it, otherwise return 0.  If HANDLE was
     2838+   found but could not be opened, *HANDLE will be set to 0.  */
     2839+static lt_dlhandle *
     2840+find_handle (search_path, base_name, handle)
     2841+     const char *search_path;
     2842+     const char *base_name;
     2843+     lt_dlhandle *handle;
     2844+{
     2845+  if (!search_path)
     2846+    return 0;
     2847 
     2848-  MUTEX_UNLOCK ();
     2849+  if (!foreach_dirinpath (search_path, base_name, find_handle_callback,
     2850+                         handle, 0))
     2851+    return 0;
     2852 
     2853-  return result;
     2854+  return handle;
     2855 }
     2856 
     2857 static int
     2858-load_deplibs(handle, deplibs)
     2859+load_deplibs (handle, deplibs)
     2860      lt_dlhandle handle;
     2861      char *deplibs;
     2862 {
     2863 #if LTDL_DLOPEN_DEPLIBS
     2864-  char *p, *save_search_path;
     2865+  char *p, *save_search_path = 0;
     2866   int   depcount = 0;
     2867   int  i;
     2868   char **names = 0;
     2869@@ -1799,12 +2815,12 @@
     2870     }
     2871   ++errors;
     2872 
     2873-  MUTEX_LOCK ();
     2874-  save_search_path = strdup (user_search_path);
     2875-  if (user_search_path && !save_search_path)
     2876+  LT_DLMUTEX_LOCK ();
     2877+  if (user_search_path)
     2878     {
     2879-      MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     2880-      goto cleanup;
     2881+      save_search_path = lt_estrdup (user_search_path);
     2882+      if (!save_search_path)
     2883+       goto cleanup;
     2884     }
     2885 
     2886   /* extract search paths and count deplibs */
     2887@@ -1846,7 +2862,7 @@
     2888   LT_DLFREE (user_search_path);
     2889   user_search_path = save_search_path;
     2890 
     2891-  MUTEX_UNLOCK ();
     2892+  LT_DLMUTEX_UNLOCK ();
     2893 
     2894   if (!depcount)
     2895     {
     2896@@ -1854,11 +2870,9 @@
     2897       goto cleanup;
     2898     }
     2899 
     2900-  names = LT_DLMALLOC (char *, depcount * sizeof (char*));
     2901+  names = LT_EMALLOC (char *, depcount * sizeof (char*));
     2902   if (!names)
     2903-    {
     2904-      goto cleanup;
     2905-    }
     2906+    goto cleanup;
     2907 
     2908   /* now only extract the actual deplibs */
     2909   depcount = 0;
     2910@@ -1884,25 +2898,18 @@
     2911              *end = 0; /* set a temporary string terminator */
     2912              if (strncmp(p, "-l", 2) == 0)
     2913                {
     2914-                 name = LT_DLMALLOC (char, 3+ /* "lib" */ strlen (p+2) + 1);
     2915+                 size_t name_len = 3+ /* "lib" */ LT_STRLEN (p + 2);
     2916+                 name = LT_EMALLOC (char, 1+ name_len);
     2917                  if (name)
     2918-                   {
     2919-                     sprintf (name, "lib%s", p+2);
     2920-                   }
     2921+                   sprintf (name, "lib%s", p+2);
     2922                }
     2923              else
     2924-               {
     2925-                 name = strdup(p);
     2926-               }
     2927+               name = lt_estrdup(p);
     2928 
     2929-             if (name)
     2930-               {
     2931-                 names[depcount++] = name;
     2932-               }
     2933-             else
     2934-               {
     2935-                 goto cleanup_names;
     2936-               }
     2937+             if (!name)
     2938+               goto cleanup_names;
     2939+
     2940+             names[depcount++] = name;
     2941              *end = save;
     2942            }
     2943          p = end;
     2944@@ -1918,11 +2925,9 @@
     2945     {
     2946       int      j = 0;
     2947 
     2948-      handle->deplibs = (lt_dlhandle*) LT_DLMALLOC (lt_dlhandle *, depcount);
     2949+      handle->deplibs = (lt_dlhandle*) LT_EMALLOC (lt_dlhandle *, depcount);
     2950       if (!handle->deplibs)
     2951-           {
     2952-         goto cleanup;
     2953-           }
     2954+       goto cleanup;
     2955 
     2956       for (i = 0; i < depcount; ++i)
     2957        {
     2958@@ -1951,7 +2956,7 @@
     2959 }
     2960 
     2961 static int
     2962-unload_deplibs(handle)
     2963+unload_deplibs (handle)
     2964      lt_dlhandle handle;
     2965 {
     2966   int i;
     2967@@ -1971,7 +2976,7 @@
     2968   return errors;
     2969 }
     2970 
     2971-static inline int
     2972+static int
     2973 trim (dest, str)
     2974      char **dest;
     2975      const char *str;
     2976@@ -1979,22 +2984,19 @@
     2977   /* remove the leading and trailing "'" from str
     2978      and store the result in dest */
     2979   const char *end   = strrchr (str, '\'');
     2980-  int  len         = strlen  (str);
     2981+  size_t len       = LT_STRLEN (str);
     2982   char *tmp;
     2983 
     2984   LT_DLFREE (*dest);
     2985 
     2986   if (len > 3 && str[0] == '\'')
     2987     {
     2988-      tmp = LT_DLMALLOC (char, end - str);
     2989+      tmp = LT_EMALLOC (char, end - str);
     2990       if (!tmp)
     2991-       {
     2992-         last_error = LT_DLSTRERROR (NO_MEMORY);
     2993-         return 1;
     2994-       }
     2995+       return 1;
     2996 
     2997       strncpy(tmp, &str[1], (end - str) - 1);
     2998-      tmp[len-3] = '\0';
     2999+      tmp[len-3] = LT_EOS_CHAR;
     3000       *dest = tmp;
     3001     }
     3002   else
     3003@@ -2005,8 +3007,8 @@
     3004   return 0;
     3005 }
     3006 
     3007-static inline int
     3008-free_vars( dlname, oldname, libdir, deplibs)
     3009+static int
     3010+free_vars (dlname, oldname, libdir, deplibs)
     3011      char *dlname;
     3012      char *oldname;
     3013      char *libdir;
     3014@@ -2020,87 +3022,93 @@
     3015   return 0;
     3016 }
     3017 
     3018-lt_dlhandle
     3019-lt_dlopen (filename)
     3020+static int
     3021+try_dlopen (phandle, filename)
     3022+     lt_dlhandle *phandle;
     3023      const char *filename;
     3024 {
     3025-  lt_dlhandle handle = 0, newhandle;
     3026-  const char *ext;
     3027-  const char *saved_error;
     3028-  char *canonical = 0, *basename = 0, *dir = 0, *name = 0;
     3029+  const char * ext             = 0;
     3030+  const char * saved_error     = 0;
     3031+  char *       canonical       = 0;
     3032+  char *       base_name       = 0;
     3033+  char *       dir             = 0;
     3034+  char *       name            = 0;
     3035+  int          errors          = 0;
     3036+  lt_dlhandle  newhandle;
     3037+
     3038+  assert (phandle);
     3039+  assert (*phandle == 0);
     3040 
     3041-  MUTEX_GETERROR (saved_error);
     3042+  LT_DLMUTEX_GETERROR (saved_error);
     3043 
     3044   /* dlopen self? */
     3045   if (!filename)
     3046     {
     3047-      handle = (lt_dlhandle) LT_DLMALLOC (struct lt_dlhandle_struct, 1);
     3048-      if (!handle)
     3049-       {
     3050-         MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     3051-         return 0;
     3052-       }
     3053-      memset( handle, 0, sizeof( struct lt_dlhandle_struct ) );
     3054+      *phandle = (lt_dlhandle) LT_EMALLOC (struct lt_dlhandle_struct, 1);
     3055+      if (*phandle == 0)
     3056+       return 1;
     3057 
     3058-      handle->info.ref_count   = 0;
     3059-      handle->depcount         = 0;
     3060-      handle->deplibs          = 0;
     3061-      handle->caller_data      = 0;
     3062-      newhandle                        = handle;
     3063+      memset (*phandle, 0, sizeof(struct lt_dlhandle_struct));
     3064+      newhandle        = *phandle;
     3065 
     3066       /* lt_dlclose()ing yourself is very bad!  Disallow it.  */
     3067-      LT_DLSET_FLAG (handle, LT_DLRESIDENT_FLAG);
     3068+      LT_DLSET_FLAG (*phandle, LT_DLRESIDENT_FLAG);
     3069 
     3070       if (tryall_dlopen (&newhandle, 0) != 0)
     3071        {
     3072-         LT_DLFREE (handle);
     3073-         return 0;
     3074+         LT_DLFREE (*phandle);
     3075+         return 1;
     3076        }
     3077+
     3078       goto register_handle;
     3079     }
     3080 
     3081-  canonical = canonicalize_path (filename);
     3082-  if (!canonical)
     3083+  assert (filename && *filename);
     3084+
     3085+  /* Doing this immediately allows internal functions to safely
     3086+     assume only canonicalized paths are passed.  */
     3087+  if (canonicalize_path (filename, &canonical) != 0)
     3088     {
     3089-      MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     3090-      LT_DLFREE (handle);
     3091-      return 0;
     3092+      ++errors;
     3093+      goto cleanup;
     3094     }
     3095 
     3096   /* If the canonical module name is a path (relative or absolute)
     3097      then split it into a directory part and a name part.  */
     3098-  basename = strrchr (canonical, '/');
     3099-  if (basename)
     3100+  base_name = strrchr (canonical, '/');
     3101+  if (base_name)
     3102     {
     3103-      ++basename;
     3104-      dir = LT_DLMALLOC (char, basename - canonical + 1);
     3105+      size_t dirlen = (1+ base_name) - canonical;
     3106+
     3107+      dir = LT_EMALLOC (char, 1+ dirlen);
     3108       if (!dir)
     3109        {
     3110-         MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     3111-         handle = 0;
     3112+         ++errors;
     3113          goto cleanup;
     3114        }
     3115 
     3116-      strncpy (dir, canonical, basename - canonical);
     3117-      dir[basename - canonical] = '\0';
     3118+      strncpy (dir, canonical, dirlen);
     3119+      dir[dirlen] = LT_EOS_CHAR;
     3120+
     3121+      ++base_name;
     3122     }
     3123   else
     3124-    {
     3125-      basename = canonical;
     3126-    }
     3127+    LT_DLMEM_REASSIGN (base_name, canonical);
     3128+
     3129+  assert (base_name && *base_name);
     3130 
     3131   /* Check whether we are opening a libtool module (.la extension).  */
     3132-  ext = strrchr(basename, '.');
     3133-  if (ext && strcmp(ext, ".la") == 0)
     3134+  ext = strrchr (base_name, '.');
     3135+  if (ext && strcmp (ext, archive_ext) == 0)
     3136     {
     3137       /* this seems to be a libtool module */
     3138-      FILE     *file = 0;
     3139-      int      i;
     3140-      char     *dlname = 0, *old_name = 0;
     3141-      char     *libdir = 0, *deplibs = 0;
     3142-      char     *line;
     3143+      FILE *   file     = 0;
     3144+      char *   dlname   = 0;
     3145+      char *   old_name = 0;
     3146+      char *   libdir   = 0;
     3147+      char *   deplibs  = 0;
     3148+      char *    line    = 0;
     3149       size_t   line_len;
     3150-      int      error = 0;
     3151 
     3152       /* if we can't find the installed flag, it is probably an
     3153         installed libtool archive, produced with an old version
     3154@@ -2108,403 +3116,644 @@
     3155       int      installed = 1;
     3156 
     3157       /* extract the module name from the file name */
     3158-      name = LT_DLMALLOC (char, ext - basename + 1);
     3159+      name = LT_EMALLOC (char, ext - base_name + 1);
     3160       if (!name)
     3161        {
     3162-         MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     3163-         handle = 0;
     3164+         ++errors;
     3165          goto cleanup;
     3166-      }
     3167+       }
     3168 
     3169-    /* canonicalize the module name */
     3170-    for (i = 0; i < ext - basename; ++i)
     3171+      /* canonicalize the module name */
     3172       {
     3173-       if (isalnum ((int)(basename[i])))
     3174-         {
     3175-           name[i] = basename[i];
     3176-         }
     3177-       else
     3178+        size_t i;
     3179+        for (i = 0; i < ext - base_name; ++i)
     3180          {
     3181-           name[i] = '_';
     3182+           if (isalnum ((int)(base_name[i])))
     3183+             {
     3184+               name[i] = base_name[i];
     3185+             }
     3186+           else
     3187+             {
     3188+               name[i] = '_';
     3189+             }
     3190          }
     3191+        name[ext - base_name] = LT_EOS_CHAR;
     3192       }
     3193 
     3194-    name[ext - basename] = '\0';
     3195+      /* Now try to open the .la file.  If there is no directory name
     3196+         component, try to find it first in user_search_path and then other
     3197+         prescribed paths.  Otherwise (or in any case if the module was not
     3198+         yet found) try opening just the module name as passed.  */
     3199+      if (!dir)
     3200+       {
     3201+         const char *search_path;
     3202 
     3203-    /* Now try to open the .la file.  If there is no directory name
     3204-       component, try to find it first in user_search_path and then other
     3205-       prescribed paths.  Otherwise (or in any case if the module was not
     3206-       yet found) try opening just the module name as passed.  */
     3207-    if (!dir)
     3208-      {
     3209-       file = (FILE*) find_file(basename, user_search_path, &dir, 0);
     3210-       if (!file)
     3211-         {
     3212-           file = (FILE*) find_file(basename, getenv("LTDL_LIBRARY_PATH"),
     3213-                                    &dir, 0);
     3214-         }
     3215+         LT_DLMUTEX_LOCK ();
     3216+         search_path = user_search_path;
     3217+         if (search_path)
     3218+           file = find_file (user_search_path, base_name, &dir);
     3219+         LT_DLMUTEX_UNLOCK ();
     3220+
     3221+         if (!file)
     3222+           {
     3223+             search_path = getenv (LTDL_SEARCHPATH_VAR);
     3224+             if (search_path)
     3225+               file = find_file (search_path, base_name, &dir);
     3226+           }
     3227 
     3228 #ifdef LTDL_SHLIBPATH_VAR
     3229-       if (!file)
     3230-         {
     3231-           file = (FILE*) find_file(basename, getenv(LTDL_SHLIBPATH_VAR),
     3232-                                    &dir, 0);
     3233-         }
     3234+         if (!file)
     3235+           {
     3236+             search_path = getenv (LTDL_SHLIBPATH_VAR);
     3237+             if (search_path)
     3238+               file = find_file (search_path, base_name, &dir);
     3239+           }
     3240 #endif
     3241 #ifdef LTDL_SYSSEARCHPATH
     3242-       if (!file)
     3243-         {
     3244-           file = (FILE*) find_file(basename, sys_search_path, &dir, 0);
     3245-         }
     3246+         if (!file && sys_search_path)
     3247+           {
     3248+             file = find_file (sys_search_path, base_name, &dir);
     3249+           }
     3250 #endif
     3251-      }
     3252-    if (!file)
     3253-      {
     3254-       file = fopen (filename, LT_READTEXT_MODE);
     3255-      }
     3256-    if (!file)
     3257-      {
     3258-       MUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND));
     3259-      }
     3260-
     3261-    if (!file)
     3262-      {
     3263-       handle = 0;
     3264-       goto cleanup;
     3265-      }
     3266+       }
     3267+      if (!file)
     3268+       {
     3269+         file = fopen (filename, LT_READTEXT_MODE);
     3270+       }
     3271 
     3272-    line_len = LT_FILENAME_MAX;
     3273-    line = LT_DLMALLOC (char, line_len);
     3274-    if (!line)
     3275-      {
     3276-       fclose (file);
     3277-       MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     3278-       handle = 0;
     3279-       goto cleanup;
     3280-      }
     3281+      /* If we didn't find the file by now, it really isn't there.  Set
     3282+        the status flag, and bail out.  */
     3283+      if (!file)
     3284+       {
     3285+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND));
     3286+         ++errors;
     3287+         goto cleanup;
     3288+       }
     3289 
     3290-    /* read the .la file */
     3291-    while (!feof(file))
     3292-      {
     3293-       if (!fgets (line, line_len, file))
     3294-         {
     3295-           break;
     3296-         }
     3297+      line_len = LT_FILENAME_MAX;
     3298+      line = LT_EMALLOC (char, line_len);
     3299+      if (!line)
     3300+       {
     3301+         fclose (file);
     3302+         ++errors;
     3303+         goto cleanup;
     3304+       }
     3305 
     3306+      /* read the .la file */
     3307+      while (!feof (file))
     3308+       {
     3309+         if (!fgets (line, (int) line_len, file))
     3310+           {
     3311+             break;
     3312+           }
     3313 
     3314-       /* Handle the case where we occasionally need to read a line
     3315-          that is longer than the initial buffer size.  */
     3316-       while (line[strlen(line) -1] != '\n')
     3317-         {
     3318-           line = LT_DLREALLOC (char, line, line_len *2);
     3319-           if (!fgets (&line[line_len -1], line_len +1, file))
     3320-             {
     3321-               break;
     3322-             }
     3323-           line_len *= 2;
     3324-         }
     3325+         /* Handle the case where we occasionally need to read a line
     3326+            that is longer than the initial buffer size.  */
     3327+         while ((line[LT_STRLEN(line) -1] != '\n') && (!feof (file)))
     3328+           {
     3329+             line = LT_DLREALLOC (char, line, line_len *2);
     3330+             if (!fgets (&line[line_len -1], (int) line_len +1, file))
     3331+               {
     3332+                 break;
     3333+               }
     3334+             line_len *= 2;
     3335+           }
     3336 
     3337-       if (line[0] == '\n' || line[0] == '#')
     3338-         {
     3339-           continue;
     3340-         }
     3341+         if (line[0] == '\n' || line[0] == '#')
     3342+           {
     3343+             continue;
     3344+           }
     3345 
     3346 #undef  STR_DLNAME
     3347 #define STR_DLNAME     "dlname="
     3348-       if (strncmp (line, STR_DLNAME, sizeof (STR_DLNAME) - 1) == 0)
     3349-         {
     3350-           error = trim (&dlname, &line[sizeof (STR_DLNAME) - 1]);
     3351-         }
     3352+         if (strncmp (line, STR_DLNAME, sizeof (STR_DLNAME) - 1) == 0)
     3353+           {
     3354+             errors += trim (&dlname, &line[sizeof (STR_DLNAME) - 1]);
     3355+           }
     3356 
     3357 #undef  STR_OLD_LIBRARY
     3358 #define STR_OLD_LIBRARY        "old_library="
     3359-       else if (strncmp (line, STR_OLD_LIBRARY,
     3360-                         sizeof (STR_OLD_LIBRARY) - 1) == 0)
     3361-         {
     3362-           error = trim (&old_name, &line[sizeof (STR_OLD_LIBRARY) - 1]);
     3363-         }
     3364+         else if (strncmp (line, STR_OLD_LIBRARY,
     3365+                           sizeof (STR_OLD_LIBRARY) - 1) == 0)
     3366+           {
     3367+             errors += trim (&old_name, &line[sizeof (STR_OLD_LIBRARY) - 1]);
     3368+           }
     3369 #undef  STR_LIBDIR
     3370 #define STR_LIBDIR     "libdir="
     3371-       else if (strncmp (line, STR_LIBDIR, sizeof (STR_LIBDIR) - 1) == 0)
     3372-         {
     3373-           error = trim (&libdir, &line[sizeof(STR_LIBDIR) - 1]);
     3374-         }
     3375+         else if (strncmp (line, STR_LIBDIR, sizeof (STR_LIBDIR) - 1) == 0)
     3376+           {
     3377+             errors += trim (&libdir, &line[sizeof(STR_LIBDIR) - 1]);
     3378+           }
     3379 
     3380 #undef  STR_DL_DEPLIBS
     3381 #define STR_DL_DEPLIBS "dependency_libs="
     3382-       else if (strncmp (line, STR_DL_DEPLIBS,
     3383-                         sizeof (STR_DL_DEPLIBS) - 1) == 0)
     3384-         {
     3385-           error = trim (&deplibs, &line[sizeof (STR_DL_DEPLIBS) - 1]);
     3386-         }
     3387-       else if (strcmp (line, "installed=yes\n") == 0)
     3388-         {
     3389-           installed = 1;
     3390-         }
     3391-       else if (strcmp (line, "installed=no\n") == 0)
     3392-         {
     3393-           installed = 0;
     3394-         }
     3395+         else if (strncmp (line, STR_DL_DEPLIBS,
     3396+                           sizeof (STR_DL_DEPLIBS) - 1) == 0)
     3397+           {
     3398+             errors += trim (&deplibs, &line[sizeof (STR_DL_DEPLIBS) - 1]);
     3399+           }
     3400+         else if (strcmp (line, "installed=yes\n") == 0)
     3401+           {
     3402+             installed = 1;
     3403+           }
     3404+         else if (strcmp (line, "installed=no\n") == 0)
     3405+           {
     3406+             installed = 0;
     3407+           }
     3408 
     3409 #undef  STR_LIBRARY_NAMES
     3410 #define STR_LIBRARY_NAMES "library_names="
     3411-       else if (! dlname && strncmp (line, STR_LIBRARY_NAMES,
     3412-                                     sizeof (STR_LIBRARY_NAMES) - 1) == 0)
     3413-         {
     3414-           char *last_libname;
     3415-           error = trim (&dlname, &line[sizeof (STR_LIBRARY_NAMES) - 1]);
     3416-           if (! error && dlname &&
     3417-               (last_libname = strrchr (dlname, ' ')) != NULL)
     3418-             {
     3419-               last_libname = strdup (last_libname + 1);
     3420-               LT_DLMEM_REASSIGN (dlname, last_libname);
     3421-             }
     3422-         }
     3423+         else if (! dlname && strncmp (line, STR_LIBRARY_NAMES,
     3424+                                       sizeof (STR_LIBRARY_NAMES) - 1) == 0)
     3425+           {
     3426+             char *last_libname;
     3427+             errors += trim (&dlname, &line[sizeof (STR_LIBRARY_NAMES) - 1]);
     3428+             if (!errors
     3429+                 && dlname
     3430+                 && (last_libname = strrchr (dlname, ' ')) != 0)
     3431+               {
     3432+                 last_libname = lt_estrdup (last_libname + 1);
     3433+                 if (!last_libname)
     3434+                   {
     3435+                     ++errors;
     3436+                     goto cleanup;
     3437+                   }
     3438+                 LT_DLMEM_REASSIGN (dlname, last_libname);
     3439+               }
     3440+           }
     3441 
     3442-       if (error)
     3443-         {
     3444+         if (errors)
     3445            break;
     3446-         }
     3447-      }
     3448+       }
     3449 
     3450-    fclose (file);
     3451-    LT_DLFREE (line);
     3452+      fclose (file);
     3453+      LT_DLFREE (line);
     3454 
     3455-    /* allocate the handle */
     3456-    handle = (lt_dlhandle) LT_DLMALLOC (struct lt_dlhandle_struct, 1);
     3457-    if (!handle || error)
     3458-      {
     3459-        LT_DLFREE (handle);
     3460-       if (!error)
     3461-         {
     3462-           MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     3463-         }
     3464+      /* allocate the handle */
     3465+      *phandle = (lt_dlhandle) LT_EMALLOC (struct lt_dlhandle_struct, 1);
     3466+      if (*phandle == 0)
     3467+       ++errors;
     3468 
     3469-       free_vars (dlname, old_name, libdir, deplibs);
     3470-       /* handle is already set to 0 */
     3471-       goto cleanup;
     3472-      }
     3473-    memset( handle, 0, sizeof( struct lt_dlhandle_struct ) );
     3474+      if (errors)
     3475+       {
     3476+         free_vars (dlname, old_name, libdir, deplibs);
     3477+         LT_DLFREE (*phandle);
     3478+         goto cleanup;
     3479+       }
     3480 
     3481-    handle->info.ref_count = 0;
     3482-    if (load_deplibs (handle, deplibs) == 0)
     3483-      {
     3484-       newhandle = handle;
     3485-       /* find_module may replace newhandle */
     3486-       if (find_module (&newhandle, dir, libdir, dlname, old_name, installed))
     3487-         {
     3488-           unload_deplibs (handle);
     3489-           error = 1;
     3490-         }
     3491-      }
     3492-    else
     3493-      {
     3494-       error = 1;
     3495-      }
     3496+      assert (*phandle);
     3497 
     3498-    free_vars (dlname, old_name, libdir, deplibs);
     3499-    if (error)
     3500-      {
     3501-       LT_DLFREE (handle);
     3502-       goto cleanup;
     3503-      }
     3504+      memset (*phandle, 0, sizeof(struct lt_dlhandle_struct));
     3505+      if (load_deplibs (*phandle, deplibs) == 0)
     3506+       {
     3507+         newhandle = *phandle;
     3508+         /* find_module may replace newhandle */
     3509+         if (find_module (&newhandle, dir, libdir, dlname, old_name, installed))
     3510+           {
     3511+             unload_deplibs (*phandle);
     3512+             ++errors;
     3513+           }
     3514+       }
     3515+      else
     3516+       {
     3517+         ++errors;
     3518+       }
     3519 
     3520-    if (handle != newhandle)
     3521-      {
     3522-       unload_deplibs (handle);
     3523-      } else {
     3524-       LT_DLFREE( handle->info.filename );
     3525-       handle->info.filename = strdup( filename );
     3526-      }
     3527+      free_vars (dlname, old_name, libdir, deplibs);
     3528+      if (errors)
     3529+       {
     3530+         LT_DLFREE (*phandle);
     3531+         goto cleanup;
     3532+       }
     3533+
     3534+      if (*phandle != newhandle)
     3535+       {
     3536+         unload_deplibs (*phandle);
     3537+       }
     3538     }
     3539   else
     3540     {
     3541       /* not a libtool module */
     3542-      handle = (lt_dlhandle) LT_DLMALLOC (struct lt_dlhandle_struct, 1);
     3543-      if (!handle)
     3544+      *phandle = (lt_dlhandle) LT_EMALLOC (struct lt_dlhandle_struct, 1);
     3545+      if (*phandle == 0)
     3546        {
     3547-         MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     3548-         /* handle is already set to 0 */
     3549+         ++errors;
     3550          goto cleanup;
     3551        }
     3552-      memset( handle, 0, sizeof( struct lt_dlhandle_struct ) );
     3553-      handle->info.ref_count = 0;
     3554-      /* non-libtool modules don't have dependencies */
     3555-      handle->depcount    = 0;
     3556-      handle->deplibs    = 0;
     3557-      newhandle                  = handle;
     3558+
     3559+      memset (*phandle, 0, sizeof (struct lt_dlhandle_struct));
     3560+      newhandle = *phandle;
     3561 
     3562       /* If the module has no directory name component, try to find it
     3563         first in user_search_path and then other prescribed paths.
     3564         Otherwise (or in any case if the module was not yet found) try
     3565         opening just the module name as passed.  */
     3566-      if ((dir || (!find_file (basename, user_search_path, 0, &newhandle)
     3567-                     && !find_file (basename, getenv ("LTDL_LIBRARY_PATH"),
     3568-                                    0, &newhandle)
     3569+      if ((dir || (!find_handle (user_search_path, base_name, &newhandle)
     3570+                  && !find_handle (getenv (LTDL_SEARCHPATH_VAR), base_name,
     3571+                                   &newhandle)
     3572 #ifdef LTDL_SHLIBPATH_VAR
     3573-                     && !find_file (basename, getenv (LTDL_SHLIBPATH_VAR),
     3574-                                    0, &newhandle)
     3575+                  && !find_handle (getenv (LTDL_SHLIBPATH_VAR), base_name,
     3576+                                   &newhandle)
     3577 #endif
     3578 #ifdef LTDL_SYSSEARCHPATH
     3579-                     && !find_file (basename, sys_search_path, 0, &newhandle)
     3580+                  && !find_handle (sys_search_path, base_name, &newhandle)
     3581 #endif
     3582-                  )) && tryall_dlopen (&newhandle, filename))
     3583+                  )))
     3584        {
     3585-         LT_DLFREE (handle);
     3586+          if (tryall_dlopen (&newhandle, filename) != 0)
     3587+            {
     3588+              newhandle = NULL;
     3589+            }
     3590+       }
     3591+
     3592+      if (!newhandle)
     3593+       {
     3594+         LT_DLFREE (*phandle);
     3595+         ++errors;
     3596          goto cleanup;
     3597        }
     3598     }
     3599 
     3600  register_handle:
     3601-  LT_DLMEM_REASSIGN (handle, newhandle);
     3602+  LT_DLMEM_REASSIGN (*phandle, newhandle);
     3603 
     3604-  if (handle->info.ref_count == 0)
     3605+  if ((*phandle)->info.ref_count == 0)
     3606     {
     3607-      handle->info.ref_count   = 1;
     3608-      handle->info.name                = name;
     3609-      handle->next             = handles;
     3610+      (*phandle)->info.ref_count       = 1;
     3611+      LT_DLMEM_REASSIGN ((*phandle)->info.name, name);
     3612 
     3613-      MUTEX_LOCK ();
     3614-      handles                  = handle;
     3615-      MUTEX_UNLOCK ();
     3616-
     3617-      name = 0;        /* don't free this during `cleanup' */
     3618+      LT_DLMUTEX_LOCK ();
     3619+      (*phandle)->next         = handles;
     3620+      handles                  = *phandle;
     3621+      LT_DLMUTEX_UNLOCK ();
     3622     }
     3623 
     3624-  MUTEX_SETERROR (saved_error);
     3625+  LT_DLMUTEX_SETERROR (saved_error);
     3626 
     3627  cleanup:
     3628   LT_DLFREE (dir);
     3629   LT_DLFREE (name);
     3630   LT_DLFREE (canonical);
     3631 
     3632+  return errors;
     3633+}
     3634+
     3635+lt_dlhandle
     3636+lt_dlopen (filename)
     3637+     const char *filename;
     3638+{
     3639+  lt_dlhandle handle = 0;
     3640+
     3641+  /* Just incase we missed a code path in try_dlopen() that reports
     3642+     an error, but forgets to reset handle... */
     3643+  if (try_dlopen (&handle, filename) != 0)
     3644+    return 0;
     3645+
     3646   return handle;
     3647 }
     3648 
     3649+/* If the last error messge store was `FILE_NOT_FOUND', then return
     3650+   non-zero.  */
     3651+static int
     3652+file_not_found ()
     3653+{
     3654+  const char *error = 0;
     3655+
     3656+  LT_DLMUTEX_GETERROR (error);
     3657+  if (error == LT_DLSTRERROR (FILE_NOT_FOUND))
     3658+    return 1;
     3659+
     3660+  return 0;
     3661+}
     3662+
     3663+/* If FILENAME has an ARCHIVE_EXT or SHLIB_EXT extension, try to
     3664+   open the FILENAME as passed.  Otherwise try appending ARCHIVE_EXT,
     3665+   and if a file is still not found try again with SHLIB_EXT appended
     3666+   instead.  */
     3667 lt_dlhandle
     3668 lt_dlopenext (filename)
     3669      const char *filename;
     3670 {
     3671-  lt_dlhandle handle;
     3672-  char *tmp;
     3673-  int  len;
     3674-  const char *saved_error;
     3675-
     3676-  MUTEX_GETERROR (saved_error);
     3677+  lt_dlhandle  handle          = 0;
     3678+  char *       tmp             = 0;
     3679+  char *       ext             = 0;
     3680+  size_t       len;
     3681+  int          errors          = 0;
     3682 
     3683   if (!filename)
     3684     {
     3685       return lt_dlopen (filename);
     3686     }
     3687 
     3688-  len = strlen (filename);
     3689-  if (!len)
     3690-    {
     3691-      MUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND));
     3692-      return 0;
     3693-    }
     3694-
     3695-  tmp = LT_DLMALLOC (char, len+4);
     3696-  if (!tmp)
     3697-    {
     3698-      MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     3699-      return 0;
     3700-    }
     3701-  strcpy (tmp, filename);
     3702+  assert (filename);
     3703 
     3704-#ifdef _AIX
     3705-  tmp[len] = '\0';
     3706+  len = LT_STRLEN (filename);
     3707+  ext = strrchr (filename, '.');
     3708 
     3709-  /* find by info.name in the list */
     3710-  handle = sys_dl_search_by_name( tmp );
     3711-  if (handle)
     3712+  /* If FILENAME already bears a suitable extension, there is no need
     3713+     to try appending additional extensions.  */
     3714+  if (ext && ((strcmp (ext, archive_ext) == 0)
     3715+#ifdef LTDL_SHLIB_EXT
     3716+             || (strcmp (ext, shlib_ext) == 0)
     3717+#endif
     3718+      ))
     3719     {
     3720-      if( LT_DLGET_FLAG (handle, LT_DLNOTFOUND_FLAG) )
     3721-        {
     3722-          /* don't search libm and libstdc++ over and over again,
     3723-           * they are hardlinked and symbols are exported by the
     3724-           * executable */
     3725-          MUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND));
     3726-          LT_DLFREE (tmp);
     3727-          return 0;
     3728-        }
     3729-      MUTEX_SETERROR (saved_error);
     3730-      LT_DLFREE (tmp);
     3731-      return handle;
     3732+      return lt_dlopen (filename);
     3733     }
     3734-#endif /* _AIX */
     3735 
     3736-  /* try "filename.la" */
     3737-  strcat (tmp, ".la");
     3738-  handle = lt_dlopen (tmp);
     3739-  if (handle)
     3740-    {
     3741-      MUTEX_SETERROR (saved_error);
     3742-      LT_DLFREE (tmp);
     3743-      return handle;
     3744-    }
     3745+  /* First try appending ARCHIVE_EXT.  */
     3746+  tmp = LT_EMALLOC (char, len + LT_STRLEN (archive_ext) + 1);
     3747+  if (!tmp)
     3748+    return 0;
     3749 
     3750+  strcpy (tmp, filename);
     3751+  strcat (tmp, archive_ext);
     3752+  errors = try_dlopen (&handle, tmp);
     3753 
     3754-#ifdef _AIX
     3755-  tmp[len] = '\0'; /* delete the ".la" again.  */
     3756
     3757-  /* versioned shared objects can be in .a's */
     3758-  strcat(tmp, ".a");
     3759-  handle = lt_dlopen (tmp);
     3760-  if (handle)
     3761+  /* If we found FILENAME, stop searching -- whether we were able to
     3762+     load the file as a module or not.  If the file exists but loading
     3763+     failed, it is better to return an error message here than to
     3764+     report FILE_NOT_FOUND when the alternatives (foo.so etc) are not
     3765+     in the module search path.  */
     3766+  if (handle || ((errors > 0) && !file_not_found ()))
     3767     {
     3768-      MUTEX_SETERROR (saved_error);
     3769       LT_DLFREE (tmp);
     3770       return handle;
     3771     }
     3772-#endif /* _AIX */
     3773 
     3774 #ifdef LTDL_SHLIB_EXT
     3775-  /* try "filename.EXT" */
     3776-  if (strlen(shlib_ext) > 3)
     3777+  /* Try appending SHLIB_EXT.   */
     3778+  if (LT_STRLEN (shlib_ext) > LT_STRLEN (archive_ext))
     3779     {
     3780       LT_DLFREE (tmp);
     3781-      tmp = LT_DLMALLOC (char, len + strlen (shlib_ext) + 1);
     3782+      tmp = LT_EMALLOC (char, len + LT_STRLEN (shlib_ext) + 1);
     3783       if (!tmp)
     3784-       {
     3785-         MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     3786-         return 0;
     3787-       }
     3788+       return 0;
     3789+
     3790       strcpy (tmp, filename);
     3791     }
     3792   else
     3793     {
     3794-      tmp[len] = '\0';
     3795+      tmp[len] = LT_EOS_CHAR;
     3796     }
     3797 
     3798   strcat(tmp, shlib_ext);
     3799-  handle = lt_dlopen (tmp);
     3800-  if (handle)
     3801+  errors = try_dlopen (&handle, tmp);
     3802+
     3803+  /* As before, if the file was found but loading failed, return now
     3804+     with the current error message.  */
     3805+  if (handle || ((errors > 0) && !file_not_found ()))
     3806     {
     3807-      MUTEX_SETERROR (saved_error);
     3808       LT_DLFREE (tmp);
     3809       return handle;
     3810     }
     3811 #endif
     3812 
     3813-  /* try the normal file name */
     3814-  handle = lt_dlopen (filename);
     3815-  if (handle)
     3816+  /* Still here?  Then we really did fail to locate any of the file
     3817+     names we tried.  */
     3818+  LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND));
     3819+  LT_DLFREE (tmp);
     3820+  return 0;
     3821+}
     3822+
     3823+
     3824+static int
     3825+lt_argz_insert (pargz, pargz_len, before, entry)
     3826+     char **pargz;
     3827+     size_t *pargz_len;
     3828+     char *before;
     3829+     const char *entry;
     3830+{
     3831+  error_t error;
     3832+
     3833+  if ((error = argz_insert (pargz, pargz_len, before, entry)))
     3834     {
     3835-      return handle;
     3836+      switch (error)
     3837+       {
     3838+       case ENOMEM:
     3839+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     3840+         break;
     3841+       default:
     3842+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (UNKNOWN));
     3843+         break;
     3844+       }
     3845+      return 1;
     3846     }
     3847 
     3848-#ifdef _AIX
     3849-  /* put into the can't be found list */
     3850-  tmp[len] = '\0';
     3851-  sys_dl_not_found_entry( tmp );
     3852-#endif /* _AIX */
     3853-
     3854-  MUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND));
     3855-  LT_DLFREE (tmp);
     3856   return 0;
     3857 }
     3858 
     3859+static int
     3860+lt_argz_insertinorder (pargz, pargz_len, entry)
     3861+     char **pargz;
     3862+     size_t *pargz_len;
     3863+     const char *entry;
     3864+{
     3865+  char *before = 0;
     3866+
     3867+  assert (pargz);
     3868+  assert (pargz_len);
     3869+  assert (entry && *entry);
     3870+
     3871+  if (*pargz)
     3872+    while ((before = argz_next (*pargz, *pargz_len, before)))
     3873+      {
     3874+       int cmp = strcmp (entry, before);
     3875+
     3876+       if (cmp < 0)  break;
     3877+       if (cmp == 0) return 0; /* No duplicates! */
     3878+      }
     3879+
     3880+  return lt_argz_insert (pargz, pargz_len, before, entry);
     3881+}
     3882+
     3883+static int
     3884+lt_argz_insertdir (pargz, pargz_len, dirnam, dp)
     3885+     char **pargz;
     3886+     size_t *pargz_len;
     3887+     const char *dirnam;
     3888+     struct dirent *dp;
     3889+{
     3890+  char   *buf      = 0;
     3891+  size_t buf_len    = 0;
     3892+  char   *end      = 0;
     3893+  size_t end_offset = 0;
     3894+  size_t dir_len    = 0;
     3895+  int    errors            = 0;
     3896+
     3897+  assert (pargz);
     3898+  assert (pargz_len);
     3899+  assert (dp);
     3900+
     3901+  dir_len = LT_STRLEN (dirnam);
     3902+  end     = dp->d_name + LT_D_NAMLEN(dp);
     3903+
     3904+  /* Ignore version numbers.  */
     3905+  {
     3906+    char *p;
     3907+    for (p = end; p -1 > dp->d_name; --p)
     3908+      if (strchr (".0123456789", p[-1]) == 0)
     3909+       break;
     3910+
     3911+    if (*p == '.')
     3912+      end = p;
     3913+  }
     3914+
     3915+  /* Ignore filename extension.  */
     3916+  {
     3917+    char *p;
     3918+    for (p = end -1; p > dp->d_name; --p)
     3919+      if (*p == '.')
     3920+       {
     3921+         end = p;
     3922+         break;
     3923+       }
     3924+  }
     3925+
     3926+  /* Prepend the directory name.  */
     3927+  end_offset   = end - dp->d_name;
     3928+  buf_len      = dir_len + 1+ end_offset;
     3929+  buf          = LT_EMALLOC (char, 1+ buf_len);
     3930+  if (!buf)
     3931+    return ++errors;
     3932+
     3933+  assert (buf);
     3934+
     3935+  strcpy  (buf, dirnam);
     3936+  strcat  (buf, "/");
     3937+  strncat (buf, dp->d_name, end_offset);
     3938+  buf[buf_len] = LT_EOS_CHAR;
     3939+
     3940+  /* Try to insert (in order) into ARGZ/ARGZ_LEN.  */
     3941+  if (lt_argz_insertinorder (pargz, pargz_len, buf) != 0)
     3942+    ++errors;
     3943+
     3944+  LT_DLFREE (buf);
     3945+
     3946+  return errors;
     3947+}
     3948+
     3949+static int
     3950+list_files_by_dir (dirnam, pargz, pargz_len)
     3951+     const char *dirnam;
     3952+     char **pargz;
     3953+     size_t *pargz_len;
     3954+{
     3955+  DIR  *dirp     = 0;
     3956+  int    errors          = 0;
     3957+
     3958+  assert (dirnam && *dirnam);
     3959+  assert (pargz);
     3960+  assert (pargz_len);
     3961+  assert (dirnam[LT_STRLEN(dirnam) -1] != '/');
     3962+
     3963+  dirp = opendir (dirnam);
     3964+  if (dirp)
     3965+    {
     3966+      struct dirent *dp        = 0;
     3967+
     3968+      while ((dp = readdir (dirp)))
     3969+       if (dp->d_name[0] != '.')
     3970+         if (lt_argz_insertdir (pargz, pargz_len, dirnam, dp))
     3971+           {
     3972+             ++errors;
     3973+             break;
     3974+           }
     3975+
     3976+      closedir (dirp);
     3977+    }
     3978+  else
     3979+    ++errors;
     3980+
     3981+  return errors;
     3982+}
     3983+
     3984+
     3985+/* If there are any files in DIRNAME, call the function passed in
     3986+   DATA1 (with the name of each file and DATA2 as arguments).  */
     3987+static int
     3988+foreachfile_callback (dirname, data1, data2)
     3989+     char *dirname;
     3990+     lt_ptr data1;
     3991+     lt_ptr data2;
     3992+{
     3993+  int (*func) LT_PARAMS((const char *filename, lt_ptr data))
     3994+       = (int (*) LT_PARAMS((const char *filename, lt_ptr data))) data1;
     3995+
     3996+  int    is_done  = 0;
     3997+  char   *argz     = 0;
     3998+  size_t  argz_len = 0;
     3999+
     4000+  if (list_files_by_dir (dirname, &argz, &argz_len) != 0)
     4001+    goto cleanup;
     4002+  if (!argz)
     4003+    goto cleanup;
     4004+
     4005+  {
     4006+    char *filename = 0;
     4007+    while ((filename = argz_next (argz, argz_len, filename)))
     4008+      if ((is_done = (*func) (filename, data2)))
     4009+       break;
     4010+  }
     4011+
     4012+ cleanup:
     4013+  LT_DLFREE (argz);
     4014+
     4015+  return is_done;
     4016+}
     4017+
     4018+
     4019+/* Call FUNC for each unique extensionless file in SEARCH_PATH, along
     4020+   with DATA.  The filenames passed to FUNC would be suitable for
     4021+   passing to lt_dlopenext.  The extensions are stripped so that
     4022+   individual modules do not generate several entries (e.g. libfoo.la,
     4023+   libfoo.so, libfoo.so.1, libfoo.so.1.0.0).  If SEARCH_PATH is NULL,
     4024+   then the same directories that lt_dlopen would search are examined.  */
     4025+int
     4026+lt_dlforeachfile (search_path, func, data)
     4027+     const char *search_path;
     4028+     int (*func) LT_PARAMS ((const char *filename, lt_ptr data));
     4029+     lt_ptr data;
     4030+{
     4031+  int is_done = 0;
     4032+
     4033+  if (search_path)
     4034+    {
     4035+      /* If a specific path was passed, search only the directories
     4036+        listed in it.  */
     4037+      is_done = foreach_dirinpath (search_path, 0,
     4038+                                  foreachfile_callback, func, data);
     4039+    }
     4040+  else
     4041+    {
     4042+      /* Otherwise search the default paths.  */
     4043+      is_done = foreach_dirinpath (user_search_path, 0,
     4044+                                  foreachfile_callback, func, data);
     4045+      if (!is_done)
     4046+       {
     4047+         is_done = foreach_dirinpath (getenv("LTDL_LIBRARY_PATH"), 0,
     4048+                                      foreachfile_callback, func, data);
     4049+       }
     4050+
     4051+#ifdef LTDL_SHLIBPATH_VAR
     4052+      if (!is_done)
     4053+       {
     4054+         is_done = foreach_dirinpath (getenv(LTDL_SHLIBPATH_VAR), 0,
     4055+                                      foreachfile_callback, func, data);
     4056+       }
     4057+#endif
     4058+#ifdef LTDL_SYSSEARCHPATH
     4059+      if (!is_done)
     4060+       {
     4061+         is_done = foreach_dirinpath (getenv(LTDL_SYSSEARCHPATH), 0,
     4062+                                      foreachfile_callback, func, data);
     4063+       }
     4064+#endif
     4065+    }
     4066+
     4067+  return is_done;
     4068+}
     4069+
     4070 int
     4071 lt_dlclose (handle)
     4072      lt_dlhandle handle;
     4073@@ -2512,7 +3761,7 @@
     4074   lt_dlhandle cur, last;
     4075   int errors = 0;
     4076 
     4077-  MUTEX_LOCK ();
     4078+  LT_DLMUTEX_LOCK ();
     4079 
     4080   /* check whether the handle is valid */
     4081   last = cur = handles;
     4082@@ -2524,7 +3773,7 @@
     4083 
     4084   if (!cur)
     4085     {
     4086-      MUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE));
     4087+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE));
     4088       ++errors;
     4089       goto done;
     4090     }
     4091@@ -2551,6 +3800,9 @@
     4092       errors += handle->loader->module_close (data, handle->module);
     4093       errors += unload_deplibs(handle);
     4094 
     4095+      /* It is up to the callers to free the data itself.  */
     4096+      LT_DLFREE (handle->caller_data);
     4097+
     4098       LT_DLFREE (handle->info.filename);
     4099       LT_DLFREE (handle->info.name);
     4100       LT_DLFREE (handle);
     4101@@ -2560,12 +3812,12 @@
     4102 
     4103   if (LT_DLIS_RESIDENT (handle))
     4104     {
     4105-      MUTEX_SETERROR (LT_DLSTRERROR (CLOSE_RESIDENT_MODULE));
     4106+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CLOSE_RESIDENT_MODULE));
     4107       ++errors;
     4108     }
     4109 
     4110  done:
     4111-  MUTEX_UNLOCK ();
     4112+  LT_DLMUTEX_UNLOCK ();
     4113 
     4114   return errors;
     4115 }
     4116@@ -2575,7 +3827,7 @@
     4117      lt_dlhandle handle;
     4118      const char *symbol;
     4119 {
     4120-  int  lensym;
     4121+  size_t lensym;
     4122   char lsym[LT_SYMBOL_LENGTH];
     4123   char *sym;
     4124   lt_ptr address;
     4125@@ -2583,26 +3835,18 @@
     4126 
     4127   if (!handle)
     4128     {
     4129-      MUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE));
     4130+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE));
     4131       return 0;
     4132     }
     4133 
     4134   if (!symbol)
     4135     {
     4136-      MUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND));
     4137+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND));
     4138       return 0;
     4139     }
     4140 
     4141-  lensym = strlen(symbol);
     4142-  if (handle->loader->sym_prefix)
     4143-    {
     4144-      lensym += strlen(handle->loader->sym_prefix);
     4145-    }
     4146-
     4147-  if (handle->info.name)
     4148-    {
     4149-      lensym += strlen(handle->info.name);
     4150-    }
     4151+  lensym = LT_STRLEN (symbol) + LT_STRLEN (handle->loader->sym_prefix)
     4152+                                       + LT_STRLEN (handle->info.name);
     4153 
     4154   if (lensym + LT_SYMBOL_OVERHEAD < LT_SYMBOL_LENGTH)
     4155     {
     4156@@ -2610,13 +3854,12 @@
     4157     }
     4158   else
     4159     {
     4160-      sym = LT_DLMALLOC (char, lensym + LT_SYMBOL_OVERHEAD + 1);
     4161-    }
     4162-
     4163-  if (!sym)
     4164-    {
     4165-      MUTEX_SETERROR (LT_DLSTRERROR (BUFFER_OVERFLOW));
     4166-      return 0;
     4167+      sym = LT_EMALLOC (char, lensym + LT_SYMBOL_OVERHEAD + 1);
     4168+      if (!sym)
     4169+       {
     4170+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (BUFFER_OVERFLOW));
     4171+         return 0;
     4172+       }
     4173     }
     4174 
     4175   data = handle->loader->dlloader_data;
     4176@@ -2624,7 +3867,7 @@
     4177     {
     4178       const char *saved_error;
     4179 
     4180-      MUTEX_GETERROR (saved_error);
     4181+      LT_DLMUTEX_GETERROR (saved_error);
     4182 
     4183       /* this is a libtool module */
     4184       if (handle->loader->sym_prefix)
     4185@@ -2650,7 +3893,7 @@
     4186            }
     4187          return address;
     4188        }
     4189-      MUTEX_SETERROR (saved_error);
     4190+      LT_DLMUTEX_SETERROR (saved_error);
     4191     }
     4192 
     4193   /* otherwise try "symbol" */
     4194@@ -2678,10 +3921,82 @@
     4195 {
     4196   const char *error;
     4197 
     4198-  MUTEX_GETERROR (error);
     4199-  MUTEX_SETERROR (0);
     4200+  LT_DLMUTEX_GETERROR (error);
     4201+  LT_DLMUTEX_SETERROR (0);
     4202 
     4203-  return error;
     4204+  return error ? error : LT_DLSTRERROR (UNKNOWN);
     4205+}
     4206+
     4207+static int
     4208+lt_dlpath_insertdir (ppath, before, dir)
     4209+     char **ppath;
     4210+     char *before;
     4211+     const char *dir;
     4212+{
     4213+  int    errors                = 0;
     4214+  char  *canonical     = 0;
     4215+  char  *argz          = 0;
     4216+  size_t argz_len      = 0;
     4217+
     4218+  assert (ppath);
     4219+  assert (dir && *dir);
     4220+
     4221+  if (canonicalize_path (dir, &canonical) != 0)
     4222+    {
     4223+      ++errors;
     4224+      goto cleanup;
     4225+    }
     4226+
     4227+  assert (canonical && *canonical);
     4228+
     4229+  /* If *PPATH is empty, set it to DIR.  */
     4230+  if (*ppath == 0)
     4231+    {
     4232+      assert (!before);                /* BEFORE cannot be set without PPATH.  */
     4233+      assert (dir);            /* Without DIR, don't call this function!  */
     4234+
     4235+      *ppath = lt_estrdup (dir);
     4236+      if (*ppath == 0)
     4237+       ++errors;
     4238+
     4239+      return errors;
     4240+    }
     4241+
     4242+  assert (ppath && *ppath);
     4243+
     4244+  if (argzize_path (*ppath, &argz, &argz_len) != 0)
     4245+    {
     4246+      ++errors;
     4247+      goto cleanup;
     4248+    }
     4249+
     4250+  /* Convert BEFORE into an equivalent offset into ARGZ.  This only works
     4251+     if *PPATH is already canonicalized, and hence does not change length
     4252+     with respect to ARGZ.  We canonicalize each entry as it is added to
     4253+     the search path, and don't call this function with (uncanonicalized)
     4254+     user paths, so this is a fair assumption.  */
     4255+  if (before)
     4256+    {
     4257+      assert (*ppath <= before);
     4258+      assert (before - *ppath <= strlen (*ppath));
     4259+
     4260+      before = before - *ppath + argz;
     4261+    }
     4262+
     4263+  if (lt_argz_insert (&argz, &argz_len, before, dir) != 0)
     4264+    {
     4265+      ++errors;
     4266+      goto cleanup;
     4267+    }
     4268+
     4269+  argz_stringify (argz, argz_len, LT_PATHSEP_CHAR);
     4270+  LT_DLMEM_REASSIGN (*ppath,  argz);
     4271+
     4272+ cleanup:
     4273+  LT_DLFREE (canonical);
     4274+  LT_DLFREE (argz);
     4275+
     4276+  return errors;
     4277 }
     4278 
     4279 int
     4280@@ -2690,40 +4005,47 @@
     4281 {
     4282   int errors = 0;
     4283 
     4284-  if (!search_dir || !strlen(search_dir))
     4285+  if (search_dir && *search_dir)
     4286     {
     4287-      return errors;
     4288+      LT_DLMUTEX_LOCK ();
     4289+      if (lt_dlpath_insertdir (&user_search_path, 0, search_dir) != 0)
     4290+       ++errors;
     4291+      LT_DLMUTEX_UNLOCK ();
     4292     }
     4293 
     4294-  MUTEX_LOCK ();
     4295-  if (!user_search_path)
     4296+  return errors;
     4297+}
     4298+
     4299+int
     4300+lt_dlinsertsearchdir (before, search_dir)
     4301+     const char *before;
     4302+     const char *search_dir;
     4303+{
     4304+  int errors = 0;
     4305+
     4306+  if (before)
     4307     {
     4308-      user_search_path = strdup (search_dir);
     4309-      if (!user_search_path)
     4310+      LT_DLMUTEX_LOCK ();
     4311+      if ((before < user_search_path)
     4312+         || (before >= user_search_path + LT_STRLEN (user_search_path)))
     4313        {
     4314-         last_error = LT_DLSTRERROR (NO_MEMORY);
     4315-         ++errors;
     4316+         LT_DLMUTEX_UNLOCK ();
     4317+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_POSITION));
     4318+         return 1;
     4319        }
     4320+      LT_DLMUTEX_UNLOCK ();
     4321     }
     4322-  else
     4323-    {
     4324-      size_t len = strlen (user_search_path) + 1 + strlen (search_dir);
     4325-      char  *new_search_path = LT_DLMALLOC (char, 1+ len);
     4326 
     4327-      if (!new_search_path)
     4328+  if (search_dir && *search_dir)
     4329+    {
     4330+      LT_DLMUTEX_LOCK ();
     4331+      if (lt_dlpath_insertdir (&user_search_path,
     4332+                              (char *) before, search_dir) != 0)
     4333        {
     4334-         MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     4335          ++errors;
     4336        }
     4337-      else
     4338-       {
     4339-         sprintf (new_search_path, "%s%c%s", user_search_path,
     4340-                  LT_PATHSEP_CHAR, search_dir);
     4341-
     4342-         LT_DLMEM_REASSIGN (user_search_path, new_search_path);
     4343-       }
     4344+      LT_DLMUTEX_UNLOCK ();
     4345     }
     4346-  MUTEX_UNLOCK ();
     4347 
     4348   return errors;
     4349 }
     4350@@ -2732,24 +4054,21 @@
     4351 lt_dlsetsearchpath (search_path)
     4352      const char *search_path;
     4353 {
     4354-  int errors = 0;
     4355+  int   errors     = 0;
     4356 
     4357-  MUTEX_LOCK ();
     4358+  LT_DLMUTEX_LOCK ();
     4359   LT_DLFREE (user_search_path);
     4360-  MUTEX_UNLOCK ();
     4361+  LT_DLMUTEX_UNLOCK ();
     4362 
     4363-  if (!search_path || !strlen (search_path))
     4364+  if (!search_path || !LT_STRLEN (search_path))
     4365     {
     4366       return errors;
     4367     }
     4368 
     4369-  MUTEX_LOCK ();
     4370-  user_search_path = strdup (search_path);
     4371-  if (!user_search_path)
     4372-    {
     4373-      ++errors;
     4374-    }
     4375-  MUTEX_UNLOCK ();
     4376+  LT_DLMUTEX_LOCK ();
     4377+  if (canonicalize_path (search_path, &user_search_path) != 0)
     4378+    ++errors;
     4379+  LT_DLMUTEX_UNLOCK ();
     4380 
     4381   return errors;
     4382 }
     4383@@ -2759,9 +4078,9 @@
     4384 {
     4385   const char *saved_path;
     4386 
     4387-  MUTEX_LOCK ();
     4388+  LT_DLMUTEX_LOCK ();
     4389   saved_path = user_search_path;
     4390-  MUTEX_UNLOCK ();
     4391+  LT_DLMUTEX_UNLOCK ();
     4392 
     4393   return saved_path;
     4394 }
     4395@@ -2774,7 +4093,7 @@
     4396 
     4397   if (!handle)
     4398     {
     4399-      MUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE));
     4400+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE));
     4401       ++errors;
     4402     }
     4403   else
     4404@@ -2791,7 +4110,7 @@
     4405 {
     4406   if (!handle)
     4407     {
     4408-      MUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE));
     4409+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE));
     4410       return -1;
     4411     }
     4412 
     4413@@ -2809,7 +4128,7 @@
     4414 {
     4415   if (!handle)
     4416     {
     4417-      MUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE));
     4418+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE));
     4419       return 0;
     4420     }
     4421 
     4422@@ -2820,7 +4139,7 @@
     4423 lt_dlhandle_next (place)
     4424      lt_dlhandle place;
     4425 {
     4426-  return place ? place->next : (lt_dlhandle) 0;
     4427+  return place ? place->next : handles;
     4428 }
     4429 
     4430 int
     4431@@ -2831,7 +4150,7 @@
     4432   int errors = 0;
     4433   lt_dlhandle cur;
     4434 
     4435-  MUTEX_LOCK ();
     4436+  LT_DLMUTEX_LOCK ();
     4437 
     4438   cur = handles;
     4439   while (cur)
     4440@@ -2846,7 +4165,7 @@
     4441        }
     4442     }
     4443 
     4444-  MUTEX_UNLOCK ();
     4445+  LT_DLMUTEX_UNLOCK ();
     4446 
     4447   return errors;
     4448 }
     4449@@ -2854,18 +4173,16 @@
     4450 lt_dlcaller_id
     4451 lt_dlcaller_register ()
     4452 {
     4453-  static int last_caller_id = -1;
     4454+  static lt_dlcaller_id last_caller_id = 0;
     4455   int result;
     4456 
     4457-  MUTEX_LOCK ();
     4458+  LT_DLMUTEX_LOCK ();
     4459   result = ++last_caller_id;
     4460-  MUTEX_UNLOCK ();
     4461+  LT_DLMUTEX_UNLOCK ();
     4462 
     4463   return result;
     4464 }
     4465 
     4466-#define N_ELEMENTS(a)  (sizeof(a) / sizeof(*(a)))
     4467-
     4468 lt_ptr
     4469 lt_dlcaller_set_data (key, handle, data)
     4470      lt_dlcaller_id key;
     4471@@ -2878,10 +4195,11 @@
     4472 
     4473   /* This needs to be locked so that the caller data can be updated
     4474      simultaneously by different threads.  */
     4475-  MUTEX_LOCK ();
     4476+  LT_DLMUTEX_LOCK ();
     4477 
     4478   if (handle->caller_data)
     4479-    n_elements = N_ELEMENTS (handle->caller_data);
     4480+    while (handle->caller_data[n_elements].key)
     4481+      ++n_elements;
     4482 
     4483   for (i = 0; i < n_elements; ++i)
     4484     {
     4485@@ -2893,31 +4211,29 @@
     4486     }
     4487 
     4488   /* Ensure that there is enough room in this handle's caller_data
     4489-     array to accept a new element.  */
     4490+     array to accept a new element (and an empty end marker).  */
     4491   if (i == n_elements)
     4492     {
     4493       lt_caller_data *temp
     4494-       = LT_DLREALLOC (lt_caller_data, handle->caller_data, 1+ n_elements);
     4495+       = LT_DLREALLOC (lt_caller_data, handle->caller_data, 2+ n_elements);
     4496 
     4497-      if (temp == 0)
     4498+      if (!temp)
     4499        {
     4500-         MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     4501-         stale =  (lt_ptr) 0;
     4502+         stale = 0;
     4503          goto done;
     4504        }
     4505-      else
     4506-       {
     4507-         handle->caller_data = temp;
     4508-       }
     4509+
     4510+      handle->caller_data = temp;
     4511 
     4512       /* We only need this if we needed to allocate a new caller_data.  */
     4513       handle->caller_data[i].key  = key;
     4514+      handle->caller_data[1+ i].key = 0;
     4515     }
     4516 
     4517   handle->caller_data[i].data = data;
     4518 
     4519  done:
     4520-  MUTEX_UNLOCK ();
     4521+  LT_DLMUTEX_UNLOCK ();
     4522 
     4523   return stale;
     4524 }
     4525@@ -2928,19 +4244,15 @@
     4526      lt_dlhandle handle;
     4527 {
     4528   lt_ptr result = (lt_ptr) 0;
     4529-  int n_elements = 0;
     4530 
     4531   /* This needs to be locked so that the caller data isn't updated by
     4532      another thread part way through this function.  */
     4533-  MUTEX_LOCK ();
     4534-
     4535-  if (handle->caller_data)
     4536-    n_elements = N_ELEMENTS (handle->caller_data);
     4537+  LT_DLMUTEX_LOCK ();
     4538 
     4539   /* Locate the index of the element with a matching KEY.  */
     4540   {
     4541     int i;
     4542-    for (i = 0; i < n_elements; ++i)
     4543+    for (i = 0; handle->caller_data[i].key; ++i)
     4544       {
     4545        if (handle->caller_data[i].key == key)
     4546          {
     4547@@ -2950,7 +4262,7 @@
     4548       }
     4549   }
     4550 
     4551-  MUTEX_UNLOCK ();
     4552+  LT_DLMUTEX_UNLOCK ();
     4553 
     4554   return result;
     4555 }
     4556@@ -2974,17 +4286,14 @@
     4557       || (dlloader->module_close == 0)
     4558       || (dlloader->find_sym == 0))
     4559     {
     4560-      MUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER));
     4561+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER));
     4562       return 1;
     4563     }
     4564 
     4565   /* Create a new dlloader node with copies of the user callbacks.  */
     4566-  node = LT_DLMALLOC (lt_dlloader, 1);
     4567-  if (node == 0)
     4568-    {
     4569-      MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     4570-      return 1;
     4571-    }
     4572+  node = LT_EMALLOC (lt_dlloader, 1);
     4573+  if (!node)
     4574+    return 1;
     4575 
     4576   node->next           = 0;
     4577   node->loader_name    = loader_name;
     4578@@ -2995,7 +4304,7 @@
     4579   node->find_sym       = dlloader->find_sym;
     4580   node->dlloader_data  = dlloader->dlloader_data;
     4581 
     4582-  MUTEX_LOCK ();
     4583+  LT_DLMUTEX_LOCK ();
     4584   if (!loaders)
     4585     {
     4586       /* If there are no loaders, NODE becomes the list! */
     4587@@ -3028,7 +4337,7 @@
     4588 
     4589       if (ptr->next != place)
     4590        {
     4591-         last_error = LT_DLSTRERROR (INVALID_LOADER);
     4592+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER));
     4593          ++errors;
     4594        }
     4595       else
     4596@@ -3039,7 +4348,7 @@
     4597        }
     4598     }
     4599 
     4600-  MUTEX_UNLOCK ();
     4601+  LT_DLMUTEX_UNLOCK ();
     4602 
     4603   return errors;
     4604 }
     4605@@ -3054,18 +4363,18 @@
     4606 
     4607   if (!place)
     4608     {
     4609-      MUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER));
     4610+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER));
     4611       return 1;
     4612     }
     4613 
     4614-  MUTEX_LOCK ();
     4615+  LT_DLMUTEX_LOCK ();
     4616 
     4617   /* Fail if there are any open modules which use this loader. */
     4618   for  (handle = handles; handle; handle = handle->next)
     4619     {
     4620       if (handle->loader == place)
     4621        {
     4622-         MUTEX_SETERROR (LT_DLSTRERROR (REMOVE_LOADER));
     4623+         LT_DLMUTEX_SETERROR (LT_DLSTRERROR (REMOVE_LOADER));
     4624          ++errors;
     4625          goto done;
     4626        }
     4627@@ -3100,7 +4409,7 @@
     4628   LT_DLFREE (place);
     4629 
     4630  done:
     4631-  MUTEX_UNLOCK ();
     4632+  LT_DLMUTEX_UNLOCK ();
     4633 
     4634   return errors;
     4635 }
     4636@@ -3111,9 +4420,9 @@
     4637 {
     4638   lt_dlloader *next;
     4639 
     4640-  MUTEX_LOCK ();
     4641+  LT_DLMUTEX_LOCK ();
     4642   next = place ? place->next : loaders;
     4643-  MUTEX_UNLOCK ();
     4644+  LT_DLMUTEX_UNLOCK ();
     4645 
     4646   return next;
     4647 }
     4648@@ -3126,13 +4435,13 @@
     4649 
     4650   if (place)
     4651     {
     4652-      MUTEX_LOCK ();
     4653+      LT_DLMUTEX_LOCK ();
     4654       name = place ? place->loader_name : 0;
     4655-      MUTEX_UNLOCK ();
     4656+      LT_DLMUTEX_UNLOCK ();
     4657     }
     4658   else
     4659     {
     4660-      MUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER));
     4661+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER));
     4662     }
     4663 
     4664   return name;
     4665@@ -3146,13 +4455,13 @@
     4666 
     4667   if (place)
     4668     {
     4669-      MUTEX_LOCK ();
     4670+      LT_DLMUTEX_LOCK ();
     4671       data = place ? &(place->dlloader_data) : 0;
     4672-      MUTEX_UNLOCK ();
     4673+      LT_DLMUTEX_UNLOCK ();
     4674     }
     4675   else
     4676     {
     4677-      MUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER));
     4678+      LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER));
     4679     }
     4680 
     4681   return data;
     4682@@ -3164,7 +4473,7 @@
     4683 {
     4684   lt_dlloader *place = 0;
     4685 
     4686-  MUTEX_LOCK ();
     4687+  LT_DLMUTEX_LOCK ();
     4688   for (place = loaders; place; place = place->next)
     4689     {
     4690       if (strcmp (place->loader_name, loader_name) == 0)
     4691@@ -3172,236 +4481,7 @@
     4692          break;
     4693        }
     4694     }
     4695-  MUTEX_UNLOCK ();
     4696+  LT_DLMUTEX_UNLOCK ();
     4697 
     4698   return place;
     4699 }
     4700-
     4701-#ifdef _AIX
     4702-
     4703-/* #define DBG_PRNT(a) fprintf a ; */
     4704-#define DBG_PRNT(a)
     4705-
     4706-static void
     4707-sys_dl_debug_print_loaded( const char* filename )
     4708-{
     4709-    int                    ret;
     4710-    static unsigned char   buffer[1024*1024];
     4711-    struct ld_info*        info;
     4712-
     4713-    ret = loadquery( L_GETINFO, buffer, 1024*1024 );
     4714-    if( ret >= 0 )
     4715-      {
     4716-        DBG_PRNT((stderr, "%d: Successfully loaded %s\n",
     4717-               __LINE__, filename ))
     4718-        info = (struct ld_info*)buffer;
     4719-        do
     4720-          {
     4721-           const char* c;
     4722-           const char* d;
     4723-           c = info->ldinfo_filename;
     4724-           d = &c[strlen(c)];
     4725-           d++;
     4726-           DBG_PRNT((stderr, "%d: path name %s, member name %s\n",
     4727-                   __LINE__,
     4728-                   c,d))
     4729-           info = (struct ld_info*)(((char*)info)+info->ldinfo_next);
     4730-          }
     4731-        while( info->ldinfo_next != 0 );
     4732-      }
     4733-    else if( errno == ENOMEM )
     4734-      {
     4735-        DBG_PRNT((stderr, "%d: Successfully loaded %s, loadquery needs larger buffer\n",
     4736-               __LINE__, filename ))
     4737-      }
     4738-    else
     4739-      {
     4740-        DBG_PRNT((stderr, "Loadquery failure\n"))
     4741-      }
     4742-}
     4743-
     4744-static void
     4745-sys_dl_debug_print_handle( lt_dlhandle handle )
     4746-{
     4747-    DBG_PRNT((stderr," > next          = %ld\n", (long)handle->next ))
     4748-    DBG_PRNT((stderr," > loader        = %ld\n", (long)handle->loader ))
     4749-    DBG_PRNT((stderr," > info.filename = %s\n", handle->info.filename ))
     4750-    DBG_PRNT((stderr," > info.name     = %s\n", handle->info.name ))
     4751-    DBG_PRNT((stderr," > info.ref_count= %d\n", handle->info.ref_count ))
     4752-    DBG_PRNT((stderr," > depcount      = %d\n", handle->depcount ))
     4753-    DBG_PRNT((stderr," > resident flags %s\n",
     4754-            (LT_DLGET_FLAG (handle, LT_DLRESIDENT_FLAG)?"yes":"no")))
     4755-    DBG_PRNT((stderr," > not found flags %s\n",
     4756-            (LT_DLGET_FLAG (handle, LT_DLNOTFOUND_FLAG)?"yes":"no")))
     4757-}
     4758-
     4759-static void
     4760-sys_dl_init( )
     4761-{
     4762-  char*           buffer = NULL;
     4763-  size_t          buf_size = 512;
     4764-  int             ret;
     4765-  const char*     libname;
     4766-  const char*     modname;
     4767-  struct ld_info* info;
     4768-  lt_dlhandle    cur;
     4769-  lt_dlhandle     handle;
     4770-  int             already_listed;
     4771-  const char*     last_slash;
     4772-  const char*     last_dot;
     4773-
     4774-  do
     4775-    {
     4776-      buf_size *= 2;
     4777-      if( buffer != NULL ) LT_DLFREE( buffer );
     4778-      buffer = LT_DLMALLOC( char, buf_size );
     4779-      ret = loadquery( L_GETINFO, buffer, buf_size );
     4780-    }
     4781-  while( ret==-1 && errno==ENOMEM );
     4782-
     4783-  if( ret >= 0 )
     4784-    {
     4785-      info = (struct ld_info*)buffer;
     4786-      do
     4787-        {
     4788-         libname        = info->ldinfo_filename;
     4789-         modname        = &libname[strlen(libname)];
     4790-         modname        += 1;
     4791-         already_listed = 0;
     4792-
     4793-          cur = handles;
     4794-         while (cur)
     4795-           {
     4796-             if( cur->info.filename &&
     4797-                 !strcmp( cur->info.filename, libname ) )
     4798-               {
     4799-                 already_listed = 1;
     4800-                 break;
     4801-               }
     4802-              cur = cur->next;
     4803-           }
     4804-
     4805-         if( already_listed == 0 )
     4806-           {
     4807-              handle = (lt_dlhandle) LT_DLMALLOC (struct lt_dlhandle_struct, 1);
     4808-              if (!handle)
     4809-                {
     4810-                  MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     4811-                 LT_DLFREE( buffer );
     4812-                  return;
     4813-                }
     4814-             memset( handle, 0, sizeof( struct lt_dlhandle_struct ) );
     4815-
     4816-             last_slash = strrchr( libname, '/' );
     4817-             if( last_slash == NULL )
     4818-               {
     4819-                 last_slash = libname;
     4820-               }
     4821-             else
     4822-               {
     4823-                 last_slash++;
     4824-               }
     4825-             last_dot   = strrchr( last_slash, '.' );
     4826-             if( last_dot == NULL )
     4827-               {
     4828-                 last_dot = &last_slash[strlen(last_slash)];
     4829-               }
     4830-
     4831-              handle->info.name = LT_DLMALLOC( char, last_dot-last_slash+1 );
     4832-             strncpy( handle->info.name, last_slash, last_dot-last_slash );
     4833-             handle->info.name[last_dot-last_slash] = '\0';
     4834-
     4835-             handle->loader         = lt_dlloader_find ("dlopen");
     4836-             handle->info.filename  = strdup( libname );
     4837-              handle->info.ref_count = 1;
     4838-              handle->depcount       = 0;
     4839-              handle->deplibs        = 0;
     4840-              handle->module         = dlopen( libname, lt_dlopen_flag );
     4841-              handle->system         = 0;
     4842-              handle->caller_data    = 0;
     4843-             LT_DLSET_FLAG (handle, LT_DLRESIDENT_FLAG);
     4844-
     4845-              MUTEX_LOCK ();
     4846-              handle->next = handles;
     4847-              handles = handle;
     4848-              MUTEX_UNLOCK ();
     4849-           }
     4850-
     4851-         info = (struct ld_info*)(((char*)info)+info->ldinfo_next);
     4852-        }
     4853-      while( info->ldinfo_next != 0 );
     4854-    }
     4855-
     4856-    if( buffer != NULL ) LT_DLFREE( buffer );
     4857-}
     4858-
     4859-static lt_dlhandle
     4860-sys_dl_search_by_name( const char* name )
     4861-{
     4862-  lt_dlhandle cur;
     4863-  const char* la;
     4864-  int         inlen;
     4865-
     4866-  cur = handles;
     4867-
     4868-  while (cur)
     4869-    {
     4870-      if( cur->info.name && name )
     4871-        {
     4872-         if( !strcmp( cur->info.name, name ) )
     4873-            {
     4874-             if( cur->info.filename )
     4875-               {
     4876-                 la = strrchr( cur->info.filename, '.' );
     4877-                 if( !la || strcmp(la,".la") )
     4878-                   {
     4879-                     return cur;
     4880-                   }
     4881-               }
     4882-            }
     4883-        }
     4884-      if( cur->info.filename && name )
     4885-       {
     4886-         if( !strcmp( cur->info.filename, name ) )
     4887-           {
     4888-             return cur;
     4889-           }
     4890-       }
     4891-      cur = cur->next;
     4892-    }
     4893-  return NULL;
     4894-}
     4895-
     4896-static void
     4897-sys_dl_not_found_entry( const char* tmp )
     4898-{
     4899-    lt_dlhandle handle;
     4900-
     4901-    handle = (lt_dlhandle) LT_DLMALLOC (struct lt_dlhandle_struct, 1);
     4902-    if (!handle)
     4903-      {
     4904-        MUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
     4905-        return;
     4906-      }
     4907-    memset( handle, 0, sizeof( struct lt_dlhandle_struct ) );
     4908-
     4909-    handle->loader = NULL;
     4910-
     4911-    handle->info.filename = strdup( tmp );
     4912-    handle->info.name = strdup( tmp );
     4913-    handle->info.ref_count    = 0;
     4914-    handle->depcount          = 0;
     4915-    handle->deplibs           = 0;
     4916-    handle->module            = 0;
     4917-    handle->system            = 0;
     4918-    handle->caller_data       = 0;
     4919-
     4920-    LT_DLSET_FLAG (handle, LT_DLNOTFOUND_FLAG);
     4921-
     4922-    MUTEX_LOCK ();
     4923-    handle->next = handles;
     4924-    handles = handle;
     4925-    MUTEX_UNLOCK ();
     4926-}
     4927-
     4928-#endif /* _AIX */
  • trunk/dports/audio/arts/files/current/patch-arts-libltdl-ltdl.m4.diff

    r2795 r2983  
    33RCS file: /home/kde/kdelibs/libltdl/ltdl.m4,v
    44retrieving revision 1.8
    5 diff -u -b -u -r1.8 ltdl.m4
     5diff -u -u -r1.8 ltdl.m4
    66--- libltdl/ltdl.m4     22 May 2002 15:37:48 -0000      1.8
    7 +++ libltdl/ltdl.m4     16 Jun 2003 01:59:33 -0000
    8 @@ -103,6 +103,9 @@
    9         osf*)
    10           libltdl_cv_sys_dlopen_deplibs=yes
    11           ;;
    12 +       darwin*)
    13 +         libltdl_cv_sys_dlopen_deplibs=yes
    14 +         ;;
    15         esac
    16  ])
     7+++ libltdl/ltdl.m4     29 Jun 2003 05:09:08 -0000
     8@@ -1,5 +1,5 @@
     9-## ltdl.m4 - Configure ltdl for the target system. -*-Shell-script-*-
     10-## Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
     11+## ltdl.m4 - Configure ltdl for the target system. -*-Autoconf-*-
     12+## Copyright (C) 1999-2000 Free Software Foundation, Inc.
     13 ##
     14 ## This program is free software; you can redistribute it and/or modify
     15 ## it under the terms of the GNU General Public License as published by
     16@@ -20,482 +20,452 @@
     17 ## configuration script generated by Autoconf, you may include it under
     18 ## the same distribution terms that you use for the rest of that program.
     19 
     20-# serial 1 AC_LIB_LTDL
     21+# serial 6 AC_LIB_LTDL
     22 
     23-AC_DEFUN(AC_LIB_LTDL,
     24-[AC_PREREQ(2.13)dnl
     25-AC_REQUIRE([AC_PROG_CC])dnl
     26-AC_REQUIRE([AC_C_CONST])dnl
     27-AC_REQUIRE([AC_C_INLINE])dnl
     28-AC_REQUIRE([AC_LIB_LTDL_COMMON])dnl
     29-])
     30-
     31-AC_DEFUN(KDE_LIB_LTDL,
     32-[AC_PREREQ(2.13)dnl
     33-AC_REQUIRE([AC_PROG_CC])dnl
     34-AC_REQUIRE([AC_LIB_LTDL_COMMON])dnl
     35-])
     36-
     37-AC_DEFUN(AC_LIB_LTDL_COMMON,
     38-[dnl
     39-dnl AC_LIB_LTDL must perform all the checks necessary for compilation
     40-dnl of the ltdl objects -- including compiler checks (above) and header
     41-dnl checks (below).
     42-AC_REQUIRE([AC_HEADER_STDC])dnl
     43-
     44-AC_CHECK_HEADERS(malloc.h memory.h stdlib.h stdio.h ctype.h dlfcn.h dl.h dld.h)
     45-AC_CHECK_HEADERS(string.h strings.h, break)
     46-AC_CHECK_FUNCS(strchr index, break)
     47-AC_CHECK_FUNCS(strrchr rindex, break)
     48-AC_CHECK_FUNCS(memcpy bcopy, break)
     49-AC_CHECK_FUNCS(strcmp)
     50-
     51-AC_REQUIRE([AC_LTDL_ENABLE_INSTALL])dnl
     52-AC_REQUIRE([AC_LTDL_SHLIBEXT])dnl
     53-AC_REQUIRE([AC_LTDL_SHLIBPATH])dnl
     54-AC_REQUIRE([AC_LTDL_SYSSEARCHPATH])dnl
     55-AC_REQUIRE([AC_LTDL_OBJDIR])dnl
     56-AC_REQUIRE([AC_LTDL_DLPREOPEN])dnl
     57-AC_REQUIRE([AC_LTDL_DLLIB])dnl
     58-AC_REQUIRE([AC_LTDL_SYMBOL_USCORE])dnl
     59-AC_REQUIRE([AC_LTDL_DLSYM_USCORE])dnl
     60-AC_REQUIRE([AC_LTDL_SYS_DLOPEN_DEPLIBS])dnl
     61-])
     62-
     63-AC_DEFUN(AC_LTDL_ENABLE_INSTALL,
     64-[AC_ARG_ENABLE(ltdl-install,
     65-[  --enable-ltdl-install   install libltdl])
     66+# AC_WITH_LTDL
     67+# ------------
     68+# Clients of libltdl can use this macro to allow the installer to
     69+# choose between a shipped copy of the ltdl sources or a preinstalled
     70+# version of the library.
     71+AC_DEFUN([AC_WITH_LTDL],
     72+[AC_REQUIRE([AC_LIB_LTDL])
     73+AC_SUBST([LIBLTDL])
     74+AC_SUBST([INCLTDL])
     75+
     76+# Unless the user asks us to check, assume no installed ltdl exists.
     77+use_installed_libltdl=no
     78+
     79+AC_ARG_WITH([included_ltdl],
     80+    [  --with-included-ltdl    use the GNU ltdl sources included here])
     81+
     82+if test "x$with_included_ltdl" != xyes; then
     83+  # We are not being forced to use the included libltdl sources, so
     84+  # decide whether there is a useful installed version we can use.
     85+  AC_CHECK_HEADER([ltdl.h],
     86+      [AC_CHECK_LIB([ltdl], [lt_dlcaller_register],
     87+          [with_included_ltdl=no],
     88+          [with_included_ltdl=yes])
     89+  ])
     90+fi
     91+
     92+if test "x$enable_ltdl_install" != xyes; then
     93+  # If the user did not specify an installable libltdl, then default
     94+  # to a convenience lib.
     95+  AC_LIBLTDL_CONVENIENCE
     96+fi
     97+
     98+if test "x$with_included_ltdl" = xno; then
     99+  # If the included ltdl is not to be used. then Use the
     100+  # preinstalled libltdl we found.
     101+  AC_DEFINE([HAVE_LTDL], 1,
     102+    [Define this if a modern libltdl is already installed])
     103+  LIBLTDL=-lltdl
     104+fi
     105+
     106+# Report our decision...
     107+AC_MSG_CHECKING([whether to use included libltdl])
     108+AC_MSG_RESULT([$with_included_ltdl])
     109+
     110+AC_CONFIG_SUBDIRS([libltdl])
     111+])# AC_WITH_LTDL
     112+
     113+
     114+# KDE_LIB_LTDL
     115+# -----------
     116+# Perform all the checks necessary for compilation of the ltdl objects
     117+#  -- including compiler checks and header checks.
     118+AC_DEFUN([KDE_LIB_LTDL],
     119+[AC_PREREQ(2.50)
     120+AC_REQUIRE([AC_PROG_CC])
     121+AC_REQUIRE([AC_C_CONST])
     122+AC_REQUIRE([AC_HEADER_STDC])
     123+AC_REQUIRE([AC_HEADER_DIRENT])
     124+AC_REQUIRE([_LT_AC_CHECK_DLFCN])
     125+AC_REQUIRE([AC_LTDL_ENABLE_INSTALL])
     126+AC_REQUIRE([AC_LTDL_SHLIBEXT])
     127+AC_REQUIRE([AC_LTDL_SHLIBPATH])
     128+AC_REQUIRE([AC_LTDL_SYSSEARCHPATH])
     129+AC_REQUIRE([AC_LTDL_OBJDIR])
     130+AC_REQUIRE([AC_LTDL_DLPREOPEN])
     131+AC_REQUIRE([AC_LTDL_DLLIB])
     132+AC_REQUIRE([AC_LTDL_SYMBOL_USCORE])
     133+AC_REQUIRE([AC_LTDL_DLSYM_USCORE])
     134+AC_REQUIRE([AC_LTDL_SYS_DLOPEN_DEPLIBS])
     135+AC_REQUIRE([AC_LTDL_FUNC_ARGZ])
     136+
     137+AC_CHECK_HEADERS([assert.h ctype.h errno.h malloc.h memory.h stdlib.h \
     138+                 stdio.h unistd.h])
     139+AC_CHECK_HEADERS([dl.h sys/dl.h dld.h mach-o/dyld.h])
     140+AC_CHECK_HEADERS([string.h strings.h], [break])
     141+
     142+AC_CHECK_FUNCS([strchr index], [break])
     143+AC_CHECK_FUNCS([strrchr rindex], [break])
     144+AC_CHECK_FUNCS([memcpy bcopy], [break])
     145+AC_CHECK_FUNCS([memmove strcmp])
     146+AC_CHECK_FUNCS([closedir opendir readdir])
     147+])# KDE_LIB_LTDL
     148+
     149+
     150+# AC_LIB_LTDL
     151+# -----------
     152+# Perform all the checks necessary for compilation of the ltdl objects
     153+#  -- including compiler checks and header checks.
     154+AC_DEFUN([AC_LIB_LTDL],
     155+[AC_PREREQ(2.50)
     156+AC_REQUIRE([AC_PROG_CC])
     157+AC_REQUIRE([AC_C_CONST])
     158+AC_REQUIRE([AC_HEADER_STDC])
     159+AC_REQUIRE([AC_HEADER_DIRENT])
     160+AC_REQUIRE([_LT_AC_CHECK_DLFCN])
     161+AC_REQUIRE([AC_LTDL_ENABLE_INSTALL])
     162+AC_REQUIRE([AC_LTDL_SHLIBEXT])
     163+AC_REQUIRE([AC_LTDL_SHLIBPATH])
     164+AC_REQUIRE([AC_LTDL_SYSSEARCHPATH])
     165+AC_REQUIRE([AC_LTDL_OBJDIR])
     166+AC_REQUIRE([AC_LTDL_DLPREOPEN])
     167+AC_REQUIRE([AC_LTDL_DLLIB])
     168+AC_REQUIRE([AC_LTDL_SYMBOL_USCORE])
     169+AC_REQUIRE([AC_LTDL_DLSYM_USCORE])
     170+AC_REQUIRE([AC_LTDL_SYS_DLOPEN_DEPLIBS])
     171+AC_REQUIRE([AC_LTDL_FUNC_ARGZ])
     172+
     173+AC_CHECK_HEADERS([assert.h ctype.h errno.h malloc.h memory.h stdlib.h \
     174+                 stdio.h unistd.h])
     175+AC_CHECK_HEADERS([dl.h sys/dl.h dld.h mach-o/dyld.h])
     176+AC_CHECK_HEADERS([string.h strings.h], [break])
     177+
     178+AC_CHECK_FUNCS([strchr index], [break])
     179+AC_CHECK_FUNCS([strrchr rindex], [break])
     180+AC_CHECK_FUNCS([memcpy bcopy], [break])
     181+AC_CHECK_FUNCS([memmove strcmp])
     182+AC_CHECK_FUNCS([closedir opendir readdir])
     183+])# AC_LIB_LTDL
     184+
     185+
     186+# AC_LTDL_ENABLE_INSTALL
     187+# ----------------------
     188+AC_DEFUN([AC_LTDL_ENABLE_INSTALL],
     189+[AC_ARG_ENABLE([ltdl-install],
     190+    [AC_HELP_STRING([--enable-ltdl-install], [install libltdl])])
     191 
     192 AM_CONDITIONAL(INSTALL_LTDL, test x"${enable_ltdl_install-no}" != xno)
     193 AM_CONDITIONAL(CONVENIENCE_LTDL, test x"${enable_ltdl_convenience-no}" != xno)
     194-])])
     195+])])# AC_LTDL_ENABLE_INSTALL
     196 
     197 
     198-AC_DEFUN(AC_LTDL_SNARF_CONFIG,
     199-[# Read the libtool configuration
     200-rm -f conftest
     201-./libtool --config > conftest
     202-. ./conftest
     203-rm -f conftest
     204-])
     205-
     206 # AC_LTDL_SYS_DLOPEN_DEPLIBS
     207 # --------------------------
     208-AC_DEFUN(AC_LTDL_SYS_DLOPEN_DEPLIBS,
     209+AC_DEFUN([AC_LTDL_SYS_DLOPEN_DEPLIBS],
     210 [AC_REQUIRE([AC_CANONICAL_HOST])
     211 AC_CACHE_CHECK([whether deplibs are loaded by dlopen],
     212-       libltdl_cv_sys_dlopen_deplibs, [dnl
     213-       # PORTME does your system automatically load deplibs for dlopen()?
     214-       libltdl_cv_sys_dlopen_deplibs=unknown
     215-       case "$host_os" in
     216-       linux*)
     217-         libltdl_cv_sys_dlopen_deplibs=yes
     218-         ;;
     219-       netbsd*|openbsd*|freebsd*)
     220-         libltdl_cv_sys_dlopen_deplibs=yes
     221-         ;;
     222-       solaris*)
     223-         libltdl_cv_sys_dlopen_deplibs=yes
     224-         ;;
     225-       hpux*|irix*)
     226-         libltdl_cv_sys_dlopen_deplibs=yes
     227-         ;;
     228-       osf*)
     229-         libltdl_cv_sys_dlopen_deplibs=yes
     230-         ;;
     231-       esac
     232-])
     233+  [libltdl_cv_sys_dlopen_deplibs],
     234+  [# PORTME does your system automatically load deplibs for dlopen?
     235+  # or its logical equivalent (e.g. shl_load for HP-UX < 11)
     236+  # For now, we just catch OSes we know something about -- in the
     237+  # future, we'll try test this programmatically.
     238+  libltdl_cv_sys_dlopen_deplibs=unknown
     239+  case "$host_os" in
     240+  aix3*|aix4.1.*|aix4.2.*)
     241+    # Unknown whether this is true for these versions of AIX, but
     242+    # we want this `case' here to explicitly catch those versions.
     243+    libltdl_cv_sys_dlopen_deplibs=unknown
     244+    ;;
     245+  aix[[45]]*)
     246+    libltdl_cv_sys_dlopen_deplibs=yes
     247+    ;;
     248+  darwin*)
     249+    # Assuming the user has installed a libdl from somewhere, this is true
     250+    # If you are looking for one http://www.opendarwin.org/projects/dlcompat
     251+    libltdl_cv_sys_dlopen_deplibs=yes
     252+    ;;   
     253+  freebsd*-gnu*)
     254+    libltdl_cv_sys_dlopen_deplibs=yes
     255+    ;;
     256+  gnu*)
     257+    libltdl_cv_sys_dlopen_deplibs=yes
     258+    ;;
     259+  hpux10*|hpux11*)
     260+    libltdl_cv_sys_dlopen_deplibs=yes
     261+    ;;
     262+  irix[[12345]]*|irix6.[[01]]*)
     263+    # Catch all versions of IRIX before 6.2, and indicate that we don't
     264+    # know how it worked for any of those versions.
     265+    libltdl_cv_sys_dlopen_deplibs=unknown
     266+    ;;
     267+  irix*)
     268+    # The case above catches anything before 6.2, and it's known that
     269+    # at 6.2 and later dlopen does load deplibs.
     270+    libltdl_cv_sys_dlopen_deplibs=yes
     271+    ;;
     272+  linux*)
     273+    libltdl_cv_sys_dlopen_deplibs=yes
     274+    ;;
     275+  netbsd*)
     276+    libltdl_cv_sys_dlopen_deplibs=yes
     277+    ;;
     278+  openbsd*)
     279+    libltdl_cv_sys_dlopen_deplibs=yes
     280+    ;;
     281+  osf[[1234]]*)
     282+    # dlopen did load deplibs (at least at 4.x), but until the 5.x series,
     283+    # it did *not* use an RPATH in a shared library to find objects the
     284+    # library depends on, so we explictly say `no'.
     285+    libltdl_cv_sys_dlopen_deplibs=no
     286+    ;;
     287+  osf5.0|osf5.0a|osf5.1)
     288+    # dlopen *does* load deplibs and with the right loader patch applied
     289+    # it even uses RPATH in a shared library to search for shared objects
     290+    # that the library depends on, but there's no easy way to know if that
     291+    # patch is installed.  Since this is the case, all we can really
     292+    # say is unknown -- it depends on the patch being installed.  If
     293+    # it is, this changes to `yes'.  Without it, it would be `no'.
     294+    libltdl_cv_sys_dlopen_deplibs=unknown
     295+    ;;
     296+  osf*)
     297+    # the two cases above should catch all versions of osf <= 5.1.  Read
     298+    # the comments above for what we know about them.
     299+    # At > 5.1, deplibs are loaded *and* any RPATH in a shared library
     300+    # is used to find them so we can finally say `yes'.
     301+    libltdl_cv_sys_dlopen_deplibs=yes
     302+    ;;
     303+  solaris*)
     304+    libltdl_cv_sys_dlopen_deplibs=yes
     305+    ;;
     306+  esac
     307+  ])
    17308 if test "$libltdl_cv_sys_dlopen_deplibs" != yes; then
    18 @@ -442,6 +445,8 @@
     309- AC_DEFINE(LTDL_DLOPEN_DEPLIBS, 1,
     310-    [Define if the OS needs help to load dependent libraries for dlopen(). ])
     311+ AC_DEFINE([LTDL_DLOPEN_DEPLIBS], [1],
     312+    [Define if the OS needs help to load dependent libraries for dlopen().])
     313 fi
     314 ])# AC_LTDL_SYS_DLOPEN_DEPLIBS
     315 
     316-AC_DEFUN(AC_LTDL_SHLIBEXT,
     317-[AC_REQUIRE([AC_LTDL_SNARF_CONFIG])dnl
     318-AC_CACHE_CHECK([which extension is used for shared libraries],
     319-  libltdl_cv_shlibext, [dnl
     320-(
     321-  last=
     322-  for spec in $library_names_spec; do
     323-    last="$spec"
     324-  done
     325-changequote(, )
     326-  echo "$last" | sed 's/\[.*\]//;s/^[^.]*//;s/\$.*$//;s/\.$//' > conftest
     327-changequote([, ])
     328-)
     329-libltdl_cv_shlibext=`cat conftest`
     330-rm -f conftest
     331-])
     332+
     333+# AC_LTDL_SHLIBEXT
     334+# ----------------
     335+AC_DEFUN([AC_LTDL_SHLIBEXT],
     336+[AC_REQUIRE([AC_LIBTOOL_SYS_DYNAMIC_LINKER])
     337+AC_CACHE_CHECK([which extension is used for loadable modules],
     338+  [libltdl_cv_shlibext],
     339+[
     340+module=yes
     341+eval libltdl_cv_shlibext=$shrext
     342+  ])
     343 if test -n "$libltdl_cv_shlibext"; then
     344   AC_DEFINE_UNQUOTED(LTDL_SHLIB_EXT, "$libltdl_cv_shlibext",
     345-    [Define to the extension used for shared libraries, say, ".so". ])
     346+    [Define to the extension used for shared libraries, say, ".so".])
     347 fi
     348-])
     349+])# AC_LTDL_SHLIBEXT
     350 
     351-AC_DEFUN(AC_LTDL_SHLIBPATH,
     352-[AC_REQUIRE([AC_LTDL_SNARF_CONFIG])dnl
     353+
     354+# AC_LTDL_SHLIBPATH
     355+# -----------------
     356+AC_DEFUN([AC_LTDL_SHLIBPATH],
     357+[AC_REQUIRE([AC_LIBTOOL_SYS_DYNAMIC_LINKER])
     358 AC_CACHE_CHECK([which variable specifies run-time library path],
     359-  libltdl_cv_shlibpath_var, [libltdl_cv_shlibpath_var="$shlibpath_var"])
     360+  [libltdl_cv_shlibpath_var], [libltdl_cv_shlibpath_var="$shlibpath_var"])
     361 if test -n "$libltdl_cv_shlibpath_var"; then
     362   AC_DEFINE_UNQUOTED(LTDL_SHLIBPATH_VAR, "$libltdl_cv_shlibpath_var",
     363-    [Define to the name of the environment variable that determines the dynamic library search path. ])
     364+    [Define to the name of the environment variable that determines the dynamic library search path.])
     365 fi
     366-])
     367+])# AC_LTDL_SHLIBPATH
     368 
     369-AC_DEFUN(AC_LTDL_SYSSEARCHPATH,
     370-[AC_REQUIRE([AC_LTDL_SNARF_CONFIG])dnl
     371+
     372+# AC_LTDL_SYSSEARCHPATH
     373+# ---------------------
     374+AC_DEFUN([AC_LTDL_SYSSEARCHPATH],
     375+[AC_REQUIRE([AC_LIBTOOL_SYS_DYNAMIC_LINKER])
     376 AC_CACHE_CHECK([for the default library search path],
     377-  libltdl_cv_sys_search_path, [libltdl_cv_sys_search_path="$sys_lib_dlsearch_path_spec"])
     378+  [libltdl_cv_sys_search_path],
     379+  [libltdl_cv_sys_search_path="$sys_lib_dlsearch_path_spec"])
     380 if test -n "$libltdl_cv_sys_search_path"; then
     381-  case "$host" in
     382-  *-*-mingw*) pathsep=";" ;;
     383-  *) pathsep=":" ;;
     384-  esac
     385   sys_search_path=
     386   for dir in $libltdl_cv_sys_search_path; do
     387     if test -z "$sys_search_path"; then
     388       sys_search_path="$dir"
     389     else
     390-      sys_search_path="$sys_search_path$pathsep$dir"
     391+      sys_search_path="$sys_search_path$PATH_SEPARATOR$dir"
     392     fi
     393   done
     394   AC_DEFINE_UNQUOTED(LTDL_SYSSEARCHPATH, "$sys_search_path",
     395-    [Define to the system default library search path. ])
     396+    [Define to the system default library search path.])
     397 fi
     398-])
     399+])# AC_LTDL_SYSSEARCHPATH
     400 
     401-AC_DEFUN(AC_LTDL_OBJDIR,
     402+
     403+# AC_LTDL_OBJDIR
     404+# --------------
     405+AC_DEFUN([AC_LTDL_OBJDIR],
     406 [AC_CACHE_CHECK([for objdir],
     407-  libltdl_cv_objdir, [libltdl_cv_objdir="$objdir"
     408-if test -n "$objdir"; then
     409-  :
     410-else
     411-  rm -f .libs 2>/dev/null
     412-  mkdir .libs 2>/dev/null
     413-  if test -d .libs; then
     414-    libltdl_cv_objdir=.libs
     415+  [libltdl_cv_objdir],
     416+  [libltdl_cv_objdir="$objdir"
     417+  if test -n "$objdir"; then
     418+    :
     419   else
     420-    # MS-DOS does not allow filenames that begin with a dot.
     421-    libltdl_cv_objdir=_libs
     422+    rm -f .libs 2>/dev/null
     423+    mkdir .libs 2>/dev/null
     424+    if test -d .libs; then
     425+      libltdl_cv_objdir=.libs
     426+    else
     427+      # MS-DOS does not allow filenames that begin with a dot.
     428+      libltdl_cv_objdir=_libs
     429+    fi
     430+  rmdir .libs 2>/dev/null
     431   fi
     432-rmdir .libs 2>/dev/null
     433-fi])
     434+  ])
     435 AC_DEFINE_UNQUOTED(LTDL_OBJDIR, "$libltdl_cv_objdir/",
     436-  [Define to the sub-directory in which libtool stores uninstalled libraries. ])
     437-])
     438+  [Define to the sub-directory in which libtool stores uninstalled libraries.])
     439+])# AC_LTDL_OBJDIR
     440+
     441 
     442-AC_DEFUN(AC_LTDL_DLPREOPEN,
     443-[AC_REQUIRE([AC_LTDL_GLOBAL_SYMBOL_PIPE])dnl
     444+# AC_LTDL_DLPREOPEN
     445+# -----------------
     446+AC_DEFUN([AC_LTDL_DLPREOPEN],
     447+[AC_REQUIRE([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])
     448 AC_CACHE_CHECK([whether libtool supports -dlopen/-dlpreopen],
     449-       libltdl_cv_preloaded_symbols, [dnl
     450-  if test -n "$global_symbol_pipe"; then
     451+  [libltdl_cv_preloaded_symbols],
     452+  [if test -n "$lt_cv_sys_global_symbol_pipe"; then
     453     libltdl_cv_preloaded_symbols=yes
     454   else
     455     libltdl_cv_preloaded_symbols=no
     456   fi
     457-])
     458-if test x"$libltdl_cv_preloaded_symbols" = x"yes"; then
     459+  ])
     460+if test x"$libltdl_cv_preloaded_symbols" = xyes; then
     461   AC_DEFINE(HAVE_PRELOADED_SYMBOLS, 1,
     462-    [Define if libtool can extract symbol lists from object files. ])
     463+    [Define if libtool can extract symbol lists from object files.])
     464 fi
     465-])
     466+])# AC_LTDL_DLPREOPEN
     467 
     468-AC_DEFUN(AC_LTDL_DLLIB,
     469+
     470+# AC_LTDL_DLLIB
     471+# -------------
     472+AC_DEFUN([AC_LTDL_DLLIB],
     473 [LIBADD_DL=
     474-AC_CHECK_LIB(dl, dlopen, [AC_DEFINE(HAVE_LIBDL, 1,
     475-   [Define if you have the libdl library or equivalent. ]) LIBADD_DL="-ldl"],
     476-[AC_CHECK_FUNC(dlopen, [AC_DEFINE(HAVE_LIBDL, 1,
     477-   [Define if you have the libdl library or equivalent.])],
     478-[AC_CHECK_LIB(svld, dlopen, [AC_DEFINE(HAVE_LIBDL, 1,
     479-   [Define if you have the libdl library or equivalent.]) LIBADD_DL="-lsvld"]
     480-)])])
     481-AC_CHECK_FUNC(shl_load, [AC_DEFINE(HAVE_SHL_LOAD, 1,
     482-   [Define if you have the shl_load function.])],
     483-[AC_CHECK_LIB(dld, shl_load,
     484-  [AC_DEFINE(HAVE_SHL_LOAD, 1,
     485-     [Define if you have the shl_load function.])
     486-   LIBADD_DL="$LIBADD_DL -ldld"])
     487-])
     488-AC_CHECK_LIB(dld, dld_link, [AC_DEFINE(HAVE_DLD, 1,
     489-  [Define if you have the GNU dld library.])dnl
     490-test "x$ac_cv_lib_dld_shl_load" = yes || LIBADD_DL="$LIBADD_DL -ldld"])
     491 AC_SUBST(LIBADD_DL)
     492+AC_LANG_PUSH([C])
     493 
     494-if test "x$ac_cv_func_dlopen" = xyes || test "x$ac_cv_lib_dl_dlopen" = xyes; then
     495- LIBS_SAVE="$LIBS"
     496- LIBS="$LIBS $LIBADD_DL"
     497- AC_CHECK_FUNCS(dlerror)
     498- LIBS="$LIBS_SAVE"
     499-fi
     500-])
     501-
     502-AC_DEFUN(AC_LTDL_GLOBAL_SYMBOL_PIPE,
     503-[dnl Check for command to grab the raw symbol name followed
     504-dnl by C symbol name from nm.
     505-AC_REQUIRE([AC_CANONICAL_HOST])dnl
     506-AC_REQUIRE([AC_PROG_NM])dnl
     507-# Check for command to grab the raw symbol name followed by C symbol from nm.
     508-AC_MSG_CHECKING([command to parse $NM output])
     509-AC_CACHE_VAL(ac_cv_sys_global_symbol_pipe,
     510-[# These are sane defaults that work on at least a few old systems.
     511-# {They come from Ultrix.  What could be older than Ultrix?!! ;)}
     512-
     513-changequote(,)dnl
     514-# Character class describing NM global symbol codes.
     515-ac_symcode='[BCDEGRST]'
     516-
     517-# Regexp to match symbols that can be accessed directly from C.
     518-ac_sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
     519-
     520-# Transform the above into a raw symbol and a C symbol.
     521-ac_symxfrm='\1 \2\3 \3'
     522-
     523-# Transform an extracted symbol line into a proper C declaration
     524-ac_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern char \1;/p'"
     525-
     526-# Define system-specific variables.
     527-case "$host_os" in
     528-aix*)
     529-  ac_symcode='[BCDT]'
     530-  ;;
     531-cygwin* | mingw*)
     532-  ac_symcode='[ABCDGISTW]'
     533-  ;;
     534-hpux*)
     535-  ac_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern char \1();/p' -e 's/^. .* \(.*\)$/extern char \1;/p'"
     536-  ;;
     537-irix*)
     538-  ac_symcode='[BCDEGRST]'
     539-  ;;
     540-solaris*)
     541-  ac_symcode='[BDT]'
     542-  ;;
     543-esac
     544-
     545-# If we're using GNU nm, then use its standard symbol codes.
     546-if $NM -V 2>&1 | egrep '(GNU|with BFD)' > /dev/null; then
     547-  ac_symcode='[ABCDGISTW]'
     548-fi
     549-changequote([,])dnl
     550-
     551-# Try without a prefix undercore, then with it.
     552-for ac_symprfx in "" "_"; do
     553-
     554-  ac_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[      ]\($ac_symcode\)[       ][      ]*\($ac_symprfx\)$ac_sympat$/$ac_symxfrm/p'"
     555-
     556-  # Check to see that the pipe works correctly.
     557-  ac_pipe_works=no
     558-  rm -f conftest.$ac_ext
     559-  cat > conftest.$ac_ext <<EOF
     560-#ifdef __cplusplus
     561-extern "C" {
     562+AC_CHECK_FUNC([shl_load],
     563+      [AC_DEFINE([HAVE_SHL_LOAD], [1],
     564+                [Define if you have the shl_load function.])],
     565+  [AC_CHECK_LIB([dld], [shl_load],
     566+       [AC_DEFINE([HAVE_SHL_LOAD], [1],
     567+                  [Define if you have the shl_load function.])
     568+       LIBADD_DL="$LIBADD_DL -ldld"],
     569+    [AC_CHECK_LIB([dl], [dlopen],
     570+         [AC_DEFINE([HAVE_LIBDL], [1],
     571+                    [Define if you have the libdl library or equivalent.])
     572+               LIBADD_DL="-ldl" libltdl_cv_lib_dl_dlopen="yes"],
     573+      [AC_TRY_LINK([#if HAVE_DLFCN_H
     574+#  include <dlfcn.h>
     575 #endif
     576-char nm_test_var;
     577+      ],
     578+       [dlopen(0, 0);],
     579+           [AC_DEFINE([HAVE_LIBDL], [1],
     580+                            [Define if you have the libdl library or equivalent.]) libltdl_cv_func_dlopen="yes"],
     581+       [AC_CHECK_LIB([svld], [dlopen],
     582+             [AC_DEFINE([HAVE_LIBDL], [1],
     583+                        [Define if you have the libdl library or equivalent.])
     584+                   LIBADD_DL="-lsvld" libltdl_cv_func_dlopen="yes"],
     585+         [AC_CHECK_LIB([dld], [dld_link],
     586+               [AC_DEFINE([HAVE_DLD], [1],
     587+                          [Define if you have the GNU dld library.])
     588+               LIBADD_DL="$LIBADD_DL -ldld"],
     589+               [AC_CHECK_FUNC([_dyld_func_lookup],
     590+                      [AC_DEFINE([HAVE_DYLD], [1],
     591+                         [Define if you have the _dyld_func_lookup function.])])
     592+          ])
     593+        ])
     594+      ])
     595+    ])
     596+  ])
     597+])
     598+
     599+if test x"$libltdl_cv_func_dlopen" = xyes || test x"$libltdl_cv_lib_dl_dlopen" = xyes
     600+then
     601+  lt_save_LIBS="$LIBS"
     602+  LIBS="$LIBS $LIBADD_DL"
     603+  AC_CHECK_FUNCS([dlerror])
     604+  LIBS="$lt_save_LIBS"
     605+fi
     606+AC_LANG_POP
     607+])# AC_LTDL_DLLIB
     608+
     609+
     610+# AC_LTDL_SYMBOL_USCORE
     611+# ---------------------
     612+# does the compiler prefix global symbols with an underscore?
     613+AC_DEFUN([AC_LTDL_SYMBOL_USCORE],
     614+[AC_REQUIRE([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])
     615+AC_CACHE_CHECK([for _ prefix in compiled symbols],
     616+  [ac_cv_sys_symbol_underscore],
     617+  [ac_cv_sys_symbol_underscore=no
     618+  cat > conftest.$ac_ext <<EOF
     619 void nm_test_func(){}
     620-#ifdef __cplusplus
     621-}
     622-#endif
     623-int main(){nm_test_var='a';nm_test_func;return 0;}
     624+int main(){nm_test_func;return 0;}
     625 EOF
     626-
     627   if AC_TRY_EVAL(ac_compile); then
     628     # Now try to grab the symbols.
     629     ac_nlist=conftest.nm
     630-
     631-    if AC_TRY_EVAL(NM conftest.$ac_objext \| $ac_cv_sys_global_symbol_pipe \> $ac_nlist) && test -s "$ac_nlist"; then
     632-
     633-      # Try sorting and uniquifying the output.
     634-      if sort "$ac_nlist" | uniq > "$ac_nlist"T; then
     635-       mv -f "$ac_nlist"T "$ac_nlist"
     636-      else
     637-       rm -f "$ac_nlist"T
     638-      fi
     639-
     640-      # Make sure that we snagged all the symbols we need.
     641-      if egrep ' nm_test_var$' "$ac_nlist" >/dev/null; then
     642-       if egrep ' nm_test_func$' "$ac_nlist" >/dev/null; then
     643-         cat <<EOF > conftest.$ac_ext
     644-#ifdef __cplusplus
     645-extern "C" {
     646-#endif
     647-
     648-EOF
     649-         # Now generate the symbol file.
     650-         eval "$ac_global_symbol_to_cdecl"' < "$ac_nlist" >> conftest.$ac_ext'
     651-
     652-         cat <<EOF >> conftest.$ac_ext
     653-#if defined (__STDC__) && __STDC__
     654-# define lt_ptr_t void *
     655-#else
     656-# define lt_ptr_t char *
     657-# define const
     658-#endif
     659-
     660-/* The mapping between symbol names and symbols. */
     661-const struct {
     662-  const char *name;
     663-  lt_ptr_t address;
     664-}
     665-changequote(,)dnl
     666-lt_preloaded_symbols[] =
     667-changequote([,])dnl
     668-{
     669-EOF
     670-       sed 's/^. \(.*\) \(.*\)$/  {"\2", (lt_ptr_t) \&\2},/' < "$ac_nlist" >> conftest.$ac_ext
     671-       cat <<\EOF >> conftest.$ac_ext
     672-  {0, (lt_ptr_t) 0}
     673-};
     674-
     675-#ifdef __cplusplus
     676-}
     677-#endif
     678-EOF
     679-         # Now try linking the two files.
     680-         mv conftest.$ac_objext conftstm.$ac_objext
     681-         ac_save_LIBS="$LIBS"
     682-         ac_save_CFLAGS="$CFLAGS"
     683-         LIBS="conftstm.$ac_objext"
     684-         CFLAGS="$CFLAGS$no_builtin_flag"
     685-         if AC_TRY_EVAL(ac_link) && test -s conftest; then
     686-           ac_pipe_works=yes
     687-         else
     688-           echo "configure: failed program was:" >&AC_FD_CC
     689-           cat conftest.$ac_ext >&AC_FD_CC
     690-         fi
     691-         LIBS="$ac_save_LIBS"
     692-         CFLAGS="$ac_save_CFLAGS"
     693-       else
     694-         echo "cannot find nm_test_func in $ac_nlist" >&AC_FD_CC
     695-       fi
     696+    if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $ac_nlist) && test -s "$ac_nlist"; then
     697+      # See whether the symbols have a leading underscore.
     698+      if grep '^. _nm_test_func' "$ac_nlist" >/dev/null; then
     699+        ac_cv_sys_symbol_underscore=yes
     700       else
     701-       echo "cannot find nm_test_var in $ac_nlist" >&AC_FD_CC
     702+        if grep '^. nm_test_func ' "$ac_nlist" >/dev/null; then
     703+         :
     704+        else
     705+         echo "configure: cannot find nm_test_func in $ac_nlist" >&AC_FD_CC
     706+        fi
     707       fi
     708     else
     709-      echo "cannot run $ac_cv_sys_global_symbol_pipe" >&AC_FD_CC
     710+      echo "configure: cannot run $lt_cv_sys_global_symbol_pipe" >&AC_FD_CC
     711     fi
     712   else
     713-    echo "$progname: failed program was:" >&AC_FD_CC
     714-    cat conftest.$ac_ext >&AC_FD_CC
     715+    echo "configure: failed program was:" >&AC_FD_CC
     716+    cat conftest.c >&AC_FD_CC
     717   fi
     718-  rm -rf conftest* conftst*
     719+  rm -rf conftest*
     720+  ])
     721+])# AC_LTDL_SYMBOL_USCORE
     722 
     723-  # Do not use the global_symbol_pipe unless it works.
     724-  if test "$ac_pipe_works" = yes; then
     725-    if test x"$ac_symprfx" = x"_"; then
     726-      ac_cv_sys_symbol_underscore=yes
     727-    else
     728-      ac_cv_sys_symbol_underscore=no
     729-    fi
     730-    break
     731-  else
     732-    ac_cv_sys_global_symbol_pipe=
     733-  fi
     734-done
     735-])
     736-
     737-ac_result=yes
     738-if test -z "$ac_cv_sys_global_symbol_pipe"; then
     739-   ac_result=no
     740-fi
     741-AC_MSG_RESULT($ac_result)
     742-])
     743 
     744-AC_DEFUN(AC_LTDL_SYMBOL_USCORE,
     745-[dnl does the compiler prefix global symbols with an underscore?
     746-AC_REQUIRE([AC_LTDL_GLOBAL_SYMBOL_PIPE])dnl
     747-AC_MSG_CHECKING([for _ prefix in compiled symbols])
     748-AC_CACHE_VAL(ac_cv_sys_symbol_underscore,
     749-[ac_cv_sys_symbol_underscore=no
     750-cat > conftest.$ac_ext <<EOF
     751-void nm_test_func(){}
     752-int main(){nm_test_func;return 0;}
     753-EOF
     754-if AC_TRY_EVAL(ac_compile); then
     755-  # Now try to grab the symbols.
     756-  ac_nlist=conftest.nm
     757-  if AC_TRY_EVAL(NM conftest.$ac_objext \| $ac_cv_sys_global_symbol_pipe \> $ac_nlist) && test -s "$ac_nlist"; then
     758-    # See whether the symbols have a leading underscore.
     759-    if egrep '^. _nm_test_func' "$ac_nlist" >/dev/null; then
     760-      ac_cv_sys_symbol_underscore=yes
     761-    else
     762-      if egrep '^. nm_test_func ' "$ac_nlist" >/dev/null; then
     763-       :
     764-      else
     765-       echo "configure: cannot find nm_test_func in $ac_nlist" >&AC_FD_CC
     766-      fi
     767-    fi
     768-  else
     769-    echo "configure: cannot run $ac_cv_sys_global_symbol_pipe" >&AC_FD_CC
     770-  fi
     771-else
     772-  echo "configure: failed program was:" >&AC_FD_CC
     773-  cat conftest.$ac_ext >&AC_FD_CC
     774-fi
     775-rm -rf conftest*
     776-])
     777-AC_MSG_RESULT($ac_cv_sys_symbol_underscore)
     778-])
     779-
     780-AC_DEFUN(AC_LTDL_DLSYM_USCORE,
     781-[AC_REQUIRE([AC_LTDL_SYMBOL_USCORE])dnl
     782+# AC_LTDL_DLSYM_USCORE
     783+# --------------------
     784+AC_DEFUN([AC_LTDL_DLSYM_USCORE],
     785+[AC_REQUIRE([AC_LTDL_SYMBOL_USCORE])
    19786 if test x"$ac_cv_sys_symbol_underscore" = xyes; then
    20    if test x"$ac_cv_func_dlopen" = xyes ||
    21       test x"$ac_cv_lib_dl_dlopen" = xyes ; then
    22       ac_save_LIBS="$LIBS"
    23 +        LIBS="$LIBS $LIBADD_DL"
     787-  if test x"$ac_cv_func_dlopen" = xyes ||
     788-     test x"$ac_cv_lib_dl_dlopen" = xyes ; then
     789if test x"$libltdl_cv_func_dlopen" = xyes ||
     790+     test x"$libltdl_cv_lib_dl_dlopen" = xyes ; then
    24791        AC_CACHE_CHECK([whether we have to add an underscore for dlsym],
    25                 libltdl_cv_need_uscore, [dnl
    26                 AC_TRY_RUN([
    27 @@ -495,6 +500,7 @@
     792-               libltdl_cv_need_uscore, [dnl
     793-               AC_TRY_RUN([
     794-#if HAVE_DLFCN_H
     795-#include <dlfcn.h>
     796-#endif
     797-
     798-#include <stdio.h>
     799-
     800-#ifdef RTLD_GLOBAL
     801-# define LTDL_GLOBAL   RTLD_GLOBAL
     802-#else
     803-# ifdef DL_GLOBAL
     804-#  define LTDL_GLOBAL  DL_GLOBAL
     805-# else
     806-#  define LTDL_GLOBAL  0
     807-# endif
     808-#endif
     809-
     810-/* We may have to define LTDL_LAZY_OR_NOW in the command line if we
     811-   find out it does not work in some platform. */
     812-#ifndef LTDL_LAZY_OR_NOW
     813-# ifdef RTLD_LAZY
     814-#  define LTDL_LAZY_OR_NOW     RTLD_LAZY
     815-# else
     816-#  ifdef DL_LAZY
     817-#   define LTDL_LAZY_OR_NOW    DL_LAZY
     818-#  else
     819-#   ifdef RTLD_NOW
     820-#    define LTDL_LAZY_OR_NOW   RTLD_NOW
     821-#   else
     822-#    ifdef DL_NOW
     823-#     define LTDL_LAZY_OR_NOW  DL_NOW
     824-#    else
     825-#     define LTDL_LAZY_OR_NOW  0
     826-#    endif
     827-#   endif
     828-#  endif
     829-# endif
     830-#endif
     831-
     832-void fnord() { int i=42;}
     833-int main() {
     834-    void *self, *ptr1, *ptr2; self=dlopen(0,LTDL_GLOBAL|LTDL_LAZY_OR_NOW);
     835-    if(self) { ptr1=dlsym(self,"fnord"); ptr2=dlsym(self,"_fnord");
     836-              if(ptr1 && !ptr2) { dlclose(self); exit(0); } } exit(1); }
     837-],     libltdl_cv_need_uscore=no, libltdl_cv_need_uscore=yes,
     838-       libltdl_cv_need_uscore=cross
     839-)])
     840+         [libltdl_cv_need_uscore],
     841+         [libltdl_cv_need_uscore=unknown
     842+          save_LIBS="$LIBS"
     843+          LIBS="$LIBS $LIBADD_DL"
     844+         _LT_AC_TRY_DLOPEN_SELF(
     845+           [libltdl_cv_need_uscore=no], [libltdl_cv_need_uscore=yes],
     846+           [],                          [libltdl_cv_need_uscore=cross])
     847+         LIBS="$save_LIBS"
     848+       ])
     849   fi
    28850 fi
    29851 
    30852 if test x"$libltdl_cv_need_uscore" = xyes; then
    31 +  LIBS="$ac_save_LIBS"
    32853   AC_DEFINE(NEED_USCORE, 1,
    33      [Define if dlsym() requires a leading underscode in symbol names. ])
     854-    [Define if dlsym() requires a leading underscode in symbol names. ])
     855+    [Define if dlsym() requires a leading underscore in symbol names.])
    34856 fi
     857-])
     858+])# AC_LTDL_DLSYM_USCORE
     859+
     860+# AC_LTDL_FUNC_ARGZ
     861+# -----------------
     862+AC_DEFUN([AC_LTDL_FUNC_ARGZ],
     863+[AC_CHECK_HEADERS([argz.h])
     864+
     865+AC_CHECK_TYPES([error_t],
     866+  [],
     867+  [AC_DEFINE([error_t], [int],
     868+    [Define to a type to use for `error_t' if it is not otherwise available.])],
     869+  [#if HAVE_ARGZ_H
     870+#  include <argz.h>
     871+#endif])
     872+
     873+AC_CHECK_FUNCS([argz_append argz_create_sep argz_insert argz_next argz_stringify])
     874+])# AC_LTDL_FUNC_ARGZ
Note: See TracChangeset for help on using the changeset viewer.