Upgrade from trousers 0.3.3 to 0.3.6 and from testsuite 0.2 to 0.3.

ltmain.sh

 # ltmain.sh - Provide generalized library-building support services.
 # NOTE: Changing this file will not affect anything until you rerun configure.
 #
-# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004
-# Free Software Foundation, Inc.
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
+# 2007, 2008  Free Software Foundation, Inc.
 # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful, but
 # WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 # General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 #
 # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a
 # configuration script generated by Autoconf, you may include it under
 # the same distribution terms that you use for the rest of that program.
 
 basename="s,^.*/,,g"
 
 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
 # is ksh but when the shell is invoked as "sh" and the current value of
 # the _XPG environment variable is not equal to 1 (one), the special
 # positional parameter $0, within a function call, is the name of the
 # function.
 progpath="$0"
 
-# RH: define SED for historic ltconfig's generated by Libtool 1.3
-[ -z "$SED" ] && SED=sed
-
 # The name of this program:
 progname=`echo "$progpath" | $SED $basename`
 modename="$progname"
 
 # Global variables:
 EXIT_SUCCESS=0
 EXIT_FAILURE=1
 
 PROGRAM=ltmain.sh
 PACKAGE=libtool
-VERSION=1.5.6
-TIMESTAMP=" (1.1220.2.95 2004/04/11 05:50:42)"
+VERSION="1.5.26 Debian 1.5.26-1ubuntu1"
+TIMESTAMP=" (1.1220.2.493 2008/02/01 16:58:18)"
 
+# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
+fi
+BIN_SH=xpg4; export BIN_SH # for Tru64
+DUALCASE=1; export DUALCASE # for MKS sh
 
 # Check that we have a working $echo.
 if test "X$1" = X--no-reexec; then
   # Discard the --no-reexec flag, and continue.
   shift
 elif test "X$1" = X--fallback-echo; then
   # Avoid inline document here, it may be left over
   :
 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
   # Yippee, $echo works!
@@ skipping 17 matching lines @@
 magic="%%%MAGIC variable%%%"
 mkdir="mkdir"
 mv="mv -f"
 rm="rm -f"
 
 # Sed substitution that helps us do robust quoting.  It backslashifies
 # metacharacters that are still active within double-quoted strings.
 Xsed="${SED}"' -e 1s/^X//'
 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
 # test EBCDIC or ASCII
-case `echo A|tr A '\301'` in
- A) # EBCDIC based system
-  SP2NL="tr '\100' '\n'"
-  NL2SP="tr '\r\n' '\100\100'"
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+  SP2NL='tr \040 \012'
+  NL2SP='tr \015\012 \040\040'
   ;;
- *) # Assume ASCII based system
-  SP2NL="tr '\040' '\012'"
-  NL2SP="tr '\015\012' '\040\040'"
+ *) # EBCDIC based system
+  SP2NL='tr \100 \n'
+  NL2SP='tr \r\n \100\100'
   ;;
 esac
 
 # NLS nuisances.
 # Only set LANG and LC_ALL to C if already set.
 # These must not be set unconditionally because not all systems understand
 # e.g. LANG=C (notably SCO).
 # We save the old values to restore during execute mode.
-if test "${LC_ALL+set}" = set; then
-  save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
-fi
-if test "${LANG+set}" = set; then
-  save_LANG="$LANG"; LANG=C; export LANG
+lt_env=
+for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+do
+  eval "if test \"\${$lt_var+set}\" = set; then
+          save_$lt_var=\$$lt_var
+          lt_env=\"$lt_var=\$$lt_var \$lt_env\"
+          $lt_var=C
+          export $lt_var
+        fi"
+done
+
+if test -n "$lt_env"; then
+  lt_env="env $lt_env"
 fi
 
 # Make sure IFS has a sensible default
-: ${IFS="       
-"}
+lt_nl='
+'
+IFS="   $lt_nl"
 
 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
   $echo "$modename: not configured to build any kind of library" 1>&2
   $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
   exit $EXIT_FAILURE
 fi
 
 # Global variables.
 mode=$default_mode
 nonopt=
 prev=
 prevopt=
 run=
 show="$echo"
 show_help=
 execute_dlfiles=
+duplicate_deps=no
+preserve_args=
 lo2o="s/\\.lo\$/.${objext}/"
 o2lo="s/\\.${objext}\$/.lo/"
+extracted_archives=
+extracted_serial=0
 
 #####################################
 # Shell function definitions:
 # This seems to be the best place for them
 
+# func_mktempdir [string]
+# Make a temporary directory that won't clash with other running
+# libtool processes, and avoids race conditions if possible.  If
+# given, STRING is the basename for that directory.
+func_mktempdir ()
+{
+    my_template="${TMPDIR-/tmp}/${1-$progname}"
+
+    if test "$run" = ":"; then
+      # Return a directory name, but don't create it in dry-run mode
+      my_tmpdir="${my_template}-$$"
+    else
+
+      # If mktemp works, use that first and foremost
+      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
+
+      if test ! -d "$my_tmpdir"; then
+        # Failing that, at least try and use $RANDOM to avoid a race
+        my_tmpdir="${my_template}-${RANDOM-0}$$"
+
+        save_mktempdir_umask=`umask`
+        umask 0077
+        $mkdir "$my_tmpdir"
+        umask $save_mktempdir_umask
+      fi
+
+      # If we're not in dry-run mode, bomb out on failure
+      test -d "$my_tmpdir" || {
+        $echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
+        exit $EXIT_FAILURE
+      }
+    fi
+
+    $echo "X$my_tmpdir" | $Xsed
+}
+
+
 # func_win32_libid arg
 # return the library type of file 'arg'
 #
 # Need a lot of goo to handle *both* DLLs and import libs
 # Has to be a shell function in order to 'eat' the argument
 # that is supplied when $file_magic_command is called.
-func_win32_libid () {
+func_win32_libid ()
+{
   win32_libid_type="unknown"
   win32_fileres=`file -L $1 2>/dev/null`
   case $win32_fileres in
   *ar\ archive\ import\ library*) # definitely import
     win32_libid_type="x86 archive import"
     ;;
   *ar\ archive*) # could be an import, or static
     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
       $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
       win32_nmres=`eval $NM -f posix -A $1 | \
-        sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`
-      if test "X$win32_nmres" = "Ximport" ; then
-        win32_libid_type="x86 archive import"
-      else
-        win32_libid_type="x86 archive static"
-      fi
+        $SED -n -e '1,100{
+                / I /{
+                        s,.*,import,
+                        p
+                        q
+                        }
+                }'`
+      case $win32_nmres in
+      import*)  win32_libid_type="x86 archive import";;
+      *)        win32_libid_type="x86 archive static";;
+      esac
     fi
     ;;
   *DLL*)
     win32_libid_type="x86 DLL"
     ;;
   *executable*) # but shell scripts are "executable" too...
     case $win32_fileres in
     *MS\ Windows\ PE\ Intel*)
       win32_libid_type="x86 DLL"
       ;;
     esac
     ;;
   esac
   $echo $win32_libid_type
 }
 
 
 # func_infer_tag arg
 # Infer tagged configuration to use if any are available and
 # if one wasn't chosen via the "--tag" command line option.
 # Only attempt this if the compiler in the base compile
 # command doesn't match the default compiler.
 # arg is usually of the form 'gcc ...'
-func_infer_tag () {
+func_infer_tag ()
+{
     if test -n "$available_tags" && test -z "$tagname"; then
       CC_quoted=
       for arg in $CC; do
         case $arg in
           *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
           arg="\"$arg\""
           ;;
         esac
         CC_quoted="$CC_quoted $arg"
       done
@@ skipping 36 matching lines @@
           $echo "$modename: unable to infer tagged configuration"
           $echo "$modename: specify a tag with \`--tag'" 1>&2
           exit $EXIT_FAILURE
 #        else
 #          $echo "$modename: using $tagname tagged configuration"
         fi
         ;;
       esac
     fi
 }
+
+
+# func_extract_an_archive dir oldlib
+func_extract_an_archive ()
+{
+    f_ex_an_ar_dir="$1"; shift
+    f_ex_an_ar_oldlib="$1"
+
+    $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
+    $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
+    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
+     :
+    else
+      $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
+      exit $EXIT_FAILURE
+    fi
+}
+
+# func_extract_archives gentop oldlib ...
+func_extract_archives ()
+{
+    my_gentop="$1"; shift
+    my_oldlibs=${1+"$@"}
+    my_oldobjs=""
+    my_xlib=""
+    my_xabs=""
+    my_xdir=""
+    my_status=""
+
+    $show "${rm}r $my_gentop"
+    $run ${rm}r "$my_gentop"
+    $show "$mkdir $my_gentop"
+    $run $mkdir "$my_gentop"
+    my_status=$?
+    if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
+      exit $my_status
+    fi
+
+    for my_xlib in $my_oldlibs; do
+      # Extract the objects.
+      case $my_xlib in
+        [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
+        *) my_xabs=`pwd`"/$my_xlib" ;;
+      esac
+      my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
+      my_xlib_u=$my_xlib
+      while :; do
+        case " $extracted_archives " in
+        *" $my_xlib_u "*)
+          extracted_serial=`expr $extracted_serial + 1`
+          my_xlib_u=lt$extracted_serial-$my_xlib ;;
+        *) break ;;
+        esac
+      done
+      extracted_archives="$extracted_archives $my_xlib_u"
+      my_xdir="$my_gentop/$my_xlib_u"
+
+      $show "${rm}r $my_xdir"
+      $run ${rm}r "$my_xdir"
+      $show "$mkdir $my_xdir"
+      $run $mkdir "$my_xdir"
+      exit_status=$?
+      if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
+        exit $exit_status
+      fi
+      case $host in
+      *-darwin*)
+        $show "Extracting $my_xabs"
+        # Do not bother doing anything if just a dry run
+        if test -z "$run"; then
+          darwin_orig_dir=`pwd`
+          cd $my_xdir || exit $?
+          darwin_archive=$my_xabs
+          darwin_curdir=`pwd`
+          darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`
+          darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
+          if test -n "$darwin_arches"; then 
+            darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
+            darwin_arch=
+            $show "$darwin_base_archive has multiple architectures $darwin_arches"
+            for darwin_arch in  $darwin_arches ; do
+              mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
+              lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
+              cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
+              func_extract_an_archive "`pwd`" "${darwin_base_archive}"
+              cd "$darwin_curdir"
+              $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
+            done # $darwin_arches
+      ## Okay now we have a bunch of thin objects, gotta fatten them up :)
+            darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
+            darwin_file=
+            darwin_files=
+            for darwin_file in $darwin_filelist; do
+              darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
+              lipo -create -output "$darwin_file" $darwin_files
+            done # $darwin_filelist
+            ${rm}r unfat-$$
+            cd "$darwin_orig_dir"
+          else
+            cd "$darwin_orig_dir"
+            func_extract_an_archive "$my_xdir" "$my_xabs"
+          fi # $darwin_arches
+        fi # $run
+        ;;
+      *)
+        func_extract_an_archive "$my_xdir" "$my_xabs"
+        ;;
+      esac
+      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
+    done
+    func_extract_archives_result="$my_oldobjs"
+}
 # End of Shell function definitions
 #####################################
 
 # Darwin sucks
 eval std_shrext=\"$shrext_cmds\"
 
+disable_libs=no
+
 # Parse our command line options once, thoroughly.
 while test "$#" -gt 0
 do
   arg="$1"
   shift
 
   case $arg in
   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
   *) optarg= ;;
   esac
@@ skipping 42 matching lines @@
     continue
   fi
 
   # Have we seen a non-optional argument yet?
   case $arg in
   --help)
     show_help=yes
     ;;
 
   --version)
-    $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
-    $echo
-    $echo "Copyright (C) 2003  Free Software Foundation, Inc."
-    $echo "This is free software; see the source for copying conditions.  There is NO"
-    $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
-    exit $EXIT_SUCCESS
+    echo "\
+$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP
+
+Copyright (C) 2008  Free Software Foundation, Inc.
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+    exit $?
     ;;
 
   --config)
     ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
     # Now print the configurations for the tags.
     for tagname in $taglist; do
       ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
     done
-    exit $EXIT_SUCCESS
+    exit $?
     ;;
 
   --debug)
     $echo "$progname: enabling shell trace mode"
     set -x
     preserve_args="$preserve_args $arg"
     ;;
 
   --dry-run | -n)
     run=:
     ;;
 
   --features)
     $echo "host: $host"
     if test "$build_libtool_libs" = yes; then
       $echo "enable shared libraries"
     else
       $echo "disable shared libraries"
     fi
     if test "$build_old_libs" = yes; then
       $echo "enable static libraries"
     else
       $echo "disable static libraries"
     fi
-    exit $EXIT_SUCCESS
+    exit $?
     ;;
 
   --finish) mode="finish" ;;
 
   --mode) prevopt="--mode" prev=mode ;;
   --mode=*) mode="$optarg" ;;
 
   --preserve-dup-deps) duplicate_deps="yes" ;;
 
   --quiet | --silent)
     show=:
     preserve_args="$preserve_args $arg"
     ;;
 
-  --tag) prevopt="--tag" prev=tag ;;
+  --tag)
+    prevopt="--tag"
+    prev=tag
+    preserve_args="$preserve_args --tag"
+    ;;
   --tag=*)
     set tag "$optarg" ${1+"$@"}
     shift
     prev=tag
     preserve_args="$preserve_args --tag"
     ;;
 
   -dlopen)
     prevopt="-dlopen"
     prev=execute_dlfiles
@@ skipping 11 matching lines @@
     ;;
   esac
 done
 
 if test -n "$prevopt"; then
   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
   $echo "$help" 1>&2
   exit $EXIT_FAILURE
 fi
 
+case $disable_libs in
+no) 
+  ;;
+shared)
+  build_libtool_libs=no
+  build_old_libs=yes
+  ;;
+static)
+  build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
+  ;;
+esac
+
 # If this variable is set in any of the actions, the command in it
 # will be execed at the end.  This prevents here-documents from being
 # left over by shells.
 exec_cmd=
 
 if test -z "$show_help"; then
 
   # Infer the operation mode.
   if test -z "$mode"; then
     $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
-    $echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2
+    $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
     case $nonopt in
     *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
       mode=link
       for arg
       do
         case $arg in
         -c)
            mode=compile
            break
            ;;
@@ skipping 45 matching lines @@
     base_compile=
     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
     suppress_opt=yes
     suppress_output=
     arg_mode=normal
     libobj=
     later=
 
     for arg
     do
-      case "$arg_mode" in
+      case $arg_mode in
       arg  )
         # do not "continue".  Instead, add this to base_compile
         lastarg="$arg"
         arg_mode=normal
         ;;
 
       target )
         libobj="$arg"
         arg_mode=normal
         continue
@@ skipping 61 matching lines @@
         esac  #  case $arg
         ;;
       esac    #  case $arg_mode
 
       # Aesthetically quote the previous argument.
       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
 
       case $lastarg in
       # Double-quote args containing other shell metacharacters.
       # Many Bourne shells cannot handle close brackets correctly
-      # in scan sets, so we specify it separately.
+      # in scan sets, and some SunOS ksh mistreat backslash-escaping
+      # in scan sets (worked around with variable expansion),
+      # and furthermore cannot handle '|' '&' '(' ')' in scan sets 
+      # at all, so we specify them separately.
       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
         lastarg="\"$lastarg\""
         ;;
       esac
 
       base_compile="$base_compile $lastarg"
     done # for arg
 
     case $arg_mode in
     arg)
@@ skipping 17 matching lines @@
     *.ada) xform=ada ;;
     *.adb) xform=adb ;;
     *.ads) xform=ads ;;
     *.asm) xform=asm ;;
     *.c++) xform=c++ ;;
     *.cc) xform=cc ;;
     *.ii) xform=ii ;;
     *.class) xform=class ;;
     *.cpp) xform=cpp ;;
     *.cxx) xform=cxx ;;
-    *.f90) xform=f90 ;;
+    *.[fF][09]?) xform=[fF][09]. ;;
     *.for) xform=for ;;
     *.java) xform=java ;;
+    *.obj) xform=obj ;;
+    *.sx) xform=sx ;;
     esac
 
     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
 
     case $libobj in
     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
     *)
       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
       exit $EXIT_FAILURE
       ;;
@@ skipping 13 matching lines @@
         continue
         ;;
 
       -prefer-non-pic)
         pic_mode=no
         continue
         ;;
       esac
     done
 
+    qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
+    case $qlibobj in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
+        qlibobj="\"$qlibobj\"" ;;
+    esac
+    test "X$libobj" != "X$qlibobj" \
+        && $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"'  &()|`$[]' \
+        && $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
     if test "X$xdir" = "X$obj"; then
       xdir=
     else
       xdir=$xdir/
     fi
     lobj=${xdir}$objdir/$objname
 
     if test -z "$base_compile"; then
@@ skipping 52 matching lines @@
 This indicates that another process is trying to use the same
 temporary object file, and libtool could not work around it because
 your compiler does not support \`-c' and \`-o' together.  If you
 repeat this compilation, it may succeed, by chance, but you had better
 avoid parallel builds (make -j) in this platform, or get a better
 compiler."
 
         $run $rm $removelist
         exit $EXIT_FAILURE
       fi
-      $echo $srcfile > "$lockfile"
+      $echo "$srcfile" > "$lockfile"
     fi
 
     if test -n "$fix_srcfile_path"; then
       eval srcfile=\"$fix_srcfile_path\"
     fi
+    qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
+    case $qsrcfile in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
+      qsrcfile="\"$qsrcfile\"" ;;
+    esac
 
     $run $rm "$libobj" "${libobj}T"
 
     # Create a libtool object file (analogous to a ".la" file),
     # but don't create it if we're doing a dry run.
     test -z "$run" && cat > ${libobj}T <<EOF
 # $libobj - a libtool object file
 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 #
 # Please DO NOT delete this file!
 # It is necessary for linking the library.
 
 # Name of the PIC object.
 EOF
 
     # Only build a PIC object if we are building libtool libraries.
     if test "$build_libtool_libs" = yes; then
       # Without this assignment, base_compile gets emptied.
       fbsd_hideous_sh_bug=$base_compile
 
       if test "$pic_mode" != no; then
-        command="$base_compile $srcfile $pic_flag"
+        command="$base_compile $qsrcfile $pic_flag"
       else
         # Don't build PIC code
-        command="$base_compile $srcfile"
+        command="$base_compile $qsrcfile"
       fi
 
       if test ! -d "${xdir}$objdir"; then
         $show "$mkdir ${xdir}$objdir"
         $run $mkdir ${xdir}$objdir
-        status=$?
-        if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then
-          exit $status
+        exit_status=$?
+        if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
+          exit $exit_status
         fi
       fi
 
       if test -z "$output_obj"; then
         # Place PIC objects in $objdir
         command="$command -o $lobj"
       fi
 
       $run $rm "$lobj" "$output_obj"
 
       $show "$command"
-      if $run eval "$command"; then :
+      if $run eval $lt_env "$command"; then :
       else
         test -n "$output_obj" && $run $rm $removelist
         exit $EXIT_FAILURE
       fi
 
       if test "$need_locks" = warn &&
          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
         $echo "\
 *** ERROR, $lockfile contains:
 `cat $lockfile 2>/dev/null`
@@ skipping 39 matching lines @@
       test -z "$run" && cat >> ${libobj}T <<EOF
 pic_object=none
 
 EOF
     fi
 
     # Only build a position-dependent object if we build old libraries.
     if test "$build_old_libs" = yes; then
       if test "$pic_mode" != yes; then
         # Don't build PIC code
-        command="$base_compile $srcfile"
+        command="$base_compile $qsrcfile"
       else
-        command="$base_compile $srcfile $pic_flag"
+        command="$base_compile $qsrcfile $pic_flag"
       fi
       if test "$compiler_c_o" = yes; then
         command="$command -o $obj"
       fi
 
       # Suppress compiler output if we already did a PIC compilation.
       command="$command$suppress_output"
       $run $rm "$obj" "$output_obj"
       $show "$command"
-      if $run eval "$command"; then :
+      if $run eval $lt_env "$command"; then :
       else
         $run $rm $removelist
         exit $EXIT_FAILURE
       fi
 
       if test "$need_locks" = warn &&
          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
         $echo "\
 *** ERROR, $lockfile contains:
 `cat $lockfile 2>/dev/null`
@@ skipping 98 matching lines @@
     export_dynamic=no
     export_symbols=
     export_symbols_regex=
     generated=
     libobjs=
     ltlibs=
     module=no
     no_install=no
     objs=
     non_pic_objects=
+    notinst_path= # paths that contain not-installed libtool libraries
     precious_files_regex=
     prefer_static_libs=no
     preload=no
     prev=
     prevarg=
     release=
     rpath=
     xrpath=
     perm_rpath=
     temp_rpath=
     thread_safe=no
     vinfo=
     vinfo_number=no
+    single_module="${wl}-single_module"
 
     func_infer_tag $base_compile
 
     # We need to know -static, to get the right output filenames.
     for arg
     do
       case $arg in
-      -all-static | -static)
-        if test "X$arg" = "X-all-static"; then
+      -all-static | -static | -static-libtool-libs)
+        case $arg in
+        -all-static)
           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
           fi
           if test -n "$link_static_flag"; then
             dlopen_self=$dlopen_self_static
           fi
-        else
+          prefer_static_libs=yes
+          ;;
+        -static)
           if test -z "$pic_flag" && test -n "$link_static_flag"; then
             dlopen_self=$dlopen_self_static
           fi
-        fi
+          prefer_static_libs=built
+          ;;
+        -static-libtool-libs)
+          if test -z "$pic_flag" && test -n "$link_static_flag"; then
+            dlopen_self=$dlopen_self_static
+          fi
+          prefer_static_libs=yes
+          ;;
+        esac
         build_libtool_libs=no
         build_old_libs=yes
-        prefer_static_libs=yes
         break
         ;;
       esac
     done
 
     # See if our shared archives depend on static archives.
     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
 
     # Go through the arguments, transforming them on the way.
     while test "$#" -gt 0; do
@@ skipping 154 matching lines @@
                 # Non-PIC object.
                 if test "$non_pic_object" != none; then
                   # Prepend the subdirectory the object is found in.
                   non_pic_object="$xdir$non_pic_object"
 
                   # A standard non-PIC object
                   non_pic_objects="$non_pic_objects $non_pic_object"
                   if test -z "$pic_object" || test "$pic_object" = none ; then
                     arg="$non_pic_object"
                   fi
+                else
+                  # If the PIC object exists, use it instead.
+                  # $xdir was prepended to $pic_object above.
+                  non_pic_object="$pic_object"
+                  non_pic_objects="$non_pic_objects $non_pic_object"
                 fi
               else
                 # Only an error if not doing a dry-run.
                 if test -z "$run"; then
                   $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
                   exit $EXIT_FAILURE
                 else
                   # Dry-run case.
 
                   # Extract subdirectory from the argument.
@@ skipping 63 matching lines @@
           prev=
           compile_command="$compile_command $qarg"
           finalize_command="$finalize_command $qarg"
           continue
           ;;
         shrext)
           shrext_cmds="$arg"
           prev=
           continue
           ;;
+        darwin_framework|darwin_framework_skip)
+          test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
+          compile_command="$compile_command $arg"
+          finalize_command="$finalize_command $arg"
+          prev=
+          continue
+          ;;
         *)
           eval "$prev=\"\$arg\""
           prev=
           continue
           ;;
         esac
       fi # test -n "$prev"
 
       prevarg="$arg"
 
@@ skipping 38 matching lines @@
           exit $EXIT_FAILURE
         fi
         if test "X$arg" = "X-export-symbols"; then
           prev=expsyms
         else
           prev=expsyms_regex
         fi
         continue
         ;;
 
+      -framework|-arch|-isysroot)
+        case " $CC " in
+          *" ${arg} ${1} "* | *" ${arg} ${1} "*) 
+                prev=darwin_framework_skip ;;
+          *) compiler_flags="$compiler_flags $arg"
+             prev=darwin_framework ;;
+        esac
+        compile_command="$compile_command $arg"
+        finalize_command="$finalize_command $arg"
+        continue
+        ;;
+
       -inst-prefix-dir)
         prev=inst_prefix
         continue
         ;;
 
       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
       # so, if we see these flags be careful not to treat them like -L
       -L[A-Z][A-Z]*:*)
         case $with_gcc/$host in
         no/*-*-irix* | /*-*-irix*)
           compile_command="$compile_command $arg"
           finalize_command="$finalize_command $arg"
           ;;
         esac
         continue
         ;;
 
       -L*)
         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
         # We need an absolute path.
         case $dir in
         [\\/]* | [A-Za-z]:[\\/]*) ;;
         *)
           absdir=`cd "$dir" && pwd`
           if test -z "$absdir"; then
             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
-            exit $EXIT_FAILURE
+            absdir="$dir"
+            notinst_path="$notinst_path $dir"
           fi
           dir="$absdir"
           ;;
         esac
         case "$deplibs " in
         *" -L$dir "*) ;;
         *)
           deplibs="$deplibs -L$dir"
           lib_search_path="$lib_search_path $dir"
           ;;
         esac
         case $host in
         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+          testbindir=`$echo "X$dir" | $Xsed -e 's*/lib$*/bin*'`
           case :$dllsearchpath: in
           *":$dir:"*) ;;
           *) dllsearchpath="$dllsearchpath:$dir";;
           esac
+          case :$dllsearchpath: in
+          *":$testbindir:"*) ;;
+          *) dllsearchpath="$dllsearchpath:$testbindir";;
+          esac
           ;;
         esac
         continue
         ;;
 
       -l*)
         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
           case $host in
-          *-*-cygwin* | *-*-pw32* | *-*-beos*)
+          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
             # These systems don't actually have a C or math library (as such)
             continue
             ;;
-          *-*-mingw* | *-*-os2*)
+          *-*-os2*)
             # These systems don't actually have a C library (as such)
             test "X$arg" = "X-lc" && continue
             ;;
-          *-*-openbsd* | *-*-freebsd*)
+          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
             # Do not include libc due to us having libc/libc_r.
             test "X$arg" = "X-lc" && continue
             ;;
           *-*-rhapsody* | *-*-darwin1.[012])
             # Rhapsody C and math libraries are in the System framework
             deplibs="$deplibs -framework System"
             continue
+            ;;
+          *-*-sco3.2v5* | *-*-sco5v6*)
+            # Causes problems with __ctype
+            test "X$arg" = "X-lc" && continue
+            ;;
+          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+            # Compiler inserts libc in the correct place for threads to work
+            test "X$arg" = "X-lc" && continue
+            ;;
           esac
         elif test "X$arg" = "X-lc_r"; then
          case $host in
-         *-*-openbsd* | *-*-freebsd*)
+         *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
            # Do not include libc_r directly, use -pthread flag.
            continue
            ;;
          esac
         fi
         deplibs="$deplibs $arg"
         continue
         ;;
 
-     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
-        deplibs="$deplibs $arg"
+      # Tru64 UNIX uses -model [arg] to determine the layout of C++
+      # classes, name mangling, and exception handling.
+      -model)
+        compile_command="$compile_command $arg"
+        compiler_flags="$compiler_flags $arg"
+        finalize_command="$finalize_command $arg"
+        prev=xcompiler
         continue
         ;;
 
+     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
+        compiler_flags="$compiler_flags $arg"
+        compile_command="$compile_command $arg"
+        finalize_command="$finalize_command $arg"
+        continue
+        ;;
+
+      -multi_module)
+        single_module="${wl}-multi_module"
+        continue
+        ;;
+
       -module)
         module=yes
         continue
         ;;
 
-      # gcc -m* arguments should be passed to the linker via $compiler_flags
-      # in order to pass architecture information to the linker
-      # (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo
-      # but this is not reliable with gcc because gcc may use -mfoo to
-      # select a different linker, different libraries, etc, while
-      # -Wl,-mfoo simply passes -mfoo to the linker.
-      -m*)
+      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
+      # -r[0-9][0-9]* specifies the processor on the SGI compiler
+      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
+      # +DA*, +DD* enable 64-bit mode on the HP compiler
+      # -q* pass through compiler args for the IBM compiler
+      # -m* pass through architecture-specific compiler args for GCC
+      # -m*, -t[45]*, -txscale* pass through architecture-specific
+      # compiler args for GCC
+      # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
+      # -F/path gives path to uninstalled frameworks, gcc on darwin
+      # @file GCC response files
+      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
+      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
+
         # Unknown arguments in both finalize_command and compile_command need
         # to be aesthetically quoted because they are evaled later.
         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
         case $arg in
         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
           arg="\"$arg\""
           ;;
         esac
         compile_command="$compile_command $arg"
         finalize_command="$finalize_command $arg"
-        if test "$with_gcc" = "yes" ; then
-          compiler_flags="$compiler_flags $arg"
-        fi
+        compiler_flags="$compiler_flags $arg"
         continue
         ;;
 
       -shrext)
         prev=shrext
         continue
         ;;
 
       -no-fast-install)
         fast_install=no
         continue
         ;;
 
       -no-install)
         case $host in
-        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin*)
           # The PATH hackery in wrapper scripts is required on Windows
-          # in order for the loader to find any dlls it needs.
+          # and Darwin in order for the loader to find any dlls it needs.
           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
           fast_install=no
           ;;
         *) no_install=yes ;;
         esac
         continue
         ;;
 
       -no-undefined)
@@ skipping 38 matching lines @@
           exit $EXIT_FAILURE
           ;;
         esac
         case "$xrpath " in
         *" $dir "*) ;;
         *) xrpath="$xrpath $dir" ;;
         esac
         continue
         ;;
 
-      -static)
+      -static | -static-libtool-libs)
         # The effects of -static are defined in a previous loop.
         # We used to do the same as -all-static on platforms that
         # didn't have a PIC flag, but the assumption that the effects
         # would be equivalent was wrong.  It would break on at least
         # Digital Unix and AIX.
         continue
         ;;
 
       -thread-safe)
         thread_safe=yes
@@ skipping 140 matching lines @@
           # Non-PIC object.
           if test "$non_pic_object" != none; then
             # Prepend the subdirectory the object is found in.
             non_pic_object="$xdir$non_pic_object"
 
             # A standard non-PIC object
             non_pic_objects="$non_pic_objects $non_pic_object"
             if test -z "$pic_object" || test "$pic_object" = none ; then
               arg="$non_pic_object"
             fi
+          else
+            # If the PIC object exists, use it instead.
+            # $xdir was prepended to $pic_object above.
+            non_pic_object="$pic_object"
+            non_pic_objects="$non_pic_objects $non_pic_object"
           fi
         else
           # Only an error if not doing a dry-run.
           if test -z "$run"; then
             $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
             exit $EXIT_FAILURE
           else
             # Dry-run case.
 
             # Extract subdirectory from the argument.
@@ skipping 85 matching lines @@
     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
     if test "X$output_objdir" = "X$output"; then
       output_objdir="$objdir"
     else
       output_objdir="$output_objdir/$objdir"
     fi
     # Create the object directory.
     if test ! -d "$output_objdir"; then
       $show "$mkdir $output_objdir"
       $run $mkdir $output_objdir
-      status=$?
-      if test "$status" -ne 0 && test ! -d "$output_objdir"; then
-        exit $status
+      exit_status=$?
+      if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
+        exit $exit_status
       fi
     fi
 
     # Determine the type of output
     case $output in
     "")
       $echo "$modename: you must specify an output file" 1>&2
       $echo "$help" 1>&2
       exit $EXIT_FAILURE
       ;;
@@ skipping 42 matching lines @@
         done
       fi
       pre_post_deps=
     fi
 
     deplibs=
     newdependency_libs=
     newlib_search_path=
     need_relink=no # whether we're linking any uninstalled libtool libraries
     notinst_deplibs= # not-installed libtool libraries
-    notinst_path= # paths that contain not-installed libtool libraries
     case $linkmode in
     lib)
         passes="conv link"
         for file in $dlfiles $dlprefiles; do
           case $file in
           *.la) ;;
           *)
             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
             exit $EXIT_FAILURE
             ;;
@@ skipping 14 matching lines @@
     for pass in $passes; do
       if test "$linkmode,$pass" = "lib,link" ||
          test "$linkmode,$pass" = "prog,scan"; then
         libs="$deplibs"
         deplibs=
       fi
       if test "$linkmode" = prog; then
         case $pass in
         dlopen) libs="$dlfiles" ;;
         dlpreopen) libs="$dlprefiles" ;;
-        link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
+        link)
+          libs="$deplibs %DEPLIBS%"
+          test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
+          ;;
         esac
       fi
       if test "$pass" = dlopen; then
         # Collect dlpreopened libraries
         save_deplibs="$deplibs"
         deplibs=
       fi
       for deplib in $libs; do
         lib=
         found=no
         case $deplib in
-        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
+        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
           if test "$linkmode,$pass" = "prog,link"; then
             compile_deplibs="$deplib $compile_deplibs"
             finalize_deplibs="$deplib $finalize_deplibs"
           else
-            deplibs="$deplib $deplibs"
+            compiler_flags="$compiler_flags $deplib"
           fi
           continue
           ;;
         -l*)
           if test "$linkmode" != lib && test "$linkmode" != prog; then
             $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
             continue
           fi
-          if test "$pass" = conv; then
-            deplibs="$deplib $deplibs"
-            continue
+          name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
+          if test "$linkmode" = lib; then
+            searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
+          else
+            searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
           fi
-          name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
-          for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
+          for searchdir in $searchdirs; do
             for search_ext in .la $std_shrext .so .a; do
               # Search the libtool library
               lib="$searchdir/lib${name}${search_ext}"
               if test -f "$lib"; then
                 if test "$search_ext" = ".la"; then
                   found=yes
                 else
                   found=no
                 fi
                 break 2
@@ skipping 88 matching lines @@
           continue
           ;;
         *.la) lib="$deplib" ;;
         *.$libext)
           if test "$pass" = conv; then
             deplibs="$deplib $deplibs"
             continue
           fi
           case $linkmode in
           lib)
-            if test "$deplibs_check_method" != pass_all; then
+            valid_a_lib=no
+            case $deplibs_check_method in
+              match_pattern*)
+                set dummy $deplibs_check_method
+                match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
+                if eval $echo \"$deplib\" 2>/dev/null \
+                    | $SED 10q \
+                    | $EGREP "$match_pattern_regex" > /dev/null; then
+                  valid_a_lib=yes
+                fi
+                ;;
+              pass_all)
+                valid_a_lib=yes
+                ;;
+            esac
+            if test "$valid_a_lib" != yes; then
               $echo
               $echo "*** Warning: Trying to link with static lib archive $deplib."
               $echo "*** I have the capability to make that library automatically link in when"
               $echo "*** you link to this library.  But I can only do this if you have a"
               $echo "*** shared version of the library, which you do not appear to have"
               $echo "*** because the file extensions .$libext of this argument makes me believe"
               $echo "*** that it is just a static archive that I should not used here."
             else
               $echo
               $echo "*** Warning: Linking the shared library $output against the"
@@ skipping 29 matching lines @@
           fi
           continue
           ;;
         %DEPLIBS%)
           alldeplibs=yes
           continue
           ;;
         esac # case $deplib
         if test "$found" = yes || test -f "$lib"; then :
         else
-          $echo "$modename: cannot find the library \`$lib'" 1>&2
+          $echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
           exit $EXIT_FAILURE
         fi
 
         # Check to see that this really is a libtool archive.
         if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
         else
           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
           exit $EXIT_FAILURE
         fi
 
         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
         test "X$ladir" = "X$lib" && ladir="."
 
         dlname=
         dlopen=
         dlpreopen=
         libdir=
         library_names=
         old_library=
         # If the library was installed with an old release of libtool,
         # it will not redefine variables installed, or shouldnotlink
         installed=yes
         shouldnotlink=no
+        avoidtemprpath=
+
 
         # Read the .la file
         case $lib in
         */* | *\\*) . $lib ;;
         *) . ./$lib ;;
         esac
 
         if test "$linkmode,$pass" = "lib,link" ||
            test "$linkmode,$pass" = "prog,scan" ||
            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
@@ skipping 78 matching lines @@
         if test "X$installed" = Xyes; then
           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
             $echo "$modename: warning: library \`$lib' was moved." 1>&2
             dir="$ladir"
             absdir="$abs_ladir"
             libdir="$abs_ladir"
           else
             dir="$libdir"
             absdir="$libdir"
           fi
+          test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
         else
-          dir="$ladir/$objdir"
-          absdir="$abs_ladir/$objdir"
-          # Remove this search path later
-          notinst_path="$notinst_path $abs_ladir"
+          if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+            dir="$ladir"
+            absdir="$abs_ladir"
+            # Remove this search path later
+            notinst_path="$notinst_path $abs_ladir"
+          else
+            dir="$ladir/$objdir"
+            absdir="$abs_ladir/$objdir"
+            # Remove this search path later
+            notinst_path="$notinst_path $abs_ladir"
+          fi
         fi # $installed = yes
         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
 
         # This library was specified with -dlpreopen.
         if test "$pass" = dlpreopen; then
           if test -z "$libdir"; then
             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
             exit $EXIT_FAILURE
           fi
           # Prefer using a static library (so that no silly _DYNAMIC symbols
@@ skipping 50 matching lines @@
               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
               esac
             fi
             tmp_libs="$tmp_libs $deplib"
           done # for deplib
           continue
         fi # $linkmode = prog...
 
         if test "$linkmode,$pass" = "prog,link"; then
           if test -n "$library_names" &&
-             { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
+             { { test "$prefer_static_libs" = no ||
+                 test "$prefer_static_libs,$installed" = "built,yes"; } ||
+               test -z "$old_library"; }; then
             # We need to hardcode the library path
-            if test -n "$shlibpath_var"; then
+            if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
               # Make sure the rpath contains only unique directories.
               case "$temp_rpath " in
               *" $dir "*) ;;
               *" $absdir "*) ;;
-              *) temp_rpath="$temp_rpath $dir" ;;
+              *) temp_rpath="$temp_rpath $absdir" ;;
               esac
             fi
 
             # Hardcode the library path.
             # Skip directories that are in the system default run-time
             # search path.
             case " $sys_lib_dlsearch_path " in
             *" $absdir "*) ;;
             *)
               case "$compile_rpath " in
@@ skipping 16 matching lines @@
           if test "$alldeplibs" = yes &&
              { test "$deplibs_check_method" = pass_all ||
                { test "$build_libtool_libs" = yes &&
                  test -n "$library_names"; }; }; then
             # We only need to search for static libraries
             continue
           fi
         fi
 
         link_static=no # Whether the deplib will be linked statically
+        use_static_libs=$prefer_static_libs
+        if test "$use_static_libs" = built && test "$installed" = yes ; then
+          use_static_libs=no
+        fi
         if test -n "$library_names" &&
-           { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
+           { test "$use_static_libs" = no || test -z "$old_library"; }; then
           if test "$installed" = no; then
             notinst_deplibs="$notinst_deplibs $lib"
             need_relink=yes
           fi
           # This is a shared library
 
           # Warn about portability, can't link against -module's on
           # some systems (darwin)
           if test "$shouldnotlink" = yes && test "$pass" = link ; then
             $echo
@@ skipping 92 matching lines @@
           if test "$linkmode" = prog || test "$mode" != relink; then
             add_shlibpath=
             add_dir=
             add=
             lib_linked=yes
             case $hardcode_action in
             immediate | unsupported)
               if test "$hardcode_direct" = no; then
                 add="$dir/$linklib"
                 case $host in
-                  *-*-sco3.2v5* ) add_dir="-L$dir" ;;
+                  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
+                  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
+                  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
+                    *-*-unixware7*) add_dir="-L$dir" ;;
                   *-*-darwin* )
                     # if the lib is a module then we can not link against
                     # it, someone is ignoring the new warnings I added
-                    if /usr/bin/file -L $add 2> /dev/null | $EGREP "bundle" >/dev/null ; then
+                    if /usr/bin/file -L $add 2> /dev/null |
+                      $EGREP ": [^:]* bundle" >/dev/null ; then
                       $echo "** Warning, lib $linklib is a module, not a shared library"
                       if test -z "$old_library" ; then
                         $echo
                         $echo "** And there doesn't seem to be a static archive available"
                         $echo "** The link will probably fail, sorry"
                       else
                         add="$dir/$old_library"
                       fi
                     fi
                 esac
@@ skipping 10 matching lines @@
                 lib_linked=no
               fi
               ;;
             relink)
               if test "$hardcode_direct" = yes; then
                 add="$dir/$linklib"
               elif test "$hardcode_minus_L" = yes; then
                 add_dir="-L$dir"
                 # Try looking first in the location we're being installed to.
                 if test -n "$inst_prefix_dir"; then
-                  case "$libdir" in
+                  case $libdir in
                     [\\/]*)
                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
                       ;;
                   esac
                 fi
                 add="-l$name"
               elif test "$hardcode_shlibpath_var" = yes; then
                 add_shlibpath="$dir"
                 add="-l$name"
               else
@@ skipping 52 matching lines @@
                  test -f "$inst_prefix_dir$libdir/$linklib" ; then
                 add="$inst_prefix_dir$libdir/$linklib"
               else
                 add="$libdir/$linklib"
               fi
             else
               # We cannot seem to hardcode it, guess we'll fake it.
               add_dir="-L$libdir"
               # Try looking first in the location we're being installed to.
               if test -n "$inst_prefix_dir"; then
-                case "$libdir" in
+                case $libdir in
                   [\\/]*)
                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
                     ;;
                 esac
               fi
               add="-l$name"
             fi
 
             if test "$linkmode" = prog; then
               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
@@ skipping 40 matching lines @@
                 $echo "*** \`nm' from GNU binutils and a full rebuild may help."
               fi
               if test "$build_old_libs" = no; then
                 build_libtool_libs=module
                 build_old_libs=yes
               else
                 build_libtool_libs=no
               fi
             fi
           else
-            convenience="$convenience $dir/$old_library"
-            old_convenience="$old_convenience $dir/$old_library"
             deplibs="$dir/$old_library $deplibs"
             link_static=yes
           fi
         fi # link shared/static library?
 
         if test "$linkmode" = lib; then
           if test -n "$dependency_libs" &&
              { test "$hardcode_into_libs" != yes ||
                test "$build_old_libs" = yes ||
                test "$link_static" = yes; }; then
@@ skipping 58 matching lines @@
                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
                   fi
                   path="$absdir"
                 fi
                 depdepl=
                 case $host in
                 *-*-darwin*)
                   # we do not want to link against static libs,
                   # but need to link against shared
                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
+                  eval deplibdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
                   if test -n "$deplibrary_names" ; then
                     for tmp in $deplibrary_names ; do
                       depdepl=$tmp
                     done
-                    if test -f "$path/$depdepl" ; then
+                    if test -f "$deplibdir/$depdepl" ; then
+                      depdepl="$deplibdir/$depdepl"
+                    elif test -f "$path/$depdepl" ; then
                       depdepl="$path/$depdepl"
+                    else
+                      # Can't find it, oh well...
+                      depdepl=
                     fi
                     # do not add paths which are already there
                     case " $newlib_search_path " in
                     *" $path "*) ;;
                     *) newlib_search_path="$newlib_search_path $path";;
                     esac
                   fi
                   path=""
                   ;;
                 *)
@@ skipping 13 matching lines @@
                     fi
                   done
                   path=""
                   ;;
                 *) continue ;;
                 esac
                 ;;
               *) continue ;;
               esac
               case " $deplibs " in
+              *" $path "*) ;;
+              *) deplibs="$path $deplibs" ;;
+              esac
+              case " $deplibs " in
               *" $depdepl "*) ;;
               *) deplibs="$depdepl $deplibs" ;;
               esac
-              case " $deplibs " in
-              *" $path "*) ;;
-              *) deplibs="$deplibs $path" ;;
-              esac
             done
           fi # link_all_deplibs != no
         fi # linkmode = lib
       done # for deplib in $libs
       dependency_libs="$newdependency_libs"
       if test "$pass" = dlpreopen; then
         # Link the dlpreopened libraries before other libraries
         for deplib in $save_deplibs; do
           deplibs="$deplib $deplibs"
         done
@@ skipping 87 matching lines @@
       done
       dependency_libs=$tmp_libs
     done # for pass
     if test "$linkmode" = prog; then
       dlfiles="$newdlfiles"
       dlprefiles="$newdlprefiles"
     fi
 
     case $linkmode in
     oldlib)
-      if test -n "$deplibs"; then
-        $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
-      fi
+      case " $deplibs" in
+      *\ -l* | *\ -L*)
+        $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2 ;;
+      esac
 
       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
       fi
 
       if test -n "$rpath"; then
         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
       fi
 
       if test -n "$xrpath"; then
@@ skipping 107 matching lines @@
           number_minor="$3"
           number_revision="$4"
           #
           # There are really only two kinds -- those that
           # use the current revision as the major version
           # and those that subtract age and use age as
           # a minor version.  But, then there is irix
           # which has an extra 1 added just for fun
           #
           case $version_type in
-          darwin|linux|osf|windows)
+          darwin|linux|osf|windows|none)
             current=`expr $number_major + $number_minor`
             age="$number_minor"
             revision="$number_revision"
             ;;
           freebsd-aout|freebsd-elf|sunos)
             current="$number_major"
             revision="$number_minor"
             age="0"
             ;;
           irix|nonstopux)
-            current=`expr $number_major + $number_minor - 1`
+            current=`expr $number_major + $number_minor`
             age="$number_minor"
             revision="$number_minor"
+            lt_irix_increment=no
+            ;;
+          *)
+            $echo "$modename: unknown library version type \`$version_type'" 1>&2
+            $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
+            exit $EXIT_FAILURE
             ;;
           esac
           ;;
         no)
           current="$2"
           revision="$3"
           age="$4"
           ;;
         esac
 
         # Check that each of the things are valid numbers.
         case $current in
-        [0-9]*) ;;
+        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
         *)
-          $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
+          $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
           exit $EXIT_FAILURE
           ;;
         esac
 
         case $revision in
-        [0-9]*) ;;
+        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
         *)
-          $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
+          $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
           exit $EXIT_FAILURE
           ;;
         esac
 
         case $age in
-        [0-9]*) ;;
+        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
         *)
-          $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
+          $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
           exit $EXIT_FAILURE
           ;;
         esac
 
         if test "$age" -gt "$current"; then
           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
           exit $EXIT_FAILURE
         fi
 
         # Calculate the version variables.
         major=
         versuffix=
         verstring=
         case $version_type in
         none) ;;
 
         darwin)
           # Like Linux, but with the current version available in
           # verstring for coding it into the library header
           major=.`expr $current - $age`
           versuffix="$major.$age.$revision"
           # Darwin ld doesn't like 0 for these options...
           minor_current=`expr $current + 1`
+          xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
           ;;
 
         freebsd-aout)
           major=".$current"
           versuffix=".$current.$revision";
           ;;
 
         freebsd-elf)
           major=".$current"
           versuffix=".$current";
           ;;
 
         irix | nonstopux)
-          major=`expr $current - $age + 1`
-
+          if test "X$lt_irix_increment" = "Xno"; then
+            major=`expr $current - $age`
+          else
+            major=`expr $current - $age + 1`
+          fi
           case $version_type in
             nonstopux) verstring_prefix=nonstopux ;;
             *)         verstring_prefix=sgi ;;
           esac
           verstring="$verstring_prefix$major.$revision"
 
           # Add in all the interfaces that we are compatible with.
           loop=$revision
           while test "$loop" -ne 0; do
             iface=`expr $revision - $loop`
@@ skipping 116 matching lines @@
 
       # Now set the variables for building old libraries.
       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
         oldlibs="$oldlibs $output_objdir/$libname.$libext"
 
         # Transform .lo files to .o files.
         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
       fi
 
       # Eliminate all temporary directories.
-      for path in $notinst_path; do
-        lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
-        deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
-        dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
-      done
+      #for path in $notinst_path; do
+      # lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
+      # deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
+      # dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
+      #done
 
       if test -n "$xrpath"; then
         # If the user specified any rpath flags, then add them.
         temp_xrpath=
         for libdir in $xrpath; do
           temp_xrpath="$temp_xrpath -R$libdir"
           case "$finalize_rpath " in
           *" $libdir "*) ;;
           *) finalize_rpath="$finalize_rpath $libdir" ;;
           esac
@@ skipping 29 matching lines @@
           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
             # these systems don't actually have a c library (as such)!
             ;;
           *-*-rhapsody* | *-*-darwin1.[012])
             # Rhapsody C library is in the System framework
             deplibs="$deplibs -framework System"
             ;;
           *-*-netbsd*)
             # Don't link with libc until the a.out ld.so is fixed.
             ;;
-          *-*-openbsd* | *-*-freebsd*)
+          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
             # Do not include libc due to us having libc/libc_r.
-            test "X$arg" = "X-lc" && continue
+            ;;
+          *-*-sco3.2v5* | *-*-sco5v6*)
+            # Causes problems with __ctype
+            ;;
+          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+            # Compiler inserts libc in the correct place for threads to work
             ;;
           *)
             # Add libc to deplibs on all other systems if necessary.
             if test "$build_libtool_need_lc" = "yes"; then
               deplibs="$deplibs -lc"
             fi
             ;;
           esac
         fi
 
@@ skipping 23 matching lines @@
         test_compile)
           # This code stresses the "libraries are programs" paradigm to its
           # limits. Maybe even breaks it.  We compile a program, linking it
           # against the deplibs as a proxy for the library.  Then we can check
           # whether they linked in statically or dynamically with ldd.
           $rm conftest.c
           cat > conftest.c <<EOF
           int main() { return 0; }
 EOF
           $rm conftest
-          $LTCC -o conftest conftest.c $deplibs
-          if test "$?" -eq 0 ; then
+          if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
             ldd_output=`ldd conftest`
             for i in $deplibs; do
-              name="`expr $i : '-l\(.*\)'`"
+              name=`expr $i : '-l\(.*\)'`
               # If $name is empty we are operating on a -L argument.
-              if test "$name" != "" && test "$name" -ne "0"; then
+              if test "$name" != "" && test "$name" != "0"; then
                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   case " $predeps $postdeps " in
                   *" $i "*)
                     newdeplibs="$newdeplibs $i"
                     i=""
                     ;;
                   esac
                 fi
                 if test -n "$i" ; then
                   libname=`eval \\$echo \"$libname_spec\"`
@@ skipping 14 matching lines @@
                   fi
                 fi
               else
                 newdeplibs="$newdeplibs $i"
               fi
             done
           else
             # Error occurred in the first compile.  Let's try to salvage
             # the situation: Compile a separate program for each library.
             for i in $deplibs; do
-              name="`expr $i : '-l\(.*\)'`"
+              name=`expr $i : '-l\(.*\)'`
               # If $name is empty we are operating on a -L argument.
               if test "$name" != "" && test "$name" != "0"; then
                 $rm conftest
-                $LTCC -o conftest conftest.c $i
-                # Did it work?
-                if test "$?" -eq 0 ; then
+                if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
                   ldd_output=`ldd conftest`
                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                     case " $predeps $postdeps " in
                     *" $i "*)
                       newdeplibs="$newdeplibs $i"
                       i=""
                       ;;
                     esac
                   fi
                   if test -n "$i" ; then
@@ skipping 11 matching lines @@
                       $echo "*** you link to this library.  But I can only do this if you have a"
                       $echo "*** shared version of the library, which you do not appear to have"
                       $echo "*** because a test_compile did reveal that the linker did not use this one"
                       $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
                     fi
                   fi
                 else
                   droppeddeps=yes
                   $echo
                   $echo "*** Warning!  Library $i is needed by this library but I was not able to"
-                  $echo "***  make it link in!  You will probably need to install it or some"
+                  $echo "*** make it link in!  You will probably need to install it or some"
                   $echo "*** library that it depends on before this library will be fully"
                   $echo "*** functional.  Installing it before continuing would be even better."
                 fi
               else
                 newdeplibs="$newdeplibs $i"
               fi
             done
           fi
           ;;
         file_magic*)
           set dummy $deplibs_check_method
           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
           for a_deplib in $deplibs; do
-            name="`expr $a_deplib : '-l\(.*\)'`"
+            name=`expr $a_deplib : '-l\(.*\)'`
             # If $name is empty we are operating on a -L argument.
             if test "$name" != "" && test  "$name" != "0"; then
               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                 case " $predeps $postdeps " in
                 *" $a_deplib "*)
                   newdeplibs="$newdeplibs $a_deplib"
                   a_deplib=""
                   ;;
                 esac
               fi
@@ skipping 48 matching lines @@
             else
               # Add a -L argument.
               newdeplibs="$newdeplibs $a_deplib"
             fi
           done # Gone through all deplibs.
           ;;
         match_pattern*)
           set dummy $deplibs_check_method
           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
           for a_deplib in $deplibs; do
-            name="`expr $a_deplib : '-l\(.*\)'`"
+            name=`expr $a_deplib : '-l\(.*\)'`
             # If $name is empty we are operating on a -L argument.
             if test -n "$name" && test "$name" != "0"; then
               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                 case " $predeps $postdeps " in
                 *" $a_deplib "*)
                   newdeplibs="$newdeplibs $a_deplib"
                   a_deplib=""
                   ;;
                 esac
               fi
@@ skipping 109 matching lines @@
               else
                 build_libtool_libs=no
               fi
             fi
           fi
         fi
         # Done checking deplibs!
         deplibs=$newdeplibs
       fi
 
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+        case " $new_libs " in
+        *" -L$path/$objdir "*) ;;
+        *)
+          case " $deplibs " in
+          *" -L$path/$objdir "*)
+            new_libs="$new_libs -L$path/$objdir" ;;
+          esac
+          ;;
+        esac
+      done
+      for deplib in $deplibs; do
+        case $deplib in
+        -L*)
+          case " $new_libs " in
+          *" $deplib "*) ;;
+          *) new_libs="$new_libs $deplib" ;;
+          esac
+          ;;
+        *) new_libs="$new_libs $deplib" ;;
+        esac
+      done
+      deplibs="$new_libs"
+
+
       # All the library-specific variables (install_libdir is set above).
       library_names=
       old_library=
       dlname=
 
       # Test again, we may have decided not to build it any more
       if test "$build_libtool_libs" = yes; then
         if test "$hardcode_into_libs" = yes; then
           # Hardcode the library paths
           hardcode_libdirs=
@@ skipping 24 matching lines @@
               *" $libdir "*) ;;
               *) perm_rpath="$perm_rpath $libdir" ;;
               esac
             fi
           done
           # Substitute the hardcoded libdirs into the rpath.
           if test -n "$hardcode_libdir_separator" &&
              test -n "$hardcode_libdirs"; then
             libdir="$hardcode_libdirs"
             if test -n "$hardcode_libdir_flag_spec_ld"; then
-              eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
+              case $archive_cmds in
+              *\$LD*) eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" ;;
+              *)      eval dep_rpath=\"$hardcode_libdir_flag_spec\" ;;
+              esac
             else
               eval dep_rpath=\"$hardcode_libdir_flag_spec\"
             fi
           fi
           if test -n "$runpath_var" && test -n "$perm_rpath"; then
             # We should set the runpath_var.
             rpath=
             for dir in $perm_rpath; do
               rpath="$rpath$dir:"
             done
@@ skipping 18 matching lines @@
         if test -n "$soname_spec"; then
           eval soname=\"$soname_spec\"
         else
           soname="$realname"
         fi
         if test -z "$dlname"; then
           dlname=$soname
         fi
 
         lib="$output_objdir/$realname"
+        linknames=
         for link
         do
           linknames="$linknames $link"
         done
 
         # Use standard objects if they are pic
         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 
         # Prepare the list of exported symbols
         if test -z "$export_symbols"; then
           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
             $show "generating symbol list for \`$libname.la'"
             export_symbols="$output_objdir/$libname.exp"
             $run $rm $export_symbols
             cmds=$export_symbols_cmds
             save_ifs="$IFS"; IFS='~'
             for cmd in $cmds; do
               IFS="$save_ifs"
               eval cmd=\"$cmd\"
               if len=`expr "X$cmd" : ".*"` &&
                test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
                 $show "$cmd"
                 $run eval "$cmd" || exit $?
                 skipped_export=false
               else
                 # The command line is too long to execute in one step.
                 $show "using reloadable object file for export list..."
                 skipped_export=:
+                # Break out early, otherwise skipped_export may be
+                # set to false by a later but shorter cmd.
+                break
               fi
             done
             IFS="$save_ifs"
             if test -n "$export_symbols_regex"; then
               $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
               $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
               $run eval '$mv "${export_symbols}T" "$export_symbols"'
             fi
           fi
@@ skipping 13 matching lines @@
                 esac
         done
         deplibs="$tmp_deplibs"
 
         if test -n "$convenience"; then
           if test -n "$whole_archive_flag_spec"; then
             save_libobjs=$libobjs
             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
           else
             gentop="$output_objdir/${outputname}x"
-            $show "${rm}r $gentop"
-            $run ${rm}r "$gentop"
-            $show "$mkdir $gentop"
-            $run $mkdir "$gentop"
-            status=$?
-            if test "$status" -ne 0 && test ! -d "$gentop"; then
-              exit $status
-            fi
             generated="$generated $gentop"
 
-            for xlib in $convenience; do
-              # Extract the objects.
-              case $xlib in
-              [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
-              *) xabs=`pwd`"/$xlib" ;;
-              esac
-              xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
-              xdir="$gentop/$xlib"
-
-              $show "${rm}r $xdir"
-              $run ${rm}r "$xdir"
-              $show "$mkdir $xdir"
-              $run $mkdir "$xdir"
-              status=$?
-              if test "$status" -ne 0 && test ! -d "$xdir"; then
-                exit $status
-              fi
-              # We will extract separately just the conflicting names and we will no
-              # longer touch any unique names. It is faster to leave these extract
-              # automatically by $AR in one run.
-              $show "(cd $xdir && $AR x $xabs)"
-              $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
-              if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
-                :
-              else
-                $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
-                $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
-                $AR t "$xabs" | sort | uniq -cd | while read -r count name
-                do
-                  i=1
-                  while test "$i" -le "$count"
-                  do
-                   # Put our $i before any first dot (extension)
-                   # Never overwrite any file
-                   name_to="$name"
-                   while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
-                   do
-                     name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
-                   done
-                   $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
-                   $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
-                   i=`expr $i + 1`
-                  done
-                done
-              fi
-
-              libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
-            done
+            func_extract_archives $gentop $convenience
+            libobjs="$libobjs $func_extract_archives_result"
           fi
         fi
-
+        
         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
           eval flag=\"$thread_safe_flag_spec\"
           linker_flags="$linker_flags $flag"
         fi
 
         # Make a backup of the uninstalled library when relinking
         if test "$mode" = relink; then
           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
         fi
 
         # Do each of the archive commands.
         if test "$module" = yes && test -n "$module_cmds" ; then
           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
             eval test_cmds=\"$module_expsym_cmds\"
             cmds=$module_expsym_cmds
           else
             eval test_cmds=\"$module_cmds\"
             cmds=$module_cmds
           fi
         else
         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
           eval test_cmds=\"$archive_expsym_cmds\"
           cmds=$archive_expsym_cmds
         else
           eval test_cmds=\"$archive_cmds\"
           cmds=$archive_cmds
           fi
         fi
 
-        if test "X$skipped_export" != "X:" && len=`expr "X$test_cmds" : ".*"` &&
+        if test "X$skipped_export" != "X:" &&
+           len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
            test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
           :
         else
           # The command line is too long to link in one step, link piecewise.
           $echo "creating reloadable object files..."
 
           # Save the value of $output and $libobjs because we want to
           # use them later.  If we have whole_archive_flag_spec, we
           # want to use save_libobjs as it was before
           # whole_archive_flag_spec was expanded, because we can't
           # assume the linker understands whole_archive_flag_spec.
           # This may have to be revisited, in case too many
           # convenience libraries get linked in and end up exceeding
           # the spec.
           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
             save_libobjs=$libobjs
           fi
           save_output=$output
+          output_la=`$echo "X$output" | $Xsed -e "$basename"`
 
           # Clear the reloadable object creation command queue and
           # initialize k to one.
           test_cmds=
           concat_cmds=
           objlist=
           delfiles=
           last_robj=
           k=1
-          output=$output_objdir/$save_output-${k}.$objext
+          output=$output_objdir/$output_la-${k}.$objext
           # Loop over the list of objects to be linked.
           for obj in $save_libobjs
           do
             eval test_cmds=\"$reload_cmds $objlist $last_robj\"
             if test "X$objlist" = X ||
-               { len=`expr "X$test_cmds" : ".*"` &&
+               { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
                  test "$len" -le "$max_cmd_len"; }; then
               objlist="$objlist $obj"
             else
               # The command $test_cmds is almost too long, add a
               # command to the queue.
               if test "$k" -eq 1 ; then
                 # The first file doesn't have a previous command to add.
                 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
               else
                 # All subsequent reloadable object files will link in
                 # the last one created.
                 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
               fi
-              last_robj=$output_objdir/$save_output-${k}.$objext
+              last_robj=$output_objdir/$output_la-${k}.$objext
               k=`expr $k + 1`
-              output=$output_objdir/$save_output-${k}.$objext
+              output=$output_objdir/$output_la-${k}.$objext
               objlist=$obj
               len=1
             fi
           done
           # Handle the remaining objects by creating one last
           # reloadable object file.  All subsequent reloadable object
           # files will link in the last one created.
           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
           eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
 
           if ${skipped_export-false}; then
             $show "generating symbol list for \`$libname.la'"
             export_symbols="$output_objdir/$libname.exp"
             $run $rm $export_symbols
             libobjs=$output
             # Append the command to create the export file.
             eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
           fi
 
-          # Set up a command to remove the reloadale object files
+          # Set up a command to remove the reloadable object files
           # after they are used.
           i=0
           while test "$i" -lt "$k"
           do
             i=`expr $i + 1`
-            delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
+            delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
           done
 
           $echo "creating a temporary reloadable object file: $output"
 
           # Loop through the commands generated above and execute them.
           save_ifs="$IFS"; IFS='~'
           for cmd in $concat_cmds; do
             IFS="$save_ifs"
             $show "$cmd"
             $run eval "$cmd" || exit $?
@@ skipping 27 matching lines @@
 
           # Append the command to remove the reloadable object files
           # to the just-reset $cmds.
           eval cmds=\"\$cmds~\$rm $delfiles\"
         fi
         save_ifs="$IFS"; IFS='~'
         for cmd in $cmds; do
           IFS="$save_ifs"
           eval cmd=\"$cmd\"
           $show "$cmd"
-          $run eval "$cmd" || exit $?
+          $run eval "$cmd" || {
+            lt_exit=$?
+
+            # Restore the uninstalled library and exit
+            if test "$mode" = relink; then
+              $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
+            fi
+
+            exit $lt_exit
+          }
         done
         IFS="$save_ifs"
 
         # Restore the uninstalled library and exit
         if test "$mode" = relink; then
           $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
+
+          if test -n "$convenience"; then
+            if test -z "$whole_archive_flag_spec"; then
+              $show "${rm}r $gentop"
+              $run ${rm}r "$gentop"
+            fi
+          fi
+
           exit $EXIT_SUCCESS
         fi
 
         # Create links to the real library.
         for linkname in $linknames; do
           if test "$realname" != "$linkname"; then
             $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
             $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
           fi
         done
 
         # If -module or -export-dynamic was specified, set the dlname.
         if test "$module" = yes || test "$export_dynamic" = yes; then
           # On all known operating systems, these are identical.
           dlname="$soname"
         fi
       fi
       ;;
 
     obj)
-      if test -n "$deplibs"; then
-        $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
-      fi
+      case " $deplibs" in
+      *\ -l* | *\ -L*)
+        $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2 ;;
+      esac
 
       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
       fi
 
       if test -n "$rpath"; then
         $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
       fi
 
       if test -n "$xrpath"; then
@@ skipping 26 matching lines @@
       # Delete the old objects.
       $run $rm $obj $libobj
 
       # Objects from convenience libraries.  This assumes
       # single-version convenience libraries.  Whenever we create
       # different ones for PIC/non-PIC, this we'll have to duplicate
       # the extraction.
       reload_conv_objs=
       gentop=
       # reload_cmds runs $LD directly, so let us get rid of
-      # -Wl from whole_archive_flag_spec
+      # -Wl from whole_archive_flag_spec and hope we can get by with
+      # turning comma into space..
       wl=
 
       if test -n "$convenience"; then
         if test -n "$whole_archive_flag_spec"; then
-          eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
+          eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
+          reload_conv_objs=$reload_objs\ `$echo "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
         else
           gentop="$output_objdir/${obj}x"
-          $show "${rm}r $gentop"
-          $run ${rm}r "$gentop"
-          $show "$mkdir $gentop"
-          $run $mkdir "$gentop"
-          status=$?
-          if test "$status" -ne 0 && test ! -d "$gentop"; then
-            exit $status
-          fi
           generated="$generated $gentop"
 
-          for xlib in $convenience; do
-            # Extract the objects.
-            case $xlib in
-            [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
-            *) xabs=`pwd`"/$xlib" ;;
-            esac
-            xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
-            xdir="$gentop/$xlib"
-
-            $show "${rm}r $xdir"
-            $run ${rm}r "$xdir"
-            $show "$mkdir $xdir"
-            $run $mkdir "$xdir"
-            status=$?
-            if test "$status" -ne 0 && test ! -d "$xdir"; then
-              exit $status
-            fi
-            # We will extract separately just the conflicting names and we will no
-            # longer touch any unique names. It is faster to leave these extract
-            # automatically by $AR in one run.
-            $show "(cd $xdir && $AR x $xabs)"
-            $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
-            if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
-              :
-            else
-              $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
-              $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
-              $AR t "$xabs" | sort | uniq -cd | while read -r count name
-              do
-                i=1
-                while test "$i" -le "$count"
-                do
-                 # Put our $i before any first dot (extension)
-                 # Never overwrite any file
-                 name_to="$name"
-                 while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
-                 do
-                   name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
-                 done
-                 $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
-                 $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
-                 i=`expr $i + 1`
-                done
-              done
-            fi
-
-            reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
-          done
+          func_extract_archives $gentop $convenience
+          reload_conv_objs="$reload_objs $func_extract_archives_result"
         fi
       fi
 
       # Create the old-style object.
       reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
 
       output="$obj"
       cmds=$reload_cmds
       save_ifs="$IFS"; IFS='~'
       for cmd in $cmds; do
@@ skipping 80 matching lines @@
       case $host in
       *darwin*)
         # Don't allow lazy linking, it breaks C++ global constructors
         if test "$tagname" = CXX ; then
         compile_command="$compile_command ${wl}-bind_at_load"
         finalize_command="$finalize_command ${wl}-bind_at_load"
         fi
         ;;
       esac
 
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+        case " $new_libs " in
+        *" -L$path/$objdir "*) ;;
+        *)
+          case " $compile_deplibs " in
+          *" -L$path/$objdir "*)
+            new_libs="$new_libs -L$path/$objdir" ;;
+          esac
+          ;;
+        esac
+      done
+      for deplib in $compile_deplibs; do
+        case $deplib in
+        -L*)
+          case " $new_libs " in
+          *" $deplib "*) ;;
+          *) new_libs="$new_libs $deplib" ;;
+          esac
+          ;;
+        *) new_libs="$new_libs $deplib" ;;
+        esac
+      done
+      compile_deplibs="$new_libs"
+
+
       compile_command="$compile_command $compile_deplibs"
       finalize_command="$finalize_command $finalize_deplibs"
 
       if test -n "$rpath$xrpath"; then
         # If the user specified any rpath flags, then add them.
         for libdir in $rpath $xrpath; do
           # This is the magic to use -rpath.
           case "$finalize_rpath " in
           *" $libdir "*) ;;
           *) finalize_rpath="$finalize_rpath $libdir" ;;
@@ skipping 24 matching lines @@
             rpath="$rpath $flag"
           fi
         elif test -n "$runpath_var"; then
           case "$perm_rpath " in
           *" $libdir "*) ;;
           *) perm_rpath="$perm_rpath $libdir" ;;
           esac
         fi
         case $host in
         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+          testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
           case :$dllsearchpath: in
           *":$libdir:"*) ;;
           *) dllsearchpath="$dllsearchpath:$libdir";;
           esac
+          case :$dllsearchpath: in
+          *":$testbindir:"*) ;;
+          *) dllsearchpath="$dllsearchpath:$testbindir";;
+          esac
           ;;
         esac
       done
       # Substitute the hardcoded libdirs into the rpath.
       if test -n "$hardcode_libdir_separator" &&
          test -n "$hardcode_libdirs"; then
         libdir="$hardcode_libdirs"
         eval rpath=\" $hardcode_libdir_flag_spec\"
       fi
       compile_rpath="$rpath"
@@ skipping 93 matching lines @@
               $run eval '$mv "$nlist"T "$nlist"'
             fi
 
             if test -n "$export_symbols_regex"; then
               $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
               $run eval '$mv "$nlist"T "$nlist"'
             fi
 
             # Prepare the list of exported symbols
             if test -z "$export_symbols"; then
-              export_symbols="$output_objdir/$output.exp"
+              export_symbols="$output_objdir/$outputname.exp"
               $run $rm $export_symbols
-              $run eval "${SED} -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
+              $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
+              case $host in
+              *cygwin* | *mingw* )
+                $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+                $run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
+                ;;
+              esac
             else
-              $run eval "${SED} -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
-              $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
+              $run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
+              $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
               $run eval 'mv "$nlist"T "$nlist"'
+              case $host in
+              *cygwin* | *mingw* )
+                $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+                $run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
+                ;;
+              esac
             fi
           fi
 
           for arg in $dlprefiles; do
             $show "extracting global C symbols from \`$arg'"
             name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
             $run eval '$echo ": $name " >> "$nlist"'
             $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
           done
 
@@ skipping 30 matching lines @@
 #undef lt_preloaded_symbols
 
 #if defined (__STDC__) && __STDC__
 # define lt_ptr void *
 #else
 # define lt_ptr char *
 # define const
 #endif
 
 /* The mapping between symbol names and symbols. */
+"
+
+            case $host in
+            *cygwin* | *mingw* )
+          $echo >> "$output_objdir/$dlsyms" "\
+/* DATA imports from DLLs on WIN32 can't be const, because
+   runtime relocations are performed -- see ld's documentation
+   on pseudo-relocs */
+struct {
+"
+              ;;
+            * )
+          $echo >> "$output_objdir/$dlsyms" "\
 const struct {
+"
+              ;;
+            esac
+
+
+          $echo >> "$output_objdir/$dlsyms" "\
   const char *name;
   lt_ptr address;
 }
 lt_preloaded_symbols[] =
 {\
 "
 
             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
 
             $echo >> "$output_objdir/$dlsyms" "\
@@ skipping 26 matching lines @@
             *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
             esac;;
           *-*-hpux*)
             case "$compile_command " in
             *" -static "*) ;;
             *) pic_flag_for_symtable=" $pic_flag";;
             esac
           esac
 
           # Now compile the dynamic symbol file.
-          $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
-          $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
+          $show "(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
+          $run eval '(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
 
           # Clean up the generated files.
           $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
           $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
 
           # Transform the symbol file into the correct name.
-          compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
-          finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+          case $host in
+          *cygwin* | *mingw* )
+            if test -f "$output_objdir/${outputname}.def" ; then
+              compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
+              finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
+            else
+              compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
+              finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
+             fi
+            ;;
+          * )
+            compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
+            finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
+            ;;
+          esac
           ;;
         *)
           $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
           exit $EXIT_FAILURE
           ;;
         esac
       else
         # We keep going just in case the user didn't refer to
         # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
         # really was required.
 
         # Nullify the symbol file.
-        compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
-        finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
+        compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
+        finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
       fi
 
       if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
         # Replace the output file specification.
-        compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
+        compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$output"'%g' | $NL2SP`
         link_command="$compile_command$compile_rpath"
 
         # We have no uninstalled library dependencies, so finalize right now.
         $show "$link_command"
         $run eval "$link_command"
-        status=$?
+        exit_status=$?
 
         # Delete the generated files.
         if test -n "$dlsyms"; then
           $show "$rm $output_objdir/${outputname}S.${objext}"
           $run $rm "$output_objdir/${outputname}S.${objext}"
         fi
 
-        exit $status
+        exit $exit_status
       fi
 
       if test -n "$shlibpath_var"; then
         # We should set the shlibpath_var
         rpath=
         for dir in $temp_rpath; do
           case $dir in
           [\\/]* | [A-Za-z]:[\\/]*)
             # Absolute path.
             rpath="$rpath$dir:"
@@ skipping 52 matching lines @@
         # Fast installation is not supported
         link_command="$compile_var$compile_command$compile_rpath"
         relink_command="$finalize_var$finalize_command$finalize_rpath"
 
         $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
         $echo "$modename: \`$output' will be relinked during installation" 1>&2
       else
         if test "$fast_install" != no; then
           link_command="$finalize_var$compile_command$finalize_rpath"
           if test "$fast_install" = yes; then
-            relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
+            relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $SP2NL | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g' | $NL2SP`
           else
             # fast_install is set to needless
             relink_command=
           fi
         else
           link_command="$compile_var$compile_command$compile_rpath"
           relink_command="$finalize_var$finalize_command$finalize_rpath"
         fi
       fi
 
@@ skipping 16 matching lines @@
           if eval test -z \"\${$var+set}\"; then
             relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
           elif eval var_value=\$$var; test -z "$var_value"; then
             relink_command="$var=; export $var; $relink_command"
           else
             var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
             relink_command="$var=\"$var_value\"; export $var; $relink_command"
           fi
         done
         relink_command="(cd `pwd`; $relink_command)"
-        relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
+        relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
       fi
 
       # Quote $echo for shipping.
       if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
         case $progpath in
         [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
         *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
         esac
         qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
       else
         qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
       fi
 
       # Only actually do things if our run command is non-null.
       if test -z "$run"; then
         # win32 will think the script is a binary if it has
         # a .exe suffix, so we strip it off here.
         case $output in
           *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
         esac
         # test for cygwin because mv fails w/o .exe extensions
         case $host in
           *cygwin*)
             exeext=.exe
             outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
           *) exeext= ;;
         esac
         case $host in
           *cygwin* | *mingw* )
-            cwrappersource=`$echo ${objdir}/lt-${output}.c`
-            cwrapper=`$echo ${output}.exe`
-            $rm $cwrappersource $cwrapper
-            trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
+            output_name=`basename $output`
+            output_path=`dirname $output`
+            cwrappersource="$output_path/$objdir/lt-$output_name.c"
+            cwrapper="$output_path/$output_name.exe"
+            $rm $cwrappersource $cwrapper
+            trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
 
             cat > $cwrappersource <<EOF
 
 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
    Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 
    The $output program cannot be directly executed until all the libtool
    libraries that it depends on are installed.
 
    This wrapper executable should never be moved out of the build directory.
    If it is, it will not operate correctly.
 
    Currently, it simply execs the wrapper *script* "/bin/sh $output",
    but could eventually absorb all of the scripts functionality and
    exec $objdir/$outputname directly.
 */
 EOF
             cat >> $cwrappersource<<"EOF"
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <malloc.h>
 #include <stdarg.h>
 #include <assert.h>
+#include <string.h>
+#include <ctype.h>
+#include <sys/stat.h>
 
 #if defined(PATH_MAX)
 # define LT_PATHMAX PATH_MAX
 #elif defined(MAXPATHLEN)
 # define LT_PATHMAX MAXPATHLEN
 #else
 # define LT_PATHMAX 1024
 #endif
 
 #ifndef DIR_SEPARATOR
-#define DIR_SEPARATOR '/'
+# define DIR_SEPARATOR '/'
+# define PATH_SEPARATOR ':'
 #endif
 
 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
   defined (__OS2__)
-#define HAVE_DOS_BASED_FILE_SYSTEM
-#ifndef DIR_SEPARATOR_2
-#define DIR_SEPARATOR_2 '\\'
-#endif
+# define HAVE_DOS_BASED_FILE_SYSTEM
+# ifndef DIR_SEPARATOR_2
+#  define DIR_SEPARATOR_2 '\\'
+# endif
+# ifndef PATH_SEPARATOR_2
+#  define PATH_SEPARATOR_2 ';'
+# endif
 #endif
 
 #ifndef DIR_SEPARATOR_2
 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
 #else /* DIR_SEPARATOR_2 */
 # define IS_DIR_SEPARATOR(ch) \
         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
 #endif /* DIR_SEPARATOR_2 */
 
+#ifndef PATH_SEPARATOR_2
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
+#else /* PATH_SEPARATOR_2 */
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
+#endif /* PATH_SEPARATOR_2 */
+
 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
 #define XFREE(stale) do { \
   if (stale) { free ((void *) stale); stale = 0; } \
 } while (0)
 
+/* -DDEBUG is fairly common in CFLAGS.  */
+#undef DEBUG
+#if defined DEBUGWRAPPER
+# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
+#else
+# define DEBUG(format, ...)
+#endif
+
 const char *program_name = NULL;
 
 void * xmalloc (size_t num);
 char * xstrdup (const char *string);
-char * basename (const char *name);
-char * fnqualify(const char *path);
+const char * base_name (const char *name);
+char * find_executable(const char *wrapper);
+int    check_executable(const char *path);
 char * strendzap(char *str, const char *pat);
 void lt_fatal (const char *message, ...);
 
 int
 main (int argc, char *argv[])
 {
   char **newargz;
   int i;
 
-  program_name = (char *) xstrdup ((char *) basename (argv[0]));
+  program_name = (char *) xstrdup (base_name (argv[0]));
+  DEBUG("(main) argv[0]      : %s\n",argv[0]);
+  DEBUG("(main) program_name : %s\n",program_name);
   newargz = XMALLOC(char *, argc+2);
 EOF
 
-            cat >> $cwrappersource <<EOF
-  newargz[0] = "$SHELL";
+            cat >> $cwrappersource <<EOF
+  newargz[0] = (char *) xstrdup("$SHELL");
 EOF
 
-            cat >> $cwrappersource <<"EOF"
-  newargz[1] = fnqualify(argv[0]);
+            cat >> $cwrappersource <<"EOF"
+  newargz[1] = find_executable(argv[0]);
+  if (newargz[1] == NULL)
+    lt_fatal("Couldn't find %s", argv[0]);
+  DEBUG("(main) found exe at : %s\n",newargz[1]);
   /* we know the script has the same name, without the .exe */
   /* so make sure newargz[1] doesn't end in .exe */
   strendzap(newargz[1],".exe");
   for (i = 1; i < argc; i++)
     newargz[i+1] = xstrdup(argv[i]);
   newargz[argc+1] = NULL;
+
+  for (i=0; i<argc+1; i++)
+  {
+    DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);
+    ;
+  }
+
 EOF
 
-            cat >> $cwrappersource <<EOF
+            case $host_os in
+              mingw*)
+                cat >> $cwrappersource <<EOF
+  execv("$SHELL",(char const **)newargz);
+EOF
+              ;;
+              *)
+                cat >> $cwrappersource <<EOF
   execv("$SHELL",newargz);
 EOF
+              ;;
+            esac
 
-            cat >> $cwrappersource <<"EOF"
+            cat >> $cwrappersource <<"EOF"
+  return 127;
 }
 
 void *
 xmalloc (size_t num)
 {
   void * p = (void *) malloc (num);
   if (!p)
     lt_fatal ("Memory exhausted");
 
   return p;
 }
 
 char *
 xstrdup (const char *string)
 {
   return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
 ;
 }
 
-char *
-basename (const char *name)
+const char *
+base_name (const char *name)
 {
   const char *base;
 
 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
   /* Skip over the disk name in MSDOS pathnames. */
-  if (isalpha (name[0]) && name[1] == ':')
+  if (isalpha ((unsigned char)name[0]) && name[1] == ':')
     name += 2;
 #endif
 
   for (base = name; *name; name++)
     if (IS_DIR_SEPARATOR (*name))
       base = name + 1;
-  return (char *) base;
+  return base;
+}
+
+int
+check_executable(const char * path)
+{
+  struct stat st;
+
+  DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
+  if ((!path) || (!*path))
+    return 0;
+
+  if ((stat (path, &st) >= 0) &&
+      (
+        /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
+#if defined (S_IXOTH)
+       ((st.st_mode & S_IXOTH) == S_IXOTH) ||
+#endif
+#if defined (S_IXGRP)
+       ((st.st_mode & S_IXGRP) == S_IXGRP) ||
+#endif
+       ((st.st_mode & S_IXUSR) == S_IXUSR))
+      )
+    return 1;
+  else
+    return 0;
+}
+
+/* Searches for the full path of the wrapper.  Returns
+   newly allocated full path name if found, NULL otherwise */
+char *
+find_executable (const char* wrapper)
+{
+  int has_slash = 0;
+  const char* p;
+  const char* p_next;
+  /* static buffer for getcwd */
+  char tmp[LT_PATHMAX + 1];
+  int tmp_len;
+  char* concat_name;
+
+  DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
+
+  if ((wrapper == NULL) || (*wrapper == '\0'))
+    return NULL;
+
+  /* Absolute path? */
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+  if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
+  {
+    concat_name = xstrdup (wrapper);
+    if (check_executable(concat_name))
+      return concat_name;
+    XFREE(concat_name);
+  }
+  else
+  {
+#endif
+    if (IS_DIR_SEPARATOR (wrapper[0]))
+    {
+      concat_name = xstrdup (wrapper);
+      if (check_executable(concat_name))
+        return concat_name;
+      XFREE(concat_name);
+    }
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+  }
+#endif
+
+  for (p = wrapper; *p; p++)
+    if (*p == '/')
+    {
+      has_slash = 1;
+      break;
+    }
+  if (!has_slash)
+  {
+    /* no slashes; search PATH */
+    const char* path = getenv ("PATH");
+    if (path != NULL)
+    {
+      for (p = path; *p; p = p_next)
+      {
+        const char* q;
+        size_t p_len;
+        for (q = p; *q; q++)
+          if (IS_PATH_SEPARATOR(*q))
+            break;
+        p_len = q - p;
+        p_next = (*q == '\0' ? q : q + 1);
+        if (p_len == 0)
+        {
+          /* empty path: current directory */
+          if (getcwd (tmp, LT_PATHMAX) == NULL)
+            lt_fatal ("getcwd failed");
+          tmp_len = strlen(tmp);
+          concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
+          memcpy (concat_name, tmp, tmp_len);
+          concat_name[tmp_len] = '/';
+          strcpy (concat_name + tmp_len + 1, wrapper);
+        }
+        else
+        {
+          concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
+          memcpy (concat_name, p, p_len);
+          concat_name[p_len] = '/';
+          strcpy (concat_name + p_len + 1, wrapper);
+        }
+        if (check_executable(concat_name))
+          return concat_name;
+        XFREE(concat_name);
+      }
+    }
+    /* not found in PATH; assume curdir */
+  }
+  /* Relative path | not found in path: prepend cwd */
+  if (getcwd (tmp, LT_PATHMAX) == NULL)
+    lt_fatal ("getcwd failed");
+  tmp_len = strlen(tmp);
+  concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
+  memcpy (concat_name, tmp, tmp_len);
+  concat_name[tmp_len] = '/';
+  strcpy (concat_name + tmp_len + 1, wrapper);
+
+  if (check_executable(concat_name))
+    return concat_name;
+  XFREE(concat_name);
+  return NULL;
 }
 
 char *
-fnqualify(const char *path)
-{
-  size_t size;
-  char *p;
-  char tmp[LT_PATHMAX + 1];
-
-  assert(path != NULL);
-
-  /* Is it qualified already? */
-#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
-  if (isalpha (path[0]) && path[1] == ':')
-    return xstrdup (path);
-#endif
-  if (IS_DIR_SEPARATOR (path[0]))
-    return xstrdup (path);
-
-  /* prepend the current directory */
-  /* doesn't handle '~' */
-  if (getcwd (tmp, LT_PATHMAX) == NULL)
-    lt_fatal ("getcwd failed");
-  size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '\0' */
-  p = XMALLOC(char, size);
-  sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path);
-  return p;
-}
-
-char *
 strendzap(char *str, const char *pat)
 {
   size_t len, patlen;
 
   assert(str != NULL);
   assert(pat != NULL);
 
   len = strlen(str);
   patlen = strlen(pat);
 
@@ skipping 20 matching lines @@
 
 void
 lt_fatal (const char *message, ...)
 {
   va_list ap;
   va_start (ap, message);
   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
   va_end (ap);
 }
 EOF
-          # we should really use a build-platform specific compiler
-          # here, but OTOH, the wrappers (shell script and this C one)
-          # are only useful if you want to execute the "real" binary.
-          # Since the "real" binary is built for $host, then this
-          # wrapper might as well be built for $host, too.
-          $run $LTCC -s -o $cwrapper $cwrappersource
-          ;;
-        esac
-        $rm $output
-        trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
+          # we should really use a build-platform specific compiler
+          # here, but OTOH, the wrappers (shell script and this C one)
+          # are only useful if you want to execute the "real" binary.
+          # Since the "real" binary is built for $host, then this
+          # wrapper might as well be built for $host, too.
+          $run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
+          ;;
+        esac
+        $rm $output
+        trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
 
         $echo > $output "\
 #! $SHELL
 
 # $output - temporary wrapper script for $objdir/$outputname
 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 #
 # The $output program cannot be directly executed until all the libtool
 # libraries that it depends on are installed.
 #
 # This wrapper script should never be moved out of the build directory.
 # If it is, it will not operate correctly.
 
 # Sed substitution that helps us do robust quoting.  It backslashifies
 # metacharacters that are still active within double-quoted strings.
 Xsed='${SED} -e 1s/^X//'
 sed_quote_subst='$sed_quote_subst'
 
+# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
+if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
+fi
+BIN_SH=xpg4; export BIN_SH # for Tru64
+DUALCASE=1; export DUALCASE # for MKS sh
+
 # The HP-UX ksh and POSIX shell print the target directory to stdout
 # if CDPATH is set.
-if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 
 relink_command=\"$relink_command\"
 
 # This environment variable determines our operation mode.
 if test \"\$libtool_install_magic\" = \"$magic\"; then
   # install mode needs the following variable:
   notinst_deplibs='$notinst_deplibs'
 else
   # When we are sourced in execute mode, \$file and \$echo are already set.
   if test \"\$libtool_execute_magic\" != \"$magic\"; then
@@ skipping 108 matching lines @@
         fi
 
         $echo >> $output "\
     if test \"\$libtool_execute_magic\" != \"$magic\"; then
       # Run the actual program with our arguments.
 "
         case $host in
         # Backslashes separate directories on plain windows
         *-*-mingw | *-*-os2*)
           $echo >> $output "\
-      exec \$progdir\\\\\$program \${1+\"\$@\"}
+      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
 "
           ;;
 
         *)
           $echo >> $output "\
-      exec \$progdir/\$program \${1+\"\$@\"}
+      exec \"\$progdir/\$program\" \${1+\"\$@\"}
 "
           ;;
         esac
         $echo >> $output "\
-      \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
+      \$echo \"\$0: cannot exec \$program \$*\"
       exit $EXIT_FAILURE
     fi
   else
     # The program doesn't exist.
-    \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
+    \$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
     \$echo \"This script is just a wrapper for \$program.\" 1>&2
     $echo \"See the $PACKAGE documentation for more information.\" 1>&2
     exit $EXIT_FAILURE
   fi
 fi\
 "
         chmod +x $output
       fi
       exit $EXIT_SUCCESS
       ;;
@@ skipping 11 matching lines @@
           oldobjs="$libobjs_save"
           build_libtool_libs=no
         else
           oldobjs="$old_deplibs $non_pic_objects"
         fi
         addlibs="$old_convenience"
       fi
 
       if test -n "$addlibs"; then
         gentop="$output_objdir/${outputname}x"
-        $show "${rm}r $gentop"
-        $run ${rm}r "$gentop"
-        $show "$mkdir $gentop"
-        $run $mkdir "$gentop"
-        status=$?
-        if test "$status" -ne 0 && test ! -d "$gentop"; then
-          exit $status
-        fi
         generated="$generated $gentop"
 
-        # Add in members from convenience archives.
-        for xlib in $addlibs; do
-          # Extract the objects.
-          case $xlib in
-          [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
-          *) xabs=`pwd`"/$xlib" ;;
-          esac
-          xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
-          xdir="$gentop/$xlib"
-
-          $show "${rm}r $xdir"
-          $run ${rm}r "$xdir"
-          $show "$mkdir $xdir"
-          $run $mkdir "$xdir"
-          status=$?
-          if test "$status" -ne 0 && test ! -d "$xdir"; then
-            exit $status
-          fi
-          # We will extract separately just the conflicting names and we will no
-          # longer touch any unique names. It is faster to leave these extract
-          # automatically by $AR in one run.
-          $show "(cd $xdir && $AR x $xabs)"
-          $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
-          if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
-            :
-          else
-            $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
-            $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
-            $AR t "$xabs" | sort | uniq -cd | while read -r count name
-            do
-              i=1
-              while test "$i" -le "$count"
-              do
-               # Put our $i before any first dot (extension)
-               # Never overwrite any file
-               name_to="$name"
-               while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
-               do
-                 name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
-               done
-               $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
-               $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
-               i=`expr $i + 1`
-              done
-            done
-          fi
-
-          oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP`
-        done
+        func_extract_archives $gentop $addlibs
+        oldobjs="$oldobjs $func_extract_archives_result"
       fi
 
       # Do each command in the archive commands.
       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
        cmds=$old_archive_from_new_cmds
       else
+        # POSIX demands no paths to be encoded in archives.  We have
+        # to avoid creating archives with duplicate basenames if we
+        # might have to extract them afterwards, e.g., when creating a
+        # static archive out of a convenience library, or when linking
+        # the entirety of a libtool archive into another (currently
+        # not supported by libtool).
+        if (for obj in $oldobjs
+            do
+              $echo "X$obj" | $Xsed -e 's%^.*/%%'
+            done | sort | sort -uc >/dev/null 2>&1); then
+          :
+        else
+          $echo "copying selected object files to avoid basename conflicts..."
+
+          if test -z "$gentop"; then
+            gentop="$output_objdir/${outputname}x"
+            generated="$generated $gentop"
+
+            $show "${rm}r $gentop"
+            $run ${rm}r "$gentop"
+            $show "$mkdir $gentop"
+            $run $mkdir "$gentop"
+            exit_status=$?
+            if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
+              exit $exit_status
+            fi
+          fi
+
+          save_oldobjs=$oldobjs
+          oldobjs=
+          counter=1
+          for obj in $save_oldobjs
+          do
+            objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
+            case " $oldobjs " in
+            " ") oldobjs=$obj ;;
+            *[\ /]"$objbase "*)
+              while :; do
+                # Make sure we don't pick an alternate name that also
+                # overlaps.
+                newobj=lt$counter-$objbase
+                counter=`expr $counter + 1`
+                case " $oldobjs " in
+                *[\ /]"$newobj "*) ;;
+                *) if test ! -f "$gentop/$newobj"; then break; fi ;;
+                esac
+              done
+              $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
+              $run ln "$obj" "$gentop/$newobj" ||
+              $run cp "$obj" "$gentop/$newobj"
+              oldobjs="$oldobjs $gentop/$newobj"
+              ;;
+            *) oldobjs="$oldobjs $obj" ;;
+            esac
+          done
+        fi
+
         eval cmds=\"$old_archive_cmds\"
 
         if len=`expr "X$cmds" : ".*"` &&
              test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
           cmds=$old_archive_cmds
         else
           # the command line is too long to link in one step, link in parts
           $echo "using piecewise archive linking..."
           save_RANLIB=$RANLIB
           RANLIB=:
           objlist=
           concat_cmds=
           save_oldobjs=$oldobjs
-          # GNU ar 2.10+ was changed to match POSIX; thus no paths are
-          # encoded into archives.  This makes 'ar r' malfunction in
-          # this piecewise linking case whenever conflicting object
-          # names appear in distinct ar calls; check, warn and compensate.
-            if (for obj in $save_oldobjs
-            do
-              $echo "X$obj" | $Xsed -e 's%^.*/%%'
-            done | sort | sort -uc >/dev/null 2>&1); then
-            :
-          else
-            $echo "$modename: warning: object name conflicts; overriding AR_FLAGS to 'cq'" 1>&2
-            $echo "$modename: warning: to ensure that POSIX-compatible ar will work" 1>&2
-            AR_FLAGS=cq
-          fi
+
           # Is there a better way of finding the last object in the list?
           for obj in $save_oldobjs
           do
             last_oldobj=$obj
           done
           for obj in $save_oldobjs
           do
             oldobjs="$objlist $obj"
             objlist="$objlist $obj"
             eval test_cmds=\"$old_archive_cmds\"
-            if len=`expr "X$test_cmds" : ".*"` &&
+            if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
                test "$len" -le "$max_cmd_len"; then
               :
             else
               # the above command should be used before it gets too long
               oldobjs=$objlist
               if test "$obj" = "$last_oldobj" ; then
                 RANLIB=$save_RANLIB
               fi
               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
               eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
@@ skipping 37 matching lines @@
           relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
         elif eval var_value=\$$var; test -z "$var_value"; then
           relink_command="$var=; export $var; $relink_command"
         else
           var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
           relink_command="$var=\"$var_value\"; export $var; $relink_command"
         fi
       done
       # Quote the link command for shipping.
       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
-      relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
+      relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
       if test "$hardcode_automatic" = yes ; then
         relink_command=
       fi
 
 
       # Only create the output if not a dry run.
       if test -z "$run"; then
         for installed in no yes; do
           if test "$installed" = yes; then
             if test -z "$install_libdir"; then
@@ skipping 118 matching lines @@
     ;;
 
   # libtool install mode
   install)
     modename="$modename: install"
 
     # There may be an optional sh(1) argument at the beginning of
     # install_prog (especially on Windows NT).
     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
        # Allow the use of GNU shtool's install command.
-       $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
+       $echo "X$nonopt" | grep shtool > /dev/null; then
       # Aesthetically quote it.
       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
       case $arg in
-      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
         arg="\"$arg\""
         ;;
       esac
       install_prog="$arg "
       arg="$1"
       shift
     else
       install_prog=
-      arg="$nonopt"
+      arg=$nonopt
     fi
 
     # The real first argument should be the name of the installation program.
     # Aesthetically quote it.
     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
     case $arg in
-    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
+    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
       arg="\"$arg\""
       ;;
     esac
     install_prog="$install_prog$arg"
 
     # We need to accept at least all the BSD install flags.
     dest=
     files=
     opts=
     prev=
     install_type=
     isdir=no
     stripme=
     for arg
     do
       if test -n "$dest"; then
         files="$files $dest"
-        dest="$arg"
+        dest=$arg
         continue
       fi
 
       case $arg in
       -d) isdir=yes ;;
-      -f) prev="-f" ;;
-      -g) prev="-g" ;;
-      -m) prev="-m" ;;
-      -o) prev="-o" ;;
+      -f) 
+        case " $install_prog " in
+        *[\\\ /]cp\ *) ;;
+        *) prev=$arg ;;
+        esac
+        ;;
+      -g | -m | -o) prev=$arg ;;
       -s)
         stripme=" -s"
         continue
         ;;
-      -*) ;;
-
+      -*)
+        ;;
       *)
         # If the previous option needed an argument, then skip it.
         if test -n "$prev"; then
           prev=
         else
-          dest="$arg"
+          dest=$arg
           continue
         fi
         ;;
       esac
 
       # Aesthetically quote the argument.
       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
       case $arg in
-      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
         arg="\"$arg\""
         ;;
       esac
       install_prog="$install_prog $arg"
     done
 
     if test -z "$install_prog"; then
       $echo "$modename: you must specify an install program" 1>&2
       $echo "$help" 1>&2
       exit $EXIT_FAILURE
@@ skipping 114 matching lines @@
           # At present, this check doesn't affect windows .dll's that
           # are installed into $libdir/../bin (currently, that works fine)
           # but it's something to keep an eye on.
           if test "$inst_prefix_dir" = "$destdir"; then
             $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
             exit $EXIT_FAILURE
           fi
 
           if test -n "$inst_prefix_dir"; then
             # Stick the inst_prefix_dir data into the link command.
-            relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
+            relink_command=`$echo "$relink_command" | $SP2NL | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%" | $NL2SP`
           else
-            relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
+            relink_command=`$echo "$relink_command" | $SP2NL | $SED "s%@inst_prefix_dir@%%" | $NL2SP`
           fi
 
           $echo "$modename: warning: relinking \`$file'" 1>&2
           $show "$relink_command"
           if $run eval "$relink_command"; then :
           else
             $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
             exit $EXIT_FAILURE
           fi
         fi
@@ skipping 11 matching lines @@
           # Install the shared library and build the symlinks.
           $show "$install_prog $dir/$srcname $destdir/$realname"
           $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
           if test -n "$stripme" && test -n "$striplib"; then
             $show "$striplib $destdir/$realname"
             $run eval "$striplib $destdir/$realname" || exit $?
           fi
 
           if test "$#" -gt 0; then
             # Delete the old symlinks, and create new ones.
+            # Try `ln -sf' first, because the `ln' binary might depend on
+            # the symlink we replace!  Solaris /bin/ln does not understand -f,
+            # so we also need to try rm && ln -s.
             for linkname
             do
               if test "$linkname" != "$realname"; then
-                $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
-                $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
+                $show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
+                $run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
               fi
             done
           fi
 
           # Do each command in the postinstall commands.
           lib="$destdir/$realname"
           cmds=$postinstall_cmds
           save_ifs="$IFS"; IFS='~'
           for cmd in $cmds; do
             IFS="$save_ifs"
             eval cmd=\"$cmd\"
             $show "$cmd"
-            $run eval "$cmd" || exit $?
+            $run eval "$cmd" || {
+              lt_exit=$?
+
+              # Restore the uninstalled library and exit
+              if test "$mode" = relink; then
+                $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
+              fi
+
+              exit $lt_exit
+            }
           done
           IFS="$save_ifs"
         fi
 
         # Install the pseudo-library for information purposes.
         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
         instname="$dir/$name"i
         $show "$install_prog $instname $destdir/$name"
         $run eval "$install_prog $instname $destdir/$name" || exit $?
 
@@ skipping 73 matching lines @@
             wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
             ;;
         *)
             wrapper=$file
             ;;
         esac
         if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
           notinst_deplibs=
           relink_command=
 
-          # To insure that "foo" is sourced, and not "foo.exe",
-          # finese the cygwin/MSYS system by explicitly sourcing "foo."
-          # which disallows the automatic-append-.exe behavior.
-          case $build in
-          *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
-          *) wrapperdot=${wrapper} ;;
-          esac
+          # Note that it is not necessary on cygwin/mingw to append a dot to
+          # foo even if both foo and FILE.exe exist: automatic-append-.exe
+          # behavior happens only for exec(3), not for open(2)!  Also, sourcing
+          # `FILE.' does not work on cygwin managed mounts.
+          #
           # If there is no directory component, then add one.
-          case $file in
-          */* | *\\*) . ${wrapperdot} ;;
-          *) . ./${wrapperdot} ;;
+          case $wrapper in
+          */* | *\\*) . ${wrapper} ;;
+          *) . ./${wrapper} ;;
           esac
 
           # Check the variables that should have been set.
           if test -z "$notinst_deplibs"; then
             $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
             exit $EXIT_FAILURE
           fi
 
           finalize=yes
           for lib in $notinst_deplibs; do
             # Check to see that each library is installed.
             libdir=
             if test -f "$lib"; then
               # If there is no directory component, then add one.
               case $lib in
               */* | *\\*) . $lib ;;
               *) . ./$lib ;;
               esac
             fi
             libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
             if test -n "$libdir" && test ! -f "$libfile"; then
               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
               finalize=no
             fi
           done
 
           relink_command=
-          # To insure that "foo" is sourced, and not "foo.exe",
-          # finese the cygwin/MSYS system by explicitly sourcing "foo."
-          # which disallows the automatic-append-.exe behavior.
-          case $build in
-          *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
-          *) wrapperdot=${wrapper} ;;
-          esac
+          # Note that it is not necessary on cygwin/mingw to append a dot to
+          # foo even if both foo and FILE.exe exist: automatic-append-.exe
+          # behavior happens only for exec(3), not for open(2)!  Also, sourcing
+          # `FILE.' does not work on cygwin managed mounts.
+          #
           # If there is no directory component, then add one.
-          case $file in
-          */* | *\\*) . ${wrapperdot} ;;
-          *) . ./${wrapperdot} ;;
+          case $wrapper in
+          */* | *\\*) . ${wrapper} ;;
+          *) . ./${wrapper} ;;
           esac
 
           outputname=
           if test "$fast_install" = no && test -n "$relink_command"; then
             if test "$finalize" = yes && test -z "$run"; then
-              tmpdir="/tmp"
-              test -n "$TMPDIR" && tmpdir="$TMPDIR"
-              tmpdir="$tmpdir/libtool-$$"
-              save_umask=`umask`
-              umask 0077
-              if $mkdir "$tmpdir"; then
-                umask $save_umask
-              else
-                umask $save_umask
-                $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
-                continue
-              fi
+              tmpdir=`func_mktempdir`
               file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
               outputname="$tmpdir/$file"
               # Replace the output file specification.
-              relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
+              relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g' | $NL2SP`
 
               $show "$relink_command"
               if $run eval "$relink_command"; then :
               else
                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
                 ${rm}r "$tmpdir"
                 continue
               fi
               file="$outputname"
             else
               $echo "$modename: warning: cannot relink \`$file'" 1>&2
             fi
           else
             # Install the binary that we compiled earlier.
             file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
           fi
         fi
 
         # remove .exe since cygwin /usr/bin/install will append another
-        # one anyways
+        # one anyway 
         case $install_prog,$host in
         */usr/bin/install*,*cygwin*)
           case $file:$destfile in
           *.exe:*.exe)
             # this is ok
             ;;
           *.exe:*)
             destfile=$destfile.exe
             ;;
           *:*.exe)
@@ skipping 79 matching lines @@
           eval cmds=\"$finish_eval\"
           $run eval "$cmds" || admincmds="$admincmds
        $cmds"
         fi
       done
     fi
 
     # Exit here if they wanted silent mode.
     test "$show" = : && exit $EXIT_SUCCESS
 
-    $echo "----------------------------------------------------------------------"
+    $echo "X----------------------------------------------------------------------" | $Xsed
     $echo "Libraries have been installed in:"
     for libdir in $libdirs; do
       $echo "   $libdir"
     done
     $echo
     $echo "If you ever happen to want to link against installed libraries"
     $echo "in a given directory, LIBDIR, you must either use libtool, and"
     $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
     $echo "flag during linking and do at least one of the following:"
     if test -n "$shlibpath_var"; then
@@ skipping 12 matching lines @@
     fi
     if test -n "$admincmds"; then
       $echo "   - have your system administrator run these commands:$admincmds"
     fi
     if test -f /etc/ld.so.conf; then
       $echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
     fi
     $echo
     $echo "See any operating system documentation about shared libraries for"
     $echo "more information, such as the ld(1) and ld.so(8) manual pages."
-    $echo "----------------------------------------------------------------------"
+    $echo "X----------------------------------------------------------------------" | $Xsed
     exit $EXIT_SUCCESS
     ;;
 
   # libtool execute mode
   execute)
     modename="$modename: execute"
 
     # The first argument is the command name.
     cmd="$nonopt"
     if test -z "$cmd"; then
@@ skipping 37 matching lines @@
           test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
           continue
         fi
 
         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
         test "X$dir" = "X$file" && dir=.
 
         if test -f "$dir/$objdir/$dlname"; then
           dir="$dir/$objdir"
         else
-          $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
-          exit $EXIT_FAILURE
+          if test ! -f "$dir/$dlname"; then
+            $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
+            exit $EXIT_FAILURE
+          fi
         fi
         ;;
 
       *.lo)
         # Just add the directory containing the .lo file.
         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
         test "X$dir" = "X$file" && dir=.
         ;;
 
       *)
@@ skipping 43 matching lines @@
       args="$args \"$file\""
     done
 
     if test -z "$run"; then
       if test -n "$shlibpath_var"; then
         # Export the shlibpath_var.
         eval "export $shlibpath_var"
       fi
 
       # Restore saved environment variables
-      if test "${save_LC_ALL+set}" = set; then
-        LC_ALL="$save_LC_ALL"; export LC_ALL
-      fi
-      if test "${save_LANG+set}" = set; then
-        LANG="$save_LANG"; export LANG
-      fi
+      for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+      do
+        eval "if test \"\${save_$lt_var+set}\" = set; then
+                $lt_var=\$save_$lt_var; export $lt_var
+              fi"
+      done
 
       # Now prepare to actually exec the command.
       exec_cmd="\$cmd$args"
     else
       # Display what would be done.
       if test -n "$shlibpath_var"; then
         eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
         $echo "export $shlibpath_var"
       fi
       $echo "$cmd$args"
@@ skipping 68 matching lines @@
       *.la)
         # Possibly a libtool archive, so verify it.
         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
           . $dir/$name
 
           # Delete the libtool libraries and symlinks.
           for n in $library_names; do
             rmfiles="$rmfiles $objdir/$n"
           done
           test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
-          test "$mode" = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
 
-          if test "$mode" = uninstall; then
+          case "$mode" in
+          clean)
+            case "  $library_names " in
+            # "  " in the beginning catches empty $dlname
+            *" $dlname "*) ;;
+            *) rmfiles="$rmfiles $objdir/$dlname" ;;
+            esac
+             test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
+            ;;
+          uninstall)
             if test -n "$library_names"; then
               # Do each command in the postuninstall commands.
               cmds=$postuninstall_cmds
               save_ifs="$IFS"; IFS='~'
               for cmd in $cmds; do
                 IFS="$save_ifs"
                 eval cmd=\"$cmd\"
                 $show "$cmd"
                 $run eval "$cmd"
                 if test "$?" -ne 0 && test "$rmforce" != yes; then
@@ skipping 12 matching lines @@
                 eval cmd=\"$cmd\"
                 $show "$cmd"
                 $run eval "$cmd"
                 if test "$?" -ne 0 && test "$rmforce" != yes; then
                   exit_status=1
                 fi
               done
               IFS="$save_ifs"
             fi
             # FIXME: should reinstall the best remaining shared library.
-          fi
+            ;;
+          esac
         fi
         ;;
 
       *.lo)
         # Possibly a libtool object, so verify it.
         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 
           # Read the .lo file
           . $dir/$name
 
@@ skipping 203 matching lines @@
 a program from several object files.
 
 The following components of LINK-COMMAND are treated specially:
 
   -all-static       do not do any dynamic linking at all
   -avoid-version    do not add a version suffix if possible
   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
   -export-symbols SYMFILE
-                    try to export only the symbols listed in SYMFILE
+                    try to export only the symbols listed in SYMFILE
   -export-symbols-regex REGEX
-                    try to export only the symbols matching REGEX
+                    try to export only the symbols matching REGEX
   -LLIBDIR          search LIBDIR for required installed libraries
   -lNAME            OUTPUT-FILE requires the installed library libNAME
   -module           build a library that can dlopened
   -no-fast-install  disable the fast-install mode
   -no-install       link a not-installable executable
   -no-undefined     declare that a library does not refer to external symbols
   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
   -objectlist FILE  Use a list of object files found in FILE to specify objects
   -precious-files-regex REGEX
                     don't remove output files matching REGEX
   -release RELEASE  specify package release information
   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
-  -static           do not do any dynamic linking of libtool libraries
+  -static           do not do any dynamic linking of uninstalled libtool libraries
+  -static-libtool-libs
+                    do not do any dynamic linking of libtool libraries
   -version-info CURRENT[:REVISION[:AGE]]
-                    specify library version info [each variable defaults to 0]
+                    specify library version info [each variable defaults to 0]
 
 All other options (arguments beginning with \`-') are ignored.
 
 Every other argument is treated as a filename.  Files ending in \`.la' are
 treated as uninstalled libtool libraries, other files are standard or library
 object files.
 
 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
 only library objects (\`.lo' files) may be specified, and \`-rpath' is
 required, except when creating a convenience library.
@@ skipping 22 matching lines @@
 *)
   $echo "$modename: invalid operation mode \`$mode'" 1>&2
   $echo "$help" 1>&2
   exit $EXIT_FAILURE
   ;;
 esac
 
 $echo
 $echo "Try \`$modename --help' for more information about other modes."
 
-exit $EXIT_SUCCESS
+exit $?
 
 # The TAGs below are defined such that we never get into a situation
 # in which we disable both kinds of libraries.  Given conflicting
 # choices, we go for a static library, that is the most portable,
 # since we can't tell whether shared libraries were disabled because
 # the user asked for that or because the platform doesn't support
 # them.  This is particularly important on AIX, because we don't
 # support having both static and shared libraries enabled at the same
 # time on that platform, so we default to a shared-only configuration.
 # If a disable-shared tag is given, we'll fallback to a static-only
 # configuration.  But we'll never go from static-only to shared-only.
 
 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
-build_libtool_libs=no
-build_old_libs=yes
+disable_libs=shared
 # ### END LIBTOOL TAG CONFIG: disable-shared
 
 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
-build_old_libs=`case $build_libtool_libs in yes) $echo no;; *) $echo yes;; esac`
+disable_libs=static
 # ### END LIBTOOL TAG CONFIG: disable-static
 
 # Local Variables:
 # mode:shell-script
 # sh-indentation:2
 # End: