CbC/CbC_gcc: ltmain.sh comparison

comparison ltmain.sh @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children	f6334be47118

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 # Generated from ltmain.m4sh.
-# ltmain.sh (GNU libtool) 2.2.6
+# libtool (GNU libtool 1.3134 2009-11-29) 2.2.7a
 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
-# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
+# 2007, 2008, 2009 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.
 # GNU Libtool is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # Usage: $progname [OPTION]... [MODE-ARG]...
 #
 # Provide generalized library-building support services.
 #
-#     --config             show all configuration variables
+#       --config             show all configuration variables
-#     --debug              enable verbose shell tracing
+#       --debug              enable verbose shell tracing
-# -n, --dry-run            display commands without modifying any files
+#   -n, --dry-run            display commands without modifying any files
-#     --features           display basic configuration information and exit
+#       --features           display basic configuration information and exit
-#     --mode=MODE          use operation mode MODE
+#       --mode=MODE          use operation mode MODE
-#     --preserve-dup-deps  don't remove duplicate dependency libraries
+#       --no-finish          let install mode avoid finish commands
-#     --quiet, --silent    don't print informational messages
+#       --preserve-dup-deps  don't remove duplicate dependency libraries
-#     --tag=TAG            use configuration variables from tag TAG
+#       --quiet, --silent    don't print informational messages
-# -v, --verbose            print informational messages (default)
+#       --no-quiet, --no-silent
-#     --version            print version information
+#                            print informational messages (default)
-# -h, --help               print short or long help message
+#       --tag=TAG            use configuration variables from tag TAG
+#   -v, --verbose            print more informational messages than default
+#       --no-verbose         don't print the extra informational messages
+#       --version            print version information
+#   -h, --help, --help-all   print short, long, or detailed help message
 #
 # MODE must be one of the following:
 #
-#       clean              remove files from the build directory
+#         clean              remove files from the build directory
-#       compile            compile a source file into a libtool object
+#         compile            compile a source file into a libtool object
-#       execute            automatically set library path, then run a program
+#         execute            automatically set library path, then run a program
-#       finish             complete the installation of libtool libraries
+#         finish             complete the installation of libtool libraries
-#       install            install libraries or executables
+#         install            install libraries or executables
-#       link               create a library or an executable
+#         link               create a library or an executable
-#       uninstall          remove libraries from an installed directory
+#         uninstall          remove libraries from an installed directory
 #
-# MODE-ARGS vary depending on the MODE.
+# MODE-ARGS vary depending on the MODE.  When passed as first option,
+# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
 #
 # When reporting a bug, please describe a test case to reproduce it and
 # include the following information:
 #
-#       host-triplet:	$host
+#         host-triplet:	$host
-#       shell:		$SHELL
+#         shell:		$SHELL
-#       compiler:		$LTCC
+#         compiler:		$LTCC
-#       compiler flags:		$LTCFLAGS
+#         compiler flags:		$LTCFLAGS
-#       linker:		$LD (gnu? $with_gnu_ld)
+#         linker:		$LD (gnu? $with_gnu_ld)
-#       $progname:		(GNU libtool) 2.2.6
+#         $progname:	(GNU libtool 1.3134 2009-11-29) 2.2.7a
-#       automake:		$automake_version
+#         automake:	$automake_version
-#       autoconf:		$autoconf_version
+#         autoconf:	$autoconf_version
 #
 # Report bugs to <bug-libtool@gnu.org>.
-PROGRAM=ltmain.sh
+PROGRAM=libtool
 PACKAGE=libtool
-VERSION=2.2.6
+VERSION=2.2.7a
-TIMESTAMP=""
+TIMESTAMP=" 1.3134 2009-11-29"
-package_revision=1.3012
+package_revision=1.3134
 # Be Bourne compatible
 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
 emulate sh
 NULLCMD=:
 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
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+}
 # NLS nuisances: We save the old values to restore during execute mode.
 # 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).
+# 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"
 : ${CP="cp -f"}
-: ${ECHO="echo"}
+: ${ECHO=$as_echo}
-: ${EGREP="/usr/bin/grep -E"}
+: ${EGREP="/bin/grep -E"}
-: ${FGREP="/usr/bin/grep -F"}
+: ${FGREP="/bin/grep -F"}
-: ${GREP="/usr/bin/grep"}
+: ${GREP="/bin/grep"}
 : ${LN_S="ln -s"}
 : ${MAKE="make"}
 : ${MKDIR="mkdir"}
 : ${MV="mv -f"}
 : ${RM="rm -f"}
-: ${SED="/opt/local/bin/gsed"}
+: ${SED="/mount/endor/wildenhu/local-x86_64/bin/sed"}
 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
 : ${Xsed="$SED -e 1s/^X//"}
 # Global variables:
 EXIT_SUCCESS=0
 # and func_basename. For efficiency, we do not delegate to
 # those functions but instead duplicate the functionality here.
 func_dirname_and_basename ()
 {
 # Extract subdirectory from the argument.
-func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
+func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
 if test "X$func_dirname_result" = "X${1}"; then
 func_dirname_result="${3}"
 else
 func_dirname_result="$func_dirname_result${2}"
 fi
-func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
+func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
 }
 # Generated shell functions inserted here.
-# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
+# These SED scripts presuppose an absolute path with a trailing slash.
-# is ksh but when the shell is invoked as "sh" and the current value of
+pathcar='s,^/\([^/]*\).*$,\1,'
-# the _XPG environment variable is not equal to 1 (one), the special
+pathcdr='s,^/[^/]*,,'
-# positional parameter $0, within a function call, is the name of the
+removedotparts=':dotsl
-# function.
+		s@/\./@/@g
-progpath="$0"
+		t dotsl
+		s,/\.$,/,'
+collapseslashes='s@/\{1,\}@/@g'
+finalslash='s,/*$,/,'
+# func_normal_abspath PATH
+# Remove doubled-up and trailing slashes, "." path components,
+# and cancel out any ".." path components in PATH after making
+# it an absolute path.
+#             value returned in "$func_normal_abspath_result"
+func_normal_abspath ()
+{
+# Start from root dir and reassemble the path.
+func_normal_abspath_result=
+func_normal_abspath_tpath=$1
+func_normal_abspath_altnamespace=
+case $func_normal_abspath_tpath in
+"")
+# Empty path, that just means $cwd.
+func_stripname '' '/' "`pwd`"
+func_normal_abspath_result=$func_stripname_result
+return
+;;
+# The next three entries are used to spot a run of precisely
+# two leading slashes without using negated character classes;
+# we take advantage of case's first-match behaviour.
+///*)
+# Unusual form of absolute path, do nothing.
+;;
+//*)
+# Not necessarily an ordinary path; POSIX reserves leading '//'
+# and for example Cygwin uses it to access remote file shares
+# over CIFS/SMB, so we conserve a leading double slash if found.
+func_normal_abspath_altnamespace=/
+;;
+/*)
+# Absolute path, do nothing.
+;;
+*)
+# Relative path, prepend $cwd.
+func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
+;;
+esac
+# Cancel out all the simple stuff to save iterations.  We also want
+# the path to end with a slash for ease of parsing, so make sure
+# there is one (and only one) here.
+func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+-e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
+while :; do
+# Processed it all yet?
+if test "$func_normal_abspath_tpath" = / ; then
+# If we ascended to the root using ".." the result may be empty now.
+if test -z "$func_normal_abspath_result" ; then
+func_normal_abspath_result=/
+fi
+break
+fi
+func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
+-e "$pathcar"`
+func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+-e "$pathcdr"`
+# Figure out what to do with it
+case $func_normal_abspath_tcomponent in
+"")
+# Trailing empty path component, ignore it.
+;;
+..)
+# Parent dir; strip last assembled component from result.
+func_dirname "$func_normal_abspath_result"
+func_normal_abspath_result=$func_dirname_result
+;;
+*)
+# Actual path component, append it.
+func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
+;;
+esac
+done
+# Restore leading double-slash if one was found on entry.
+func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
+}
+# func_relative_path SRCDIR DSTDIR
+# generates a relative path from SRCDIR to DSTDIR, with a trailing
+# slash if non-empty, suitable for immediately appending a filename
+# without needing to append a separator.
+#             value returned in "$func_relative_path_result"
+func_relative_path ()
+{
+func_relative_path_result=
+func_normal_abspath "$1"
+func_relative_path_tlibdir=$func_normal_abspath_result
+func_normal_abspath "$2"
+func_relative_path_tbindir=$func_normal_abspath_result
+# Ascend the tree starting from libdir
+while :; do
+# check if we have found a prefix of bindir
+case $func_relative_path_tbindir in
+$func_relative_path_tlibdir)
+# found an exact match
+func_relative_path_tcancelled=
+break
+;;
+$func_relative_path_tlibdir*)
+# found a matching prefix
+func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
+func_relative_path_tcancelled=$func_stripname_result
+if test -z "$func_relative_path_result"; then
+func_relative_path_result=.
+fi
+break
+;;
+*)
+func_dirname $func_relative_path_tlibdir
+func_relative_path_tlibdir=${func_dirname_result}
+if test "x$func_relative_path_tlibdir" = x ; then
+# Have to descend all the way to the root!
+func_relative_path_result=../$func_relative_path_result
+func_relative_path_tcancelled=$func_relative_path_tbindir
+break
+fi
+func_relative_path_result=../$func_relative_path_result
+;;
+esac
+done
+# Now calculate path; take care to avoid doubling-up slashes.
+func_stripname '' '/' "$func_relative_path_result"
+func_relative_path_result=$func_stripname_result
+func_stripname '/' '/' "$func_relative_path_tcancelled"
+if test "x$func_stripname_result" != x ; then
+func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
+fi
+# Normalisation. If bindir is libdir, return empty string,
+# else relative path ending with a slash; either way, target
+# file name can be directly appended.
+if test ! -z "$func_relative_path_result"; then
+func_stripname './' '' "$func_relative_path_result/"
+func_relative_path_result=$func_stripname_result
+fi
+}
 # The name of this program:
-# In the unlikely event $progname began with a '-', it would play havoc with
-# func_echo (imagine progname=-n), so we prepend ./ in that case:
 func_dirname_and_basename "$progpath"
 progname=$func_basename_result
-case $progname in
--*) progname=./$progname ;;
-esac
 # Make sure we have an absolute path for reexecution:
 case $progpath in
 [\\/]*|[A-Za-z]:\\*) ;;
 *[\\/]*)
 # fails when set -e is in force, so we need another command to
 # work around that:
 :
 }
+# func_echo_all arg...
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+$ECHO "$*"
+}
 # func_error arg...
 # Echo program name prefixed message to standard error.
 func_error ()
 {
 $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
 # If the last portion added has no slash in it, the list is done
 case $my_directory_path in */*) ;; *) break ;; esac
 # ...otherwise throw away the child directory and loop
-my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
+my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
 done
-my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
+my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
 save_mkdir_p_IFS="$IFS"; IFS=':'
 for my_dir in $my_dir_list; do
 	IFS="$save_mkdir_p_IFS"
 # mkdir can fail with a `File exist' error if two processes
 # If we're not in dry-run mode, bomb out on failure
 test -d "$my_tmpdir" || \
 func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
 fi
-$ECHO "X$my_tmpdir" | $Xsed
+$ECHO "$my_tmpdir"
 }
 # func_quote_for_eval arg
 # Aesthetically quote ARG to be evaled later.
 # which are still active within double quotes backslashified.
 func_quote_for_eval ()
 {
 case $1 in
 *[\\\`\"\$]*)
-	func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
+	func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
 *)
 func_quote_for_eval_unquoted_result="$1" ;;
 esac
 case $func_quote_for_eval_unquoted_result in
 # but do not quote variable references.
 func_quote_for_expand ()
 {
 case $1 in
 *[\\\`\"]*)
-	my_arg=`$ECHO "X$1" | $Xsed \
+	my_arg=`$ECHO "$1" | $SED \
 	    -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
 *)
 my_arg="$1" ;;
 esac
 # func_version
 # Echo version message to standard output and exit.
 func_version ()
 {
-$SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
+$SED -n '/(C)/!b go
+	:more
+	/\./!{
+	  N
+	  s/\n# //
+	  b more
+	}
+	:go
+	/^# '$PROGRAM' (GNU /,/# warranty; / {
 s/^# //
 	s/^# *$//
 s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
 p
 }' < "$progpath"
 # func_usage
 # Echo short help message to standard output and exit.
 func_usage ()
 {
-$SED -n '/^# Usage:/,/# -h/ {
+$SED -n '/^# Usage:/,/^#  *-h/ {
 s/^# //
 	s/^# *$//
 	s/\$progname/'$progname'/
 	p
 }' < "$progpath"
-$ECHO
+echo
 $ECHO "run \`$progname --help | more' for full usage"
 exit $?
 }
-# func_help
+# func_help [NOEXIT]
-# Echo long help message to standard output and exit.
+# Echo long help message to standard output and exit,
+# unless 'noexit' is passed as argument.
 func_help ()
 {
 $SED -n '/^# Usage:/,/# Report bugs to/ {
 s/^# //
 	s/^# *$//
 	s/\$with_gnu_ld/'"$with_gnu_ld"'/
 	s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
 	s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
 	p
 }' < "$progpath"
-exit $?
+ret=$?
+if test -z "$1"; then
+exit $ret
+fi
 }
 # func_missing_arg argname
 # Echo program name prefixed message to standard error and set global
 # exit_cmd.
-# 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!
-:
-else
-# Restart under the correct shell, and then maybe $ECHO will work.
-exec $SHELL "$progpath" --no-reexec ${1+"$@"}
-fi
-if test "X$1" = X--fallback-echo; then
-# used as fallback echo
-shift
-cat <<EOF
-$*
-EOF
-exit $EXIT_SUCCESS
-fi
 magic="%%%MAGIC variable%%%"
 magic_exe="%%%MAGIC EXE variable%%%"
 # Global variables.
 o2lo="s/\\.${objext}\$/.lo/"
 extracted_archives=
 extracted_serial=0
 opt_dry_run=false
+opt_finish=:
 opt_duplicate_deps=false
 opt_silent=false
 opt_debug=:
 # If this variable is set in any of the actions, the command in it
 # func_features
 # Display the features supported by this script.
 func_features ()
 {
-$ECHO "host: $host"
+echo "host: $host"
 if test "$build_libtool_libs" = yes; then
-$ECHO "enable shared libraries"
+echo "enable shared libraries"
 else
-$ECHO "disable shared libraries"
+echo "disable shared libraries"
 fi
 if test "$build_old_libs" = yes; then
-$ECHO "enable static libraries"
+echo "enable static libraries"
 else
-$ECHO "disable static libraries"
+echo "disable static libraries"
 fi
 exit $?
 }
 			;;
 --dry-run | -n)	opt_dry_run=:					;;
 --features)       func_features					;;
 --finish)		mode="finish"					;;
+--no-finish)	opt_finish=false				;;
 --mode)		test "$#" -eq 0 && func_missing_arg "$opt" && break
 			case $1 in
 			  # Valid mode arguments:
 			  clean)	;;
 --preserve-dup-deps)
 			opt_duplicate_deps=:				;;
 --quiet|--silent)	preserve_args="$preserve_args $opt"
 			opt_silent=:
+			opt_verbose=false
+			;;
+--no-quiet|--no-silent)
+			preserve_args="$preserve_args $opt"
+			opt_silent=false
 			;;
 --verbose| -v)	preserve_args="$preserve_args $opt"
 			opt_silent=false
+			opt_verbose=:
+			;;
+--no-verbose)	preserve_args="$preserve_args $opt"
+			opt_verbose=false
 			;;
 --tag)		test "$#" -eq 0 && func_missing_arg "$opt" && break
 			preserve_args="$preserve_args $opt $1"
 			func_enable_tag "$1"	# tagname is set here
 			shift
 			;;
 -\?|-h)		func_usage					;;
 --help)		opt_help=:					;;
+--help-all)	opt_help=': help-all'				;;
 --version)	func_version					;;
 -*)		func_fatal_help "unrecognized option \`$opt'"	;;
 *)		nonopt="$opt"
 test -z "$mode" && func_fatal_error "error: you must specify a MODE."
 # Darwin sucks
-eval std_shrext=\"$shrext_cmds\"
+eval "std_shrext=\"$shrext_cmds\""
 # Only execute mode is allowed to have -dlopen flags.
 if test -n "$execute_dlfiles" && test "$mode" != execute; then
 func_error "unrecognized option \`-dlopen'"
 {
 $opt_debug
 save_ifs=$IFS; IFS='~'
 for cmd in $1; do
 IFS=$save_ifs
-eval cmd=\"$cmd\"
+eval "cmd=\"$cmd\""
 func_show_eval "$cmd" "${2-:}"
 done
 IFS=$save_ifs
 }
 CC_quoted=
 for arg in $CC; do
 func_quote_for_eval "$arg"
 	CC_quoted="$CC_quoted $func_quote_for_eval_result"
 done
+CC_expanded=`func_echo_all $CC`
+CC_quoted_expanded=`func_echo_all $CC_quoted`
 case $@ in
 # Blanks in the command may have been stripped by the calling shell,
 # but not from the CC environment variable when configure was run.
-" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
+" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
+" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
 # Blanks at the start of $base_compile will cause this to fail
 # if we don't check for them as well.
 *)
 	for z in $available_tags; do
 	  if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
 	    for arg in $CC; do
 	      # Double-quote args containing other shell metacharacters.
 	      func_quote_for_eval "$arg"
 	      CC_quoted="$CC_quoted $func_quote_for_eval_result"
 	    done
+	    CC_expanded=`func_echo_all $CC`
+	    CC_quoted_expanded=`func_echo_all $CC_quoted`
 	    case "$@ " in
-	      " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
+	    " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
+	    " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
 	      # The compiler in the base compile command matches
 	      # the one in the tagged configuration.
 	      # Assume this is the tagged configuration we want.
 	      tagname=$z
 	      break
 # If the user specifies -o file.o, it is replaced with file.lo
 case $libobj in
 *.[cCFSifmso] | \
 *.ada | *.adb | *.ads | *.asm | \
 *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
-*.[fF][09]? | *.for | *.java | *.obj | *.sx)
+*.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
 func_xform "$libobj"
 libobj=$func_xform_result
 ;;
 esac
 fi
 # Calculate the filename of the output object if compiler does
 # not support -o with -c
 if test "$compiler_c_o" = no; then
-output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
+output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
 lockfile="$output_obj.lock"
 else
 output_obj=
 need_locks=no
 lockfile=
 $opt_dry_run || $RM $removelist
 removelist="$removelist $lockfile"
 trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
 if test -n "$fix_srcfile_path"; then
-eval srcfile=\"$fix_srcfile_path\"
+eval "srcfile=\"$fix_srcfile_path\""
 fi
 func_quote_for_eval "$srcfile"
 qsrcfile=$func_quote_for_eval_result
 # Only build a PIC object if we are building libtool libraries.
 exit $EXIT_SUCCESS
 }
 $opt_help || {
 test "$mode" = compile && func_mode_compile ${1+"$@"}
 }
 func_mode_help ()
 {
 # We need to display help for each of the modes.
 -no-suppress      do not suppress compiler output for multiple passes
 -prefer-pic       try to building PIC objects only
 -prefer-non-pic   try to building non-PIC objects only
 -shared           do not build a \`.o' file suitable for static linking
 -static           only build a \`.o' file suitable for static linking
+-Wc,FLAG          pass FLAG directly to the compiler
 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
 from the given SOURCEFILE.
 The output file name is determined by removing the directory component from
 INSTALL-COMMAND is the installation command.  The first component should be
 either the \`install' or \`cp' program.
 The following components of INSTALL-COMMAND are treated specially:
--inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
+-inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
 The rest of the components are interpreted as arguments to that command (only
 BSD-compatible install options are recognized)."
 ;;
 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
+-bindir BINDIR    specify path to binaries directory (for systems where
+libraries must be found in the PATH setting at runtime)
 -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
 -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]
 -weak LIBNAME     declare that the target provides the LIBNAME interface
+-Wc,FLAG
+-Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
+-Wl,FLAG
+-Xlinker FLAG     pass linker-specific FLAG directly to the linker
+-XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
 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
 *)
 func_fatal_help "invalid operation mode \`$mode'"
 ;;
 esac
-$ECHO
+echo
 $ECHO "Try \`$progname --help' for more information about other modes."
-exit $?
 }
 # Now that we've collected a possible --mode arg, show help if necessary
-$opt_help && func_mode_help
+if $opt_help; then
+if test "$opt_help" = :; then
+func_mode_help
+else
+{
+func_help noexit
+for mode in compile link execute install finish uninstall clean; do
+	func_mode_help
+done
+} | sed -n '1p; 2,$s/^Usage:/  or: /p'
+{
+func_help noexit
+for mode in compile link execute install finish uninstall clean; do
+	echo
+	func_mode_help
+done
+} |
+sed '1d
+/^When reporting/,/^Report/{
+	H
+	d
+}
+$x
+/information about other modes/d
+/more detailed .*MODE/d
+s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
+fi
+exit $?
+fi
 # func_mode_execute arg...
 func_mode_execute ()
 {
 # Get the absolute pathname.
 absdir=`cd "$dir" && pwd`
 test -n "$absdir" && dir="$absdir"
 # Now add the directory to shlibpath_var.
-if eval "test -z \"\$$shlibpath_var\""; then
+if eval test -z \"\$$shlibpath_var\"; then
-	eval "$shlibpath_var=\"\$dir\""
+	eval $shlibpath_var=\$dir
 else
-	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
+	eval $shlibpath_var=\$dir:\$$shlibpath_var
 fi
 done
 # This variable tells wrapper scripts just to set shlibpath_var
 # rather than running their programs.
 # Check if any of the arguments is a wrapper script.
 args=
 for file
 do
 case $file in
--*) ;;
+-* | *.la | *.lo ) ;;
 *)
 	# Do a test to see if this is really a libtool program.
 	if func_ltwrapper_script_p "$file"; then
 	  func_source "$file"
 	  # Transform arg to wrapped name.
 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"
+	echo "export $shlibpath_var"
 fi
 $ECHO "$cmd$args"
 exit $EXIT_SUCCESS
 fi
 }
 fi
 # Exit here if they wanted silent mode.
 $opt_silent && exit $EXIT_SUCCESS
-$ECHO "X----------------------------------------------------------------------" | $Xsed
+echo "----------------------------------------------------------------------"
-$ECHO "Libraries have been installed in:"
+echo "Libraries have been installed in:"
 for libdir in $libdirs; do
 $ECHO "   $libdir"
 done
-$ECHO
+echo
-$ECHO "If you ever happen to want to link against installed libraries"
+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 "in a given directory, LIBDIR, you must either use libtool, and"
-$ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
+echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
-$ECHO "flag during linking and do at least one of the following:"
+echo "flag during linking and do at least one of the following:"
 if test -n "$shlibpath_var"; then
-$ECHO "   - add LIBDIR to the \`$shlibpath_var' environment variable"
+echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
-$ECHO "     during execution"
+echo "     during execution"
 fi
 if test -n "$runpath_var"; then
-$ECHO "   - add LIBDIR to the \`$runpath_var' environment variable"
+echo "   - add LIBDIR to the \`$runpath_var' environment variable"
-$ECHO "     during linking"
+echo "     during linking"
 fi
 if test -n "$hardcode_libdir_flag_spec"; then
 libdir=LIBDIR
-eval flag=\"$hardcode_libdir_flag_spec\"
+eval "flag=\"$hardcode_libdir_flag_spec\""
 $ECHO "   - use the \`$flag' linker flag"
 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'"
+echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
 fi
-$ECHO
+echo
-$ECHO "See any operating system documentation about shared libraries for"
+echo "See any operating system documentation about shared libraries for"
 case $host in
 solaris2.[6789]|solaris2.1[0-9])
-$ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
+echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
-	$ECHO "pages."
+	echo "pages."
 	;;
 *)
-$ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
+echo "more information, such as the ld(1) and ld.so(8) manual pages."
 ;;
 esac
-$ECHO "X----------------------------------------------------------------------" | $Xsed
+echo "----------------------------------------------------------------------"
 exit $EXIT_SUCCESS
 }
 test "$mode" = finish && func_mode_finish ${1+"$@"}
 $opt_debug
 # 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" | $GREP shtool >/dev/null; then
+case $nonopt in *shtool*) :;; *) false;; esac; then
 # Aesthetically quote it.
 func_quote_for_eval "$nonopt"
 install_prog="$func_quote_for_eval_result "
 arg=$1
 shift
 # The real first argument should be the name of the installation program.
 # Aesthetically quote it.
 func_quote_for_eval "$arg"
 install_prog="$install_prog$func_quote_for_eval_result"
+install_shared_prog=$install_prog
+case " $install_prog " in
+*[\\\ /]cp\ *) install_cp=: ;;
+*) install_cp=false ;;
+esac
 # We need to accept at least all the BSD install flags.
 dest=
 files=
 opts=
 prev=
 install_type=
 isdir=no
 stripme=
+no_mode=:
 for arg
 do
+arg2=
 if test -n "$dest"; then
 	files="$files $dest"
 	dest=$arg
 	continue
 fi
 case $arg in
 -d) isdir=yes ;;
 -f)
-	case " $install_prog " in
+	if $install_cp; then :; else
-	*[\\\ /]cp\ *) ;;
+	  prev=$arg
-	*) prev=$arg ;;
+	fi
-	esac
 	;;
 -g | -m | -o)
 	prev=$arg
 	;;
 -s)
 -*)
 	;;
 *)
 	# If the previous option needed an argument, then skip it.
 	if test -n "$prev"; then
+	  if test "x$prev" = x-m && test -n "$install_override_mode"; then
+	    arg2=$install_override_mode
+	    no_mode=false
+	  fi
 	  prev=
 	else
 	  dest=$arg
 	  continue
 	fi
 esac
 # Aesthetically quote the argument.
 func_quote_for_eval "$arg"
 install_prog="$install_prog $func_quote_for_eval_result"
+if test -n "$arg2"; then
+	func_quote_for_eval "$arg2"
+fi
+install_shared_prog="$install_shared_prog $func_quote_for_eval_result"
 done
 test -z "$install_prog" && \
 func_fatal_help "you must specify an install program"
 test -n "$prev" && \
 func_fatal_help "the \`$prev' option requires an argument"
+if test -n "$install_override_mode" && $no_mode; then
+if $install_cp; then :; else
+	func_quote_for_eval "$install_override_mode"
+	install_shared_prog="$install_shared_prog -m $func_quote_for_eval_result"
+fi
+fi
 if test -z "$files"; then
 if test -z "$dest"; then
 	func_fatal_help "no file or destination specified"
 else
 	dir="$func_dirname_result"
 	dir="$dir$objdir"
 	if test -n "$relink_command"; then
 	  # Determine the prefix the user has applied to our future dir.
-	  inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
+	  inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
 	  # Don't allow the user to place us outside of our expected
 	  # location b/c this prevents finding dependent libraries that
 	  # are installed to the same prefix.
 	  # At present, this check doesn't affect windows .dll's that
 	  test "$inst_prefix_dir" = "$destdir" && \
 	    func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
 	  if test -n "$inst_prefix_dir"; then
 	    # Stick the inst_prefix_dir data into the link command.
-	    relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
+	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
 	  else
-	    relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
+	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
 	  fi
 	  func_warning "relinking \`$file'"
 	  func_show_eval "$relink_command" \
 	    'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
 	  srcname="$realname"
 	  test -n "$relink_command" && srcname="$realname"T
 	  # Install the shared library and build the symlinks.
-	  func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
+	  func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
 	      'exit $?'
 	  tstripme="$stripme"
 	  case $host_os in
 	  cygwin* | mingw* | pw32* | cegcc*)
 	    case $realname in
 	    # Check to see that each library is installed.
 	    libdir=
 	    if test -f "$lib"; then
 	      func_source "$lib"
 	    fi
-	    libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
+	    libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
 	    if test -n "$libdir" && test ! -f "$libfile"; then
 	      func_warning "\`$lib' has not been installed in \`$libdir'"
 	      finalize=no
 	    fi
 	  done
 	        tmpdir=`func_mktempdir`
 		func_basename "$file$stripped_ext"
 		file="$func_basename_result"
 	        outputname="$tmpdir/$file"
 	        # Replace the output file specification.
-	        relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
+	        relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
 	        $opt_silent || {
 	          func_quote_for_expand "$relink_command"
 		  eval "func_echo $func_quote_for_expand_result"
 	        }
 	        func_warning "cannot relink \`$file'"
 	      fi
 	    }
 	  else
 	    # Install the binary that we compiled earlier.
-	    file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
+	    file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
 	  fi
 	fi
 	# remove .exe since cygwin /usr/bin/install will append another
 	# one anyway
 done
 test -n "$future_libdirs" && \
 func_warning "remember to run \`$progname --finish$future_libdirs'"
-if test -n "$current_libdirs"; then
+if test -n "$current_libdirs" && $opt_finish; then
 # Maybe just do a dry run.
 $opt_dry_run && current_libdirs=" -n$current_libdirs"
 exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
 else
 exit $EXIT_SUCCESS
 #ifdef __cplusplus
 extern \"C\" {
 #endif
+#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
+#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
+#endif
 /* External symbol declarations for the compiler. */\
 "
 	if test "$dlself" = yes; then
 	  func_verbose "generating symbol list for \`$output'"
 	  $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
 	  # Add our own program objects to the symbol list.
-	  progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+	  progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
 	  for progfile in $progfiles; do
 	    func_verbose "extracting global C symbols from \`$progfile'"
 	    $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
 	  done
 	  if test -n "$exclude_expsyms"; then
 	    $opt_dry_run || {
-	      eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
+	      $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
-	      eval '$MV "$nlist"T "$nlist"'
+	      $MV "$nlist"T "$nlist"
 	    }
 	  fi
 	  if test -n "$export_symbols_regex"; then
 	    $opt_dry_run || {
-	      eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
+	      $EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T
-	      eval '$MV "$nlist"T "$nlist"'
+	      $MV "$nlist"T "$nlist"
 	    }
 	  fi
 	  # Prepare the list of exported symbols
 	  if test -z "$export_symbols"; then
 	    export_symbols="$output_objdir/$outputname.exp"
 	    $opt_dry_run || {
 	      $RM $export_symbols
-	      eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
+	      ${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' < "$nlist" > "$export_symbols"
 	      case $host in
 	      *cygwin* | *mingw* | *cegcc* )
-eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+echo EXPORTS > "$output_objdir/$outputname.def"
-eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
+cat "$export_symbols" >> "$output_objdir/$outputname.def"
 	        ;;
 	      esac
 	    }
 	  else
 	    $opt_dry_run || {
-	      eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
+	      ${SED} -e 's/\([].[*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/' < "$export_symbols" > "$output_objdir/$outputname.exp"
-	      eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
+	      $GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T
-	      eval '$MV "$nlist"T "$nlist"'
+	      $MV "$nlist"T "$nlist"
 	      case $host in
-	        *cygwin | *mingw* | *cegcc* )
+	        *cygwin* | *mingw* | *cegcc* )
-	          eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+	          echo EXPORTS > "$output_objdir/$outputname.def"
-	          eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
+	          cat "$nlist" >> "$output_objdir/$outputname.def"
 	          ;;
 	      esac
 	    }
 	  fi
 	fi
 	for dlprefile in $dlprefiles; do
 	  func_verbose "extracting global C symbols from \`$dlprefile'"
 	  func_basename "$dlprefile"
 	  name="$func_basename_result"
 	  $opt_dry_run || {
-	    eval '$ECHO ": $name " >> "$nlist"'
+	    $ECHO ": $name " >> "$nlist"
 	    eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
 	  }
 	done
 	$opt_dry_run || {
 	  fi
 	  if test -f "$nlist"S; then
 	    eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
 	  else
-	    $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
+	    echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
 	  fi
-	  $ECHO >> "$output_objdir/$my_dlsyms" "\
+	  echo >> "$output_objdir/$my_dlsyms" "\
 /* The mapping between symbol names and symbols.  */
 typedef struct {
 const char *name;
 void *address;
 } lt_dlsymlist;
 "
 	  case $host in
 	  *cygwin* | *mingw* | *cegcc* )
-	    $ECHO >> "$output_objdir/$my_dlsyms" "\
+	    echo >> "$output_objdir/$my_dlsyms" "\
 /* DATA imports from DLLs on WIN32 con't be const, because
 runtime relocations are performed -- see ld's documentation
 on pseudo-relocs.  */"
 	    lt_dlsym_const= ;;
 	  *osf5*)
 	    lt_dlsym_const= ;;
 	  *)
 	    lt_dlsym_const=const ;;
 	  esac
-	  $ECHO >> "$output_objdir/$my_dlsyms" "\
+	  echo >> "$output_objdir/$my_dlsyms" "\
 extern $lt_dlsym_const lt_dlsymlist
 lt_${my_prefix}_LTX_preloaded_symbols[];
 $lt_dlsym_const lt_dlsymlist
 lt_${my_prefix}_LTX_preloaded_symbols[] =
 {\
 	    ;;
 	  *)
 	    eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
 	    ;;
 	  esac
-	  $ECHO >> "$output_objdir/$my_dlsyms" "\
+	  echo >> "$output_objdir/$my_dlsyms" "\
 {0, (void *) 0}
 };
 /* This works around a problem in FreeBSD linker */
 #ifdef FREEBSD_WORKAROUND
 	# Transform the symbol file into the correct name.
 	symfileobj="$output_objdir/${my_outputname}S.$objext"
 	case $host in
 	*cygwin* | *mingw* | *cegcc* )
 	  if test -f "$output_objdir/$my_outputname.def"; then
-	    compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
-	    finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
 	  else
-	    compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
+	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
-	    finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
+	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
 	  fi
 	  ;;
 	*)
-	  compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
+	  compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
-	  finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
+	  finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
 	  ;;
 	esac
 	;;
 *)
 	func_fatal_error "unknown suffix for \`$my_dlsyms'"
 # 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@%%"`
+compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
-finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
+finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
 fi
 }
 # 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.
+# Despite the name, also deal with 64 bit binaries.
 func_win32_libid ()
 {
 $opt_debug
 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 |
+if $OBJDUMP -f "$1" | $SED -e '10q' 2>/dev/null |
-$EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
+$EGREP 'file format (pe-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
-win32_nmres=`eval $NM -f posix -A $1 |
+win32_nmres=`$NM -f posix -A "$1" |
 	$SED -n -e '
 	    1,100{
 		/ I /{
 		    s,.*,import,
 		    p
 func_extract_an_archive ()
 {
 $opt_debug
 f_ex_an_ar_dir="$1"; shift
 f_ex_an_ar_oldlib="$1"
-func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
+if test "$lock_old_archive_extraction" = yes; then
+lockfile=$f_ex_an_ar_oldlib.lock
+until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
+	func_echo "Waiting for $lockfile to be removed"
+	sleep 2
+done
+fi
+func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
+		   'stat=$?; rm -f "$lockfile"; exit $stat'
+if test "$lock_old_archive_extraction" = yes; then
+$opt_dry_run || rm -f "$lockfile"
+fi
 if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
 :
 else
 func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
 fi
 func_extract_archives_result="$my_oldobjs"
 }
-# func_emit_wrapper_part1 [arg=no]
-#
-# Emit the first part of a libtool wrapper script on stdout.
-# For more information, see the description associated with
-# func_emit_wrapper(), below.
-func_emit_wrapper_part1 ()
-{
-	func_emit_wrapper_part1_arg1=no
-	if test -n "$1" ; then
-	  func_emit_wrapper_part1_arg1=$1
-	fi
-	$ECHO "\
-#! $SHELL
-# $output - temporary wrapper script for $objdir/$outputname
-# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
-#
-# 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
-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.
-(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 variables:
-generated_by_libtool_version='$macro_version'
-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
-ECHO=\"$qecho\"
-file=\"\$0\"
-# Make sure echo works.
-if test \"X\$1\" = X--no-reexec; then
-# Discard the --no-reexec flag, and continue.
-shift
-elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
-# Yippee, \$ECHO works!
-:
-else
-# Restart under the correct shell, and then maybe \$ECHO will work.
-exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
-fi
-fi\
-"
-	$ECHO "\
-# Find the directory that this script lives in.
-thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
-test \"x\$thisdir\" = \"x\$file\" && thisdir=.
-# Follow symbolic links until we get to the real thisdir.
-file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
-while test -n \"\$file\"; do
-destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
-# If there was a directory component, then change thisdir.
-if test \"x\$destdir\" != \"x\$file\"; then
-case \"\$destdir\" in
-[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
-*) thisdir=\"\$thisdir/\$destdir\" ;;
-esac
-fi
-file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
-file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
-done
-"
-}
-# end: func_emit_wrapper_part1
-# func_emit_wrapper_part2 [arg=no]
-#
-# Emit the second part of a libtool wrapper script on stdout.
-# For more information, see the description associated with
-# func_emit_wrapper(), below.
-func_emit_wrapper_part2 ()
-{
-	func_emit_wrapper_part2_arg1=no
-	if test -n "$1" ; then
-	  func_emit_wrapper_part2_arg1=$1
-	fi
-	$ECHO "\
-# Usually 'no', except on cygwin/mingw when embedded into
-# the cwrapper.
-WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
-if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
-# special case for '.'
-if test \"\$thisdir\" = \".\"; then
-thisdir=\`pwd\`
-fi
-# remove .libs from thisdir
-case \"\$thisdir\" in
-*[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
-$objdir )   thisdir=. ;;
-esac
-fi
-# Try to get the absolute directory name.
-absdir=\`cd \"\$thisdir\" && pwd\`
-test -n \"\$absdir\" && thisdir=\"\$absdir\"
-"
-	if test "$fast_install" = yes; then
-	  $ECHO "\
-program=lt-'$outputname'$exeext
-progdir=\"\$thisdir/$objdir\"
-if test ! -f \"\$progdir/\$program\" ||
-{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
-test \"X\$file\" != \"X\$progdir/\$program\"; }; then
-file=\"\$\$-\$program\"
-if test ! -d \"\$progdir\"; then
-$MKDIR \"\$progdir\"
-else
-$RM \"\$progdir/\$file\"
-fi"
-	  $ECHO "\
-# relink executable if necessary
-if test -n \"\$relink_command\"; then
-if relink_command_output=\`eval \$relink_command 2>&1\`; then :
-else
-	$ECHO \"\$relink_command_output\" >&2
-	$RM \"\$progdir/\$file\"
-	exit 1
-fi
-fi
-$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
-{ $RM \"\$progdir/\$program\";
-$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
-$RM \"\$progdir/\$file\"
-fi"
-	else
-	  $ECHO "\
-program='$outputname'
-progdir=\"\$thisdir/$objdir\"
-"
-	fi
-	$ECHO "\
-if test -f \"\$progdir/\$program\"; then"
-	# Export our shlibpath_var if we have one.
-	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
-	  $ECHO "\
-# Add our own library path to $shlibpath_var
-$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
-# Some systems cannot cope with colon-terminated $shlibpath_var
-# The second colon is a workaround for a bug in BeOS R4 sed
-$shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
-export $shlibpath_var
-"
-	fi
-	# fixup the dll searchpath if we need to.
-	if test -n "$dllsearchpath"; then
-	  $ECHO "\
-# Add the dll search path components to the executable PATH
-PATH=$dllsearchpath:\$PATH
-"
-	fi
-	$ECHO "\
-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* | *-cegcc*)
-	  $ECHO "\
-exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
-"
-	  ;;
-	*)
-	  $ECHO "\
-exec \"\$progdir/\$program\" \${1+\"\$@\"}
-"
-	  ;;
-	esac
-	$ECHO "\
-\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
-exit 1
-fi
-else
-# The program doesn't exist.
-\$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 1
-fi
-fi\
-"
-}
-# end: func_emit_wrapper_part2
 # func_emit_wrapper [arg=no]
 #
 # Emit a libtool wrapper script on stdout.
 # Don't directly open a file because we may want to
 # incorporate the script contents within a cygwin/mingw
 # will assume that the directory in which it is stored is
 # the $objdir directory.  This is a cygwin/mingw-specific
 # behavior.
 func_emit_wrapper ()
 {
-	func_emit_wrapper_arg1=no
+	func_emit_wrapper_arg1=${1-no}
-	if test -n "$1" ; then
-	  func_emit_wrapper_arg1=$1
+	$ECHO "\
+#! $SHELL
+# $output - temporary wrapper script for $objdir/$outputname
+# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+#
+# 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.
+sed_quote_subst='$sed_quote_subst'
+# Be 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.
+(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 variables:
+generated_by_libtool_version='$macro_version'
+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
+file=\"\$0\""
+qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
+$ECHO "\
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+eval 'cat <<_LTECHO_EOF
+\$1
+_LTECHO_EOF'
+}
+ECHO=\"$qECHO\"
+fi\
+# Find the directory that this script lives in.
+thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
+test \"x\$thisdir\" = \"x\$file\" && thisdir=.
+# Follow symbolic links until we get to the real thisdir.
+file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
+while test -n \"\$file\"; do
+destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
+# If there was a directory component, then change thisdir.
+if test \"x\$destdir\" != \"x\$file\"; then
+case \"\$destdir\" in
+[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
+*) thisdir=\"\$thisdir/\$destdir\" ;;
+esac
+fi
+file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
+file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
+done
+# Usually 'no', except on cygwin/mingw when embedded into
+# the cwrapper.
+WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
+if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
+# special case for '.'
+if test \"\$thisdir\" = \".\"; then
+thisdir=\`pwd\`
+fi
+# remove .libs from thisdir
+case \"\$thisdir\" in
+*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
+$objdir )   thisdir=. ;;
+esac
+fi
+# Try to get the absolute directory name.
+absdir=\`cd \"\$thisdir\" && pwd\`
+test -n \"\$absdir\" && thisdir=\"\$absdir\"
+"
+	if test "$fast_install" = yes; then
+	  $ECHO "\
+program=lt-'$outputname'$exeext
+progdir=\"\$thisdir/$objdir\"
+if test ! -f \"\$progdir/\$program\" ||
+{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
+test \"X\$file\" != \"X\$progdir/\$program\"; }; then
+file=\"\$\$-\$program\"
+if test ! -d \"\$progdir\"; then
+$MKDIR \"\$progdir\"
+else
+$RM \"\$progdir/\$file\"
+fi"
+	  $ECHO "\
+# relink executable if necessary
+if test -n \"\$relink_command\"; then
+if relink_command_output=\`eval \"\$relink_command\" 2>&1\`; then :
+else
+	$ECHO \"\$relink_command_output\" >&2
+	$RM \"\$progdir/\$file\"
+	exit 1
+fi
+fi
+$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
+{ $RM \"\$progdir/\$program\";
+$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
+$RM \"\$progdir/\$file\"
+fi"
+	else
+	  $ECHO "\
+program='$outputname'
+progdir=\"\$thisdir/$objdir\"
+"
 	fi
-	# split this up so that func_emit_cwrapperexe_src
+	$ECHO "\
-	# can call each part independently.
-	func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
+if test -f \"\$progdir/\$program\"; then"
-	func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
+	# Export our shlibpath_var if we have one.
+	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+	  $ECHO "\
+# Add our own library path to $shlibpath_var
+$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
+# Some systems cannot cope with colon-terminated $shlibpath_var
+# The second colon is a workaround for a bug in BeOS R4 sed
+$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
+export $shlibpath_var
+"
+	fi
+	# fixup the dll searchpath if we need to.
+	if test -n "$dllsearchpath"; then
+	  $ECHO "\
+# Add the dll search path components to the executable PATH
+PATH=$dllsearchpath:\$PATH
+"
+	fi
+	$ECHO "\
+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* | *-cegcc*)
+	  $ECHO "\
+exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
+"
+	  ;;
+	*)
+	  $ECHO "\
+exec \"\$progdir/\$program\" \${1+\"\$@\"}
+"
+	  ;;
+	esac
+	$ECHO "\
+\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
+exit 1
+fi
+else
+# The program doesn't exist.
+\$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 1
+fi
+fi\
+"
 }
 # func_to_host_path arg
 #
 # the proper representation for $host. The result is stored
 # in $func_to_host_path_result.
 func_to_host_path ()
 {
 func_to_host_path_result="$1"
-if test -n "$1" ; then
+if test -n "$1"; then
 case $host in
 *mingw* )
 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
 case $build in
 *mingw* ) # actually, msys
 # awkward: cmd appends spaces to result
-lt_sed_strip_trailing_spaces="s/[ ]*\$//"
+func_to_host_path_result=`( cmd //c echo "$1" ) 2>/dev/null |
-func_to_host_path_tmp1=`( cmd //c echo "$1" |\
+$SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
-$SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
-func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
-$SED -e "$lt_sed_naive_backslashify"`
 ;;
 *cygwin* )
-func_to_host_path_tmp1=`cygpath -w "$1"`
+func_to_host_path_result=`cygpath -w "$1" |
-func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
+	      $SED -e "$lt_sed_naive_backslashify"`
-$SED -e "$lt_sed_naive_backslashify"`
 ;;
 * )
 # Unfortunately, winepath does not exit with a non-zero
 # error code, so we are forced to check the contents of
 # stdout. On the other hand, if the command is not
 # *an error message* to stdout. So we must check for both
 # error code of zero AND non-empty stdout, which explains
 # the odd construction:
 func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
 if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
-func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
+func_to_host_path_result=`$ECHO "$func_to_host_path_tmp1" |
 $SED -e "$lt_sed_naive_backslashify"`
 else
 # Allow warning below.
-func_to_host_path_result=""
+func_to_host_path_result=
 fi
 ;;
 esac
 if test -z "$func_to_host_path_result" ; then
 func_error "Could not determine host path corresponding to"
-func_error "  '$1'"
+func_error "  \`$1'"
 func_error "Continuing, but uninstalled executables may not work."
 # Fallback:
 func_to_host_path_result="$1"
 fi
 ;;
 # the proper representation on $host. The result is stored
 # in $func_to_host_pathlist_result.
 func_to_host_pathlist ()
 {
 func_to_host_pathlist_result="$1"
-if test -n "$1" ; then
+if test -n "$1"; then
 case $host in
 *mingw* )
 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
 # Remove leading and trailing path separator characters from
 # ARG. msys behavior is inconsistent here, cygpath turns them
 # into '.;' and ';.', and winepath ignores them completely.
-func_to_host_pathlist_tmp2="$1"
+	func_stripname : : "$1"
-# Once set for this call, this variable should not be
+func_to_host_pathlist_tmp1=$func_stripname_result
-# reassigned. It is used in tha fallback case.
-func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
-$SED -e 's|^:*||' -e 's|:*$||'`
 case $build in
 *mingw* ) # Actually, msys.
 # Awkward: cmd appends spaces to result.
-lt_sed_strip_trailing_spaces="s/[ ]*\$//"
+func_to_host_pathlist_result=`
-func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
+	      ( cmd //c echo "$func_to_host_pathlist_tmp1" ) 2>/dev/null |
-$SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
+	      $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
-func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
-$SED -e "$lt_sed_naive_backslashify"`
 ;;
 *cygwin* )
-func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
+func_to_host_pathlist_result=`cygpath -w -p "$func_to_host_pathlist_tmp1" |
-func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
 $SED -e "$lt_sed_naive_backslashify"`
 ;;
 * )
 # unfortunately, winepath doesn't convert pathlists
 func_to_host_pathlist_result=""
 func_to_host_path "$func_to_host_pathlist_f"
 if test -n "$func_to_host_path_result" ; then
 if test -z "$func_to_host_pathlist_result" ; then
 func_to_host_pathlist_result="$func_to_host_path_result"
 else
-func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
+func_append func_to_host_pathlist_result ";$func_to_host_path_result"
 fi
 fi
 fi
-IFS=:
 done
 IFS=$func_to_host_pathlist_oldIFS
 ;;
 esac
-if test -z "$func_to_host_pathlist_result" ; then
+if test -z "$func_to_host_pathlist_result"; then
 func_error "Could not determine the host path(s) corresponding to"
-func_error "  '$1'"
+func_error "  \`$1'"
 func_error "Continuing, but uninstalled executables may not work."
 # Fallback. This may break if $1 contains DOS-style drive
 # specifications. The fix is not to complicate the expression
 # below, but for the user to provide a working wine installation
 # with winepath so that path translation in the cross-to-mingw
 case "$1" in
 :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
 ;;
 esac
 case "$1" in
-*: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
+*: ) func_append func_to_host_pathlist_result ";"
 ;;
 esac
 ;;
 esac
 fi
 but could eventually absorb all of the scripts functionality and
 exec $objdir/$outputname directly.
 */
 EOF
 	    cat <<"EOF"
+#ifdef _MSC_VER
+# define _CRT_SECURE_NO_DEPRECATE 1
+#endif
 #include <stdio.h>
 #include <stdlib.h>
 #ifdef _MSC_VER
 # include <direct.h>
 # include <process.h>
 # include <io.h>
-# define setmode _setmode
 #else
 # include <unistd.h>
 # include <stdint.h>
 # ifdef __CYGWIN__
 #  include <io.h>
-#  define HAVE_SETENV
-#  ifdef __STRICT_ANSI__
-char *realpath (const char *, char *);
-int putenv (char *);
-int setenv (const char *, const char *, int);
-#  endif
 # endif
 #endif
 #include <malloc.h>
 #include <stdarg.h>
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
+/* declarations of non-ANSI functions */
+#if defined(__MINGW32__)
+# ifdef __STRICT_ANSI__
+int _putenv (const char *);
+# endif
+#elif defined(__CYGWIN__)
+# ifdef __STRICT_ANSI__
+char *realpath (const char *, char *);
+int putenv (char *);
+int setenv (const char *, const char *, int);
+# endif
+/* #elif defined (other platforms) ... */
+#endif
+/* portability defines, excluding path handling macros */
+#if defined(_MSC_VER)
+# define setmode _setmode
+# define stat    _stat
+# define chmod   _chmod
+# define getcwd  _getcwd
+# define putenv  _putenv
+# define S_IXUSR _S_IEXEC
+# ifndef _INTPTR_T_DEFINED
+#  define _INTPTR_T_DEFINED
+#  define intptr_t int
+# endif
+#elif defined(__MINGW32__)
+# define setmode _setmode
+# define stat    _stat
+# define chmod   _chmod
+# define getcwd  _getcwd
+# define putenv  _putenv
+#elif defined(__CYGWIN__)
+# define HAVE_SETENV
+# define FOPEN_WB "wb"
+/* #elif defined (other platforms) ... */
+#endif
 #if defined(PATH_MAX)
 # define LT_PATHMAX PATH_MAX
 #elif defined(MAXPATHLEN)
 # define LT_PATHMAX MAXPATHLEN
 #else
 #endif
 #ifndef S_IXGRP
 # define S_IXGRP 0
 #endif
-#ifdef _MSC_VER
+/* path handling portability macros */
-# define S_IXUSR _S_IEXEC
-# define stat _stat
-# ifndef _INTPTR_T_DEFINED
-#  define intptr_t int
-# endif
-#endif
 #ifndef DIR_SEPARATOR
 # define DIR_SEPARATOR '/'
 # define PATH_SEPARATOR ':'
 #endif
 # 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 */
-#ifdef __CYGWIN__
-# define FOPEN_WB "wb"
-#endif
 #ifndef FOPEN_WB
 # define FOPEN_WB "w"
 #endif
 #ifndef _O_BINARY
 # define _O_BINARY 0
 #define XFREE(stale) do { \
 if (stale) { free ((void *) stale); stale = 0; } \
 } while (0)
 #undef LTWRAPPER_DEBUGPRINTF
-#if defined DEBUGWRAPPER
+#if defined LT_DEBUGWRAPPER
 # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
 static void
 ltwrapper_debugprintf (const char *fmt, ...)
 {
 va_list args;
 int check_executable (const char *path);
 char *strendzap (char *str, const char *pat);
 void lt_fatal (const char *message, ...);
 void lt_setenv (const char *name, const char *value);
 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
-void lt_opt_process_env_set (const char *arg);
-void lt_opt_process_env_prepend (const char *arg);
-void lt_opt_process_env_append (const char *arg);
-int lt_split_name_value (const char *arg, char** name, char** value);
 void lt_update_exe_path (const char *name, const char *value);
 void lt_update_lib_path (const char *name, const char *value);
+char **prepare_spawn (char **argv);
-static const char *script_text_part1 =
+void lt_dump_script (FILE *f);
 EOF
-	    func_emit_wrapper_part1 yes |
-	        $SED -e 's/\([\\"]\)/\\\1/g' \
-	             -e 's/^/  "/' -e 's/$/\\n"/'
-	    echo ";"
-	    cat <<EOF
-static const char *script_text_part2 =
-EOF
-	    func_emit_wrapper_part2 yes |
-	        $SED -e 's/\([\\"]\)/\\\1/g' \
-	             -e 's/^/  "/' -e 's/$/\\n"/'
-	    echo ";"
 	    cat <<EOF
 const char * MAGIC_EXE = "$magic_exe";
 const char * LIB_PATH_VARNAME = "$shlibpath_var";
 EOF
 static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
 static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
-static const size_t env_set_opt_len     = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
-static const char *env_set_opt          = LTWRAPPER_OPTION_PREFIX "env-set";
-/* argument is putenv-style "foo=bar", value of foo is set to bar */
-static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
-static const char *env_prepend_opt      = LTWRAPPER_OPTION_PREFIX "env-prepend";
-/* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
-static const size_t env_append_opt_len  = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
-static const char *env_append_opt       = LTWRAPPER_OPTION_PREFIX "env-append";
-/* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
 int
 main (int argc, char *argv[])
 {
 char **newargz;
 int  newargc;
 		echo "          setmode(1,_O_BINARY);"
 		;;
 	      esac
 	    cat <<"EOF"
-	  printf ("%s", script_text_part1);
+	  lt_dump_script (stdout);
-	  printf ("%s", script_text_part2);
 	  return 0;
 	}
 }
 newargz = XMALLOC (char *, argc + 1);
 lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
 newargc=0;
 for (i = 1; i < argc; i++)
 {
-if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
-{
-if (argv[i][env_set_opt_len] == '=')
-{
-const char *p = argv[i] + env_set_opt_len + 1;
-lt_opt_process_env_set (p);
-}
-else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
-{
-lt_opt_process_env_set (argv[++i]); /* don't copy */
-}
-else
-lt_fatal ("%s missing required argument", env_set_opt);
-continue;
-}
-if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
-{
-if (argv[i][env_prepend_opt_len] == '=')
-{
-const char *p = argv[i] + env_prepend_opt_len + 1;
-lt_opt_process_env_prepend (p);
-}
-else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
-{
-lt_opt_process_env_prepend (argv[++i]); /* don't copy */
-}
-else
-lt_fatal ("%s missing required argument", env_prepend_opt);
-continue;
-}
-if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
-{
-if (argv[i][env_append_opt_len] == '=')
-{
-const char *p = argv[i] + env_append_opt_len + 1;
-lt_opt_process_env_append (p);
-}
-else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
-{
-lt_opt_process_env_append (argv[++i]); /* don't copy */
-}
-else
-lt_fatal ("%s missing required argument", env_append_opt);
-continue;
-}
 if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
 {
 /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
 namespace, but it is not one of the ones we know about and
 have already dealt with, above (inluding dump-script), then
 	    case $host_os in
 	      mingw*)
 		cat <<"EOF"
 /* execv doesn't actually work on mingw as expected on unix */
+newargz = prepare_spawn (newargz);
 rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
 if (rval == -1)
 {
 /* failed to start process */
 LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
 new_value = xstrdup (add);
 }
 return new_value;
 }
-int
-lt_split_name_value (const char *arg, char** name, char** value)
-{
-const char *p;
-int len;
-if (!arg || !*arg)
-return 1;
-p = strchr (arg, (int)'=');
-if (!p)
-return 1;
-*value = xstrdup (++p);
-len = strlen (arg) - strlen (*value);
-*name = XMALLOC (char, len);
-strncpy (*name, arg, len-1);
-(*name)[len - 1] = '\0';
-return 0;
-}
-void
-lt_opt_process_env_set (const char *arg)
-{
-char *name = NULL;
-char *value = NULL;
-if (lt_split_name_value (arg, &name, &value) != 0)
-{
-XFREE (name);
-XFREE (value);
-lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
-}
-lt_setenv (name, value);
-XFREE (name);
-XFREE (value);
-}
-void
-lt_opt_process_env_prepend (const char *arg)
-{
-char *name = NULL;
-char *value = NULL;
-char *new_value = NULL;
-if (lt_split_name_value (arg, &name, &value) != 0)
-{
-XFREE (name);
-XFREE (value);
-lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
-}
-new_value = lt_extend_str (getenv (name), value, 0);
-lt_setenv (name, new_value);
-XFREE (new_value);
-XFREE (name);
-XFREE (value);
-}
-void
-lt_opt_process_env_append (const char *arg)
-{
-char *name = NULL;
-char *value = NULL;
-char *new_value = NULL;
-if (lt_split_name_value (arg, &name, &value) != 0)
-{
-XFREE (name);
-XFREE (value);
-lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
-}
-new_value = lt_extend_str (getenv (name), value, 1);
-lt_setenv (name, new_value);
-XFREE (new_value);
-XFREE (name);
-XFREE (value);
-}
 void
 lt_update_exe_path (const char *name, const char *value)
 {
 LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
 (name ? name : "<NULL>"),
 lt_setenv (name, new_value);
 XFREE (new_value);
 }
 }
+EOF
+	    case $host_os in
+	      mingw*)
+		cat <<"EOF"
+/* Prepares an argument vector before calling spawn().
+Note that spawn() does not by itself call the command interpreter
+(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
+({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+GetVersionEx(&v);
+v.dwPlatformId == VER_PLATFORM_WIN32_NT;
+}) ? "cmd.exe" : "command.com").
+Instead it simply concatenates the arguments, separated by ' ', and calls
+CreateProcess().  We must quote the arguments since Win32 CreateProcess()
+interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
+special way:
+- Space and tab are interpreted as delimiters. They are not treated as
+delimiters if they are surrounded by double quotes: "...".
+- Unescaped double quotes are removed from the input. Their only effect is
+that within double quotes, space and tab are treated like normal
+characters.
+- Backslashes not followed by double quotes are not special.
+- But 2*n+1 backslashes followed by a double quote become
+n backslashes followed by a double quote (n >= 0):
+\" -> "
+\\\" -> \"
+\\\\\" -> \\"
+*/
+#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+char **
+prepare_spawn (char **argv)
+{
+size_t argc;
+char **new_argv;
+size_t i;
+/* Count number of arguments.  */
+for (argc = 0; argv[argc] != NULL; argc++)
+;
+/* Allocate new argument vector.  */
+new_argv = XMALLOC (char *, argc + 1);
+/* Put quoted arguments into the new argument vector.  */
+for (i = 0; i < argc; i++)
+{
+const char *string = argv[i];
+if (string[0] == '\0')
+	new_argv[i] = xstrdup ("\"\"");
+else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
+	{
+	  int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
+	  size_t length;
+	  unsigned int backslashes;
+	  const char *s;
+	  char *quoted_string;
+	  char *p;
+	  length = 0;
+	  backslashes = 0;
+	  if (quote_around)
+	    length++;
+	  for (s = string; *s != '\0'; s++)
+	    {
+	      char c = *s;
+	      if (c == '"')
+		length += backslashes + 1;
+	      length++;
+	      if (c == '\\')
+		backslashes++;
+	      else
+		backslashes = 0;
+	    }
+	  if (quote_around)
+	    length += backslashes + 1;
+	  quoted_string = XMALLOC (char, length + 1);
+	  p = quoted_string;
+	  backslashes = 0;
+	  if (quote_around)
+	    *p++ = '"';
+	  for (s = string; *s != '\0'; s++)
+	    {
+	      char c = *s;
+	      if (c == '"')
+		{
+		  unsigned int j;
+		  for (j = backslashes + 1; j > 0; j--)
+		    *p++ = '\\';
+		}
+	      *p++ = c;
+	      if (c == '\\')
+		backslashes++;
+	      else
+		backslashes = 0;
+	    }
+	  if (quote_around)
+	    {
+	      unsigned int j;
+	      for (j = backslashes; j > 0; j--)
+		*p++ = '\\';
+	      *p++ = '"';
+	    }
+	  *p = '\0';
+	  new_argv[i] = quoted_string;
+	}
+else
+	new_argv[i] = (char *) string;
+}
+new_argv[argc] = NULL;
+return new_argv;
+}
+EOF
+		;;
+	    esac
+cat <<"EOF"
+void lt_dump_script (FILE* f)
+{
+EOF
+	    func_emit_wrapper yes |
+$SED -e 's/\([\\"]\)/\\\1/g' \
+	           -e 's/^/  fputs ("/' -e 's/$/\\n", f);/'
+cat <<"EOF"
+}
 EOF
 }
 # end: func_emit_cwrapperexe_src
+# func_win32_import_lib_p ARG
+# True if ARG is an import lib, as indicated by $file_magic_cmd
+func_win32_import_lib_p ()
+{
+$opt_debug
+case `eval "$file_magic_cmd \"\$1\" 2>/dev/null" | $SED -e 10q` in
+*import*) : ;;
+*) false ;;
+esac
+}
 # func_mode_link arg...
 func_mode_link ()
 {
 $opt_debug
 lib_search_path=`pwd`
 inst_prefix_dir=
 new_inherited_linker_flags=
 avoid_version=no
+bindir=
 dlfiles=
 dlprefiles=
 dlself=no
 export_dynamic=no
 export_symbols=
 	  func_append finalize_command " @OUTPUT@"
 	  ;;
 	esac
 	case $prev in
+	bindir)
+	  bindir="$arg"
+	  prev=
+	  continue
+	  ;;
 	dlfiles|dlprefiles)
 	  if test "$preload" = no; then
 	    # Add the symbol object into the linking commands.
 	    func_append compile_command " @SYMFILE@"
 	    func_append finalize_command " @SYMFILE@"
 -avoid-version)
 	avoid_version=yes
 	continue
 	;;
+-bindir)
+	prev=bindir
+	continue
+	;;
 -dlopen)
 	prev=dlfiles
 	continue
 	;;
 	  lib_search_path="$lib_search_path $dir"
 	  ;;
 	esac
 	case $host in
 	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
-	  testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
+	  testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
 	  case :$dllsearchpath: in
 	  *":$dir:"*) ;;
 	  ::) dllsearchpath=$dir;;
 	  *) dllsearchpath="$dllsearchpath:$dir";;
 	  esac
 	;;
 -l*)
 	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
 	  case $host in
-	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
 	    # These systems don't actually have a C or math library (as such)
 	    continue
 	    ;;
 	  *-*-os2*)
 	    # These systems don't actually have a C library (as such)
 	    ;;
 	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
 	    # Compiler inserts libc in the correct place for threads to work
 	    test "X$arg" = "X-lc" && continue
 	    ;;
+	  *-*-linux*)
+	    test "X$arg" = "X-lc" && continue
+	    ;;
 	  esac
 	elif test "X$arg" = "X-lc_r"; then
 	 case $host in
 	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
 	   # Do not include libc_r directly, use -pthread flag.
 	arg=
 	save_ifs="$IFS"; IFS=','
 	for flag in $args; do
 	  IFS="$save_ifs"
 func_quote_for_eval "$flag"
-	  arg="$arg $wl$func_quote_for_eval_result"
+	  arg="$arg $func_quote_for_eval_result"
 	  compiler_flags="$compiler_flags $func_quote_for_eval_result"
 	done
 	IFS="$save_ifs"
 	func_stripname ' ' '' "$arg"
 	arg=$func_stripname_result
 # -m*, -t[45]*, -txscale* pass through architecture-specific
 # compiler args for GCC
 # -F/path gives path to uninstalled frameworks, gcc on darwin
 # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
 # @file GCC response files
+# -tp=* Portland pgcc target processor selection
 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
--t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
+-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*)
 func_quote_for_eval "$arg"
 	arg="$func_quote_for_eval_result"
 func_append compile_command " $arg"
 func_append finalize_command " $arg"
 compiler_flags="$compiler_flags $arg"
 test -n "$prev" && \
 func_fatal_help "the \`$prevarg' option requires an argument"
 if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
-eval arg=\"$export_dynamic_flag_spec\"
+eval "arg=\"$export_dynamic_flag_spec\""
 func_append compile_command " $arg"
 func_append finalize_command " $arg"
 fi
 oldlibs=
 outputname="$func_basename_result"
 libobjs_save="$libobjs"
 if test -n "$shlibpath_var"; then
 # get the directories listed in $shlibpath_var
-eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
+eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
 else
 shlib_search_path=
 fi
-eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
+eval "sys_lib_search_path=\"$sys_lib_search_path_spec\""
-eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
+eval "sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\""
 func_dirname "$output" "/" ""
 output_objdir="$func_dirname_result$objdir"
 # Create the object directory.
 func_mkdir_p "$output_objdir"
 	  esac
 	  # Collect preopened libtool deplibs, except any this library
 	  # has declared as weak libs
 	  for deplib in $dependency_libs; do
-deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
+	    func_basename "$deplib"
+deplib_base=$func_basename_result
 	    case " $weak_libs " in
 	    *" $deplib_base "*) ;;
 	    *) deplibs="$deplibs $deplib" ;;
 	    esac
 	  done
 	      valid_a_lib=no
 	      case $deplibs_check_method in
 		match_pattern*)
 		  set dummy $deplibs_check_method; shift
 		  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
-		  if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
+		  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
 		$ECHO "*** Warning: Trying to link with static lib archive $deplib."
-		$ECHO "*** I have the capability to make that library automatically link in when"
+		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 "*** 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 "*** 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 "*** because the file extensions .$libext of this argument makes me believe"
-		$ECHO "*** that it is just a static archive that I should not use here."
+		echo "*** that it is just a static archive that I should not use here."
 	      else
-		$ECHO
+		echo
 		$ECHO "*** Warning: Linking the shared library $output against the"
 		$ECHO "*** static library $deplib is not portable!"
 		deplibs="$deplib $deplibs"
 	      fi
 	      ;;
 	# Read the .la file
 	func_source "$lib"
 	# Convert "-framework foo" to "foo.ltframework"
 	if test -n "$inherited_linker_flags"; then
-	  tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
+	  tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
 	  for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
 	    case " $new_inherited_linker_flags " in
 	      *" $tmp_inherited_linker_flag "*) ;;
 	      *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
 	    esac
 	  done
 	fi
-	dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
+	dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 	if test "$linkmode,$pass" = "lib,link" ||
 	   test "$linkmode,$pass" = "prog,scan" ||
 	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then
 	  test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
 	  test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
 	      dlopenmodule="$dlpremoduletest"
 	      break
 	    fi
 	  done
 	  if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
-	    $ECHO
+	    echo
 	    if test "$linkmode" = prog; then
 	      $ECHO "*** Warning: Linking the executable $output against the loadable module"
 	    else
 	      $ECHO "*** Warning: Linking the shared library $output against the loadable module"
 	    fi
 	    # figure out the soname
 	    set dummy $library_names
 	    shift
 	    realname="$1"
 	    shift
-	    libname=`eval "\\$ECHO \"$libname_spec\""`
+	    eval "libname=\"$libname_spec\""
 	    # use dlname if we got it. it's perfectly good, no?
 	    if test -n "$dlname"; then
 	      soname="$dlname"
 	    elif test -n "$soname_spec"; then
 	      # bleh windows
 	        func_arith $current - $age
 		major=$func_arith_result
 		versuffix="-$major"
 		;;
 	      esac
-	      eval soname=\"$soname_spec\"
+	      eval "soname=\"$soname_spec\""
 	    else
 	      soname="$realname"
 	    fi
 	    # Make a new name for the extract_expsyms_cmds to use
 		    if /usr/bin/file -L $add 2> /dev/null |
 			 $GREP ": [^:]* bundle" >/dev/null ; then
 		      if test "X$dlopenmodule" != "X$lib"; then
 			$ECHO "*** Warning: lib $linklib is a module, not a shared library"
 			if test -z "$old_library" ; then
-			  $ECHO
+			  echo
-			  $ECHO "*** And there doesn't seem to be a static archive available"
+			  echo "*** And there doesn't seem to be a static archive available"
-			  $ECHO "*** The link will probably fail, sorry"
+			  echo "*** The link will probably fail, sorry"
 			else
 			  add="$dir/$old_library"
 			fi
 		      elif test -n "$old_library"; then
 			add="$dir/$old_library"
 	    # We're trying link a shared library against a static one
 	    # but the system doesn't support it.
 	    # Just print a warning and add the library to dependency_libs so
 	    # that the program can be linked against the static library.
-	    $ECHO
+	    echo
 	    $ECHO "*** Warning: This system can not link to static lib archive $lib."
-	    $ECHO "*** I have the capability to make that library automatically link in when"
+	    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 "*** 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 "*** shared version of the library, which you do not appear to have."
 	    if test "$module" = yes; then
-	      $ECHO "*** But as you try to build a module library, libtool will still create "
+	      echo "*** But as you try to build a module library, libtool will still create "
-	      $ECHO "*** a static module, that should work as long as the dlopening application"
+	      echo "*** a static module, that should work as long as the dlopening application"
-	      $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
+	      echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
 	      if test -z "$global_symbol_pipe"; then
-		$ECHO
+		echo
-		$ECHO "*** However, this would only work if libtool was able to extract symbol"
+		echo "*** However, this would only work if libtool was able to extract symbol"
-		$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
+		echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
-		$ECHO "*** not find such a program.  So, this module is probably useless."
+		echo "*** not find such a program.  So, this module is probably useless."
-		$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
+		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
 	  done
 	  if test "$link_all_deplibs" != no; then
 	    # Add the search paths of all dependency libraries
 	    for deplib in $dependency_libs; do
+	      path=
 	      case $deplib in
 	      -L*) path="$deplib" ;;
 	      *.la)
 	        func_dirname "$deplib" "" "."
 		dir="$func_dirname_result"
 		esac
 		if $GREP "^installed=no" $deplib > /dev/null; then
 		case $host in
 		*-*-darwin*)
 		  depdepl=
-		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
+		  deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
 		  if test -n "$deplibrary_names" ; then
 		    for tmp in $deplibrary_names ; do
 		      depdepl=$tmp
 		    done
 		    if test -f "$absdir/$objdir/$depdepl" ; then
 		*)
 		  path="-L$absdir/$objdir"
 		  ;;
 		esac
 		else
-		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+		  libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
 		  test -z "$libdir" && \
 		    func_fatal_error "\`$deplib' is not a valid libtool archive"
 		  test "$absdir" != "$libdir" && \
 		    func_warning "\`$deplib' seems to be moved"
 if test "$pass" = link; then
 	if test "$linkmode" = "prog"; then
 	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
 	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
 	else
-	  compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
+	  compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 	fi
 fi
 dependency_libs="$newdependency_libs"
 if test "$pass" = dlpreopen; then
 	# Link the dlpreopened libraries before other libraries
 	else
 	  vars="compile_deplibs finalize_deplibs"
 	fi
 	for var in $vars dependency_libs; do
 	  # Add libraries to $var in reverse order
-	  eval tmp_libs=\"\$$var\"
+	  eval tmp_libs=\$$var
 	  new_libs=
 	  for deplib in $tmp_libs; do
 	    # FIXME: Pedantically, this is the right thing to do, so
 	    #        that some nasty dependency loop isn't accidentally
 	    #        broken:
 	      esac
 	      ;;
 	    *) tmp_libs="$tmp_libs $deplib" ;;
 	    esac
 	  done
-	  eval $var=\"$tmp_libs\"
+	  eval $var=\$tmp_libs
 	done # for var
 fi
 # Last step: remove runtime libs from dependency_libs
 # (they stay in deplibs)
 tmp_libs=
 # Make sure we only generate libraries of the form `libNAME.la'.
 case $outputname in
 lib*)
 	func_stripname 'lib' '.la' "$outputname"
 	name=$func_stripname_result
-	eval shared_ext=\"$shrext_cmds\"
+	eval "shared_ext=\"$shrext_cmds\""
-	eval libname=\"$libname_spec\"
+	eval "libname=\"$libname_spec\""
 	;;
 *)
 	test "$module" = no && \
 	  func_fatal_help "libtool library \`$output' must begin with \`lib'"
 	if test "$need_lib_prefix" != no; then
 	  # Add the "lib" prefix for modules if required
 	  func_stripname '' '.la' "$outputname"
 	  name=$func_stripname_result
-	  eval shared_ext=\"$shrext_cmds\"
+	  eval "shared_ext=\"$shrext_cmds\""
-	  eval libname=\"$libname_spec\"
+	  eval "libname=\"$libname_spec\""
 	else
 	  func_stripname '' '.la' "$outputname"
 	  libname=$func_stripname_result
 	fi
 	;;
 if test -n "$objs"; then
 	if test "$deplibs_check_method" != pass_all; then
 	  func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
 	else
-	  $ECHO
+	  echo
 	  $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
 	  $ECHO "*** objects $objs is not portable!"
 	  libobjs="$libobjs $objs"
 	fi
 fi
 	    func_arith $number_major + $number_minor
 	    current=$func_arith_result
 	    age="$number_minor"
 	    revision="$number_revision"
 	    ;;
-	  freebsd-aout|freebsd-elf|sunos)
+	  freebsd-aout|freebsd-elf|qnx|sunos)
 	    current="$number_major"
 	    revision="$number_minor"
 	    age="0"
 	    ;;
 	  irix|nonstopux)
 # 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`
+	oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
 fi
 # Eliminate all temporary directories.
 #for path in $notinst_path; do
-#	lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
+#	lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
-#	deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
+#	deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
-#	dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
+#	dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
 #done
 if test -n "$xrpath"; then
 	# If the user specified any rpath flags, then add them.
 	temp_xrpath=
 done
 if test "$build_libtool_libs" = yes; then
 	if test -n "$rpath"; then
 	  case $host in
-	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
 	    # these systems don't actually have a c library (as such)!
 	    ;;
 	  *-*-rhapsody* | *-*-darwin1.[012])
 	    # Rhapsody C library is in the System framework
 	    deplibs="$deplibs System.ltframework"
 		    i=""
 		    ;;
 		  esac
 		fi
 		if test -n "$i" ; then
-		  libname=`eval "\\$ECHO \"$libname_spec\""`
+		  eval "libname=\"$libname_spec\""
-		  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
+		  eval "deplib_matches=\"$library_names_spec\""
 		  set dummy $deplib_matches; shift
 		  deplib_match=$1
 		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
 		    newdeplibs="$newdeplibs $i"
 		  else
 		    droppeddeps=yes
-		    $ECHO
+		    echo
 		    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
-		    $ECHO "*** I have the capability to make that library automatically link in when"
+		    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 "*** you link to this library.  But I can only do this if you have a"
-		    $ECHO "*** shared version of the library, which I believe you do not have"
+		    echo "*** shared version of the library, which I believe you do not have"
-		    $ECHO "*** because a test_compile did reveal that the linker did not use it for"
+		    echo "*** because a test_compile did reveal that the linker did not use it for"
-		    $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
+		    echo "*** its dynamic dependency list that programs get resolved with at runtime."
 		  fi
 		fi
 		;;
 	      *)
 		newdeplibs="$newdeplibs $i"
 		      i=""
 		      ;;
 		    esac
 		  fi
 		  if test -n "$i" ; then
-		    libname=`eval "\\$ECHO \"$libname_spec\""`
+		    eval "libname=\"$libname_spec\""
-		    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
+		    eval "deplib_matches=\"$library_names_spec\""
 		    set dummy $deplib_matches; shift
 		    deplib_match=$1
 		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
 		      newdeplibs="$newdeplibs $i"
 		    else
 		      droppeddeps=yes
-		      $ECHO
+		      echo
 		      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
-		      $ECHO "*** I have the capability to make that library automatically link in when"
+		      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 "*** 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 "*** 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 "*** 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."
+		      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
 		    fi
 		  fi
 		else
 		  droppeddeps=yes
-		  $ECHO
+		  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 "*** library that it depends on before this library will be fully"
-		  $ECHO "*** functional.  Installing it before continuing would be even better."
+		  echo "*** functional.  Installing it before continuing would be even better."
 		fi
 		;;
 	      *)
 		newdeplibs="$newdeplibs $i"
 		;;
 		  a_deplib=""
 		  ;;
 		esac
 	      fi
 	      if test -n "$a_deplib" ; then
-		libname=`eval "\\$ECHO \"$libname_spec\""`
+		eval "libname=\"$libname_spec\""
 		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
 		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
 		  for potent_lib in $potential_libs; do
 		      # Follow soft links.
 		      if ls -lLd "$potent_lib" 2>/dev/null |
 		      potlib="$potent_lib"
 		      while test -h "$potlib" 2>/dev/null; do
 			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
 			case $potliblink in
 			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
-			*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
+			*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
 			esac
 		      done
-		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
+		      if eval "$file_magic_cmd \"\$potlib\"" 2>/dev/null |
 			 $SED -e 10q |
 			 $EGREP "$file_magic_regex" > /dev/null; then
 			newdeplibs="$newdeplibs $a_deplib"
 			a_deplib=""
 			break 2
 		  done
 		done
 	      fi
 	      if test -n "$a_deplib" ; then
 		droppeddeps=yes
-		$ECHO
+		echo
 		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
-		$ECHO "*** I have the capability to make that library automatically link in when"
+		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 "*** 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 "*** shared version of the library, which you do not appear to have"
-		$ECHO "*** because I did check the linker path looking for a file starting"
+		echo "*** because I did check the linker path looking for a file starting"
 		if test -z "$potlib" ; then
 		  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
 		else
 		  $ECHO "*** with $libname and none of the candidates passed a file format test"
 		  $ECHO "*** using a file magic. Last file checked: $potlib"
 		  a_deplib=""
 		  ;;
 		esac
 	      fi
 	      if test -n "$a_deplib" ; then
-		libname=`eval "\\$ECHO \"$libname_spec\""`
+		eval "libname=\"$libname_spec\""
 		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
 		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
 		  for potent_lib in $potential_libs; do
 		    potlib="$potent_lib" # see symlink-check above in file_magic test
-		    if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
+		    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
 		       $EGREP "$match_pattern_regex" > /dev/null; then
 		      newdeplibs="$newdeplibs $a_deplib"
 		      a_deplib=""
 		      break 2
 		    fi
 		  done
 		done
 	      fi
 	      if test -n "$a_deplib" ; then
 		droppeddeps=yes
-		$ECHO
+		echo
 		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
-		$ECHO "*** I have the capability to make that library automatically link in when"
+		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 "*** 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 "*** shared version of the library, which you do not appear to have"
-		$ECHO "*** because I did check the linker path looking for a file starting"
+		echo "*** because I did check the linker path looking for a file starting"
 		if test -z "$potlib" ; then
 		  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
 		else
 		  $ECHO "*** with $libname and none of the candidates passed a file format test"
 		  $ECHO "*** using a regex pattern. Last file checked: $potlib"
 	    esac
 	  done # Gone through all deplibs.
 	  ;;
 	none | unknown | *)
 	  newdeplibs=""
-	  tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
+	  tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
-	      -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
 	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 	    for i in $predeps $postdeps ; do
 	      # can't use Xsed below, because $i might contain '/'
-	      tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
+	      tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
 	    done
 	  fi
-	  if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[	 ]//g' |
+	  case $tmp_deplibs in
-	     $GREP . >/dev/null; then
+	  *[!\	\ ]*)
-	    $ECHO
+	    echo
 	    if test "X$deplibs_check_method" = "Xnone"; then
-	      $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
+	      echo "*** Warning: inter-library dependencies are not supported in this platform."
 	    else
-	      $ECHO "*** Warning: inter-library dependencies are not known to be supported."
+	      echo "*** Warning: inter-library dependencies are not known to be supported."
 	    fi
-	    $ECHO "*** All declared inter-library dependencies are being dropped."
+	    echo "*** All declared inter-library dependencies are being dropped."
 	    droppeddeps=yes
-	  fi
+	    ;;
+	  esac
 	  ;;
 	esac
 	versuffix=$versuffix_save
 	major=$major_save
 	release=$release_save
 	name=$name_save
 	case $host in
 	*-*-rhapsody* | *-*-darwin1.[012])
 	  # On Rhapsody replace the C library with the System framework
-	  newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
+	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
 	  ;;
 	esac
 	if test "$droppeddeps" = yes; then
 	  if test "$module" = yes; then
-	    $ECHO
+	    echo
-	    $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
+	    echo "*** Warning: libtool could not satisfy all declared inter-library"
 	    $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
-	    $ECHO "*** a static module, that should work as long as the dlopening"
+	    echo "*** a static module, that should work as long as the dlopening"
-	    $ECHO "*** application is linked with the -dlopen flag."
+	    echo "*** application is linked with the -dlopen flag."
 	    if test -z "$global_symbol_pipe"; then
-	      $ECHO
+	      echo
-	      $ECHO "*** However, this would only work if libtool was able to extract symbol"
+	      echo "*** However, this would only work if libtool was able to extract symbol"
-	      $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
+	      echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
-	      $ECHO "*** not find such a program.  So, this module is probably useless."
+	      echo "*** not find such a program.  So, this module is probably useless."
-	      $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
+	      echo "*** \`nm' from GNU binutils and a full rebuild may help."
 	    fi
 	    if test "$build_old_libs" = no; then
 	      oldlibs="$output_objdir/$libname.$libext"
 	      build_libtool_libs=module
 	      build_old_libs=yes
 	    else
 	      build_libtool_libs=no
 	    fi
 	  else
-	    $ECHO "*** The inter-library dependencies that have been dropped here will be"
+	    echo "*** The inter-library dependencies that have been dropped here will be"
-	    $ECHO "*** automatically added whenever a program is linked with this library"
+	    echo "*** automatically added whenever a program is linked with this library"
-	    $ECHO "*** or is declared to -dlopen it."
+	    echo "*** or is declared to -dlopen it."
 	    if test "$allow_undefined" = no; then
-	      $ECHO
+	      echo
-	      $ECHO "*** Since this library must not contain undefined symbols,"
+	      echo "*** Since this library must not contain undefined symbols,"
-	      $ECHO "*** because either the platform does not support them or"
+	      echo "*** because either the platform does not support them or"
-	      $ECHO "*** it was explicitly requested with -no-undefined,"
+	      echo "*** it was explicitly requested with -no-undefined,"
-	      $ECHO "*** libtool will only create a static version of it."
+	      echo "*** libtool will only create a static version of it."
 	      if test "$build_old_libs" = no; then
 		oldlibs="$output_objdir/$libname.$libext"
 		build_libtool_libs=module
 		build_old_libs=yes
 	      else
 	deplibs=$newdeplibs
 fi
 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
 case $host in
 	*-*-darwin*)
-	  newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
+	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
-	  new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
+	  new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
-	  deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
+	  deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 	  ;;
 esac
 # move library search paths that coincide with paths to not yet
 # installed libraries to the beginning of the library search list
 		    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 		    ;;
 		  esac
 		fi
 	      else
-		eval flag=\"$hardcode_libdir_flag_spec\"
+		eval "flag=\"$hardcode_libdir_flag_spec\""
 		dep_rpath="$dep_rpath $flag"
 	      fi
 	    elif test -n "$runpath_var"; then
 	      case "$perm_rpath " in
 	      *" $libdir "*) ;;
 	  # 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\"
+	      eval "dep_rpath=\"$hardcode_libdir_flag_spec_ld\""
 	    else
-	      eval dep_rpath=\"$hardcode_libdir_flag_spec\"
+	      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
-	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
+	    eval $runpath_var=\$rpath\$$runpath_var
+	    export $runpath_var
 	  fi
 	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
 	fi
 	shlibpath="$finalize_shlibpath"
 	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
 	if test -n "$shlibpath"; then
-	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
+	  eval $shlibpath_var=\$shlibpath\$$shlibpath_var
+	  export $shlibpath_var
 	fi
 	# Get the real and link names of the library.
-	eval shared_ext=\"$shrext_cmds\"
+	eval "shared_ext=\"$shrext_cmds\""
-	eval library_names=\"$library_names_spec\"
+	eval "library_names=\"$library_names_spec\""
 	set dummy $library_names
 	shift
 	realname="$1"
 	shift
 	if test -n "$soname_spec"; then
-	  eval soname=\"$soname_spec\"
+	  eval "soname=\"$soname_spec\""
 	else
 	  soname="$realname"
 	fi
 	if test -z "$dlname"; then
 	  dlname=$soname
 	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`
+	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
 	test "X$libobjs" = "X " && libobjs=
 	delfiles=
 	if test -n "$export_symbols" && test -n "$include_expsyms"; then
 	  $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
 	    $opt_dry_run || $RM $export_symbols
 	    cmds=$export_symbols_cmds
 	    save_ifs="$IFS"; IFS='~'
 	    for cmd in $cmds; do
 	      IFS="$save_ifs"
-	      eval cmd=\"$cmd\"
+	      eval "cmd=\"$cmd\""
 	      func_len " $cmd"
 	      len=$func_len_result
 	      if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
 		func_show_eval "$cmd" 'exit $?'
 		skipped_export=false
 	fi
 	if test -n "$export_symbols" && test -n "$include_expsyms"; then
 	  tmp_export_symbols="$export_symbols"
 	  test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
-	  $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
+	  $opt_dry_run || $ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"
 	fi
 	if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
 	  # The given exports_symbols file has to be filtered, so filter it.
 	  func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
 	    # TODO: could optimize this to just extract one archive.
 	    whole_archive_flag_spec=
 	  fi
 	  if test -n "$whole_archive_flag_spec"; then
 	    save_libobjs=$libobjs
-	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	    eval "libobjs=\"\$libobjs $whole_archive_flag_spec\""
 	    test "X$libobjs" = "X " && libobjs=
 	  else
 	    gentop="$output_objdir/${outputname}x"
 	    generated="$generated $gentop"
 	    test "X$libobjs" = "X " && libobjs=
 	  fi
 	fi
 	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
-	  eval flag=\"$thread_safe_flag_spec\"
+	  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
-	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
+	  $opt_dry_run || (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\"
+	    eval "test_cmds=\"$module_expsym_cmds\""
 	    cmds=$module_expsym_cmds
 	  else
-	    eval test_cmds=\"$module_cmds\"
+	    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\"
+	    eval "test_cmds=\"$archive_expsym_cmds\""
 	    cmds=$archive_expsym_cmds
 	  else
-	    eval test_cmds=\"$archive_cmds\"
+	    eval "test_cmds=\"$archive_cmds\""
 	    cmds=$archive_cmds
 	  fi
 	fi
 	if test "X$skipped_export" != "X:" &&
 	  # 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"`
+	  func_basename "$output"
+	  output_la=$func_basename_result
 	  # Clear the reloadable object creation command queue and
 	  # initialize k to one.
 	  test_cmds=
 	  concat_cmds=
 	  k=1
 	  if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
 	    output=${output_objdir}/${output_la}.lnkscript
 	    func_verbose "creating GNU ld script: $output"
-	    $ECHO 'INPUT (' > $output
+	    echo 'INPUT (' > $output
 	    for obj in $save_libobjs
 	    do
 	      $ECHO "$obj" >> $output
 	    done
-	    $ECHO ')' >> $output
+	    echo ')' >> $output
 	    delfiles="$delfiles $output"
 	  elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
 	    output=${output_objdir}/${output_la}.lnk
 	    func_verbose "creating linker input file list: $output"
 	    : > $output
 	    output=$firstobj\"$file_list_spec$output\"
 	  else
 	    if test -n "$save_libobjs"; then
 	      func_verbose "creating reloadable object files..."
 	      output=$output_objdir/$output_la-${k}.$objext
-	      eval test_cmds=\"$reload_cmds\"
+	      eval "test_cmds=\"$reload_cmds\""
 	      func_len " $test_cmds"
 	      len0=$func_len_result
 	      len=$len0
 	      # Loop over the list of objects to be linked.
 		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\"
+		    reload_objs=$objlist
+		    eval "concat_cmds=\"$reload_cmds\""
 		  else
 		    # All subsequent reloadable object files will link in
 		    # the last one created.
-		    eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
+		    reload_objs="$objlist $last_robj"
+		    eval "concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\""
 		  fi
 		  last_robj=$output_objdir/$output_la-${k}.$objext
 		  func_arith $k + 1
 		  k=$func_arith_result
 		  output=$output_objdir/$output_la-${k}.$objext
-		  objlist=$obj
+		  objlist=" $obj"
 		  func_len " $last_robj"
 		  func_arith $len0 + $func_len_result
 		  len=$func_arith_result
 		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\"
+	      reload_objs="$objlist $last_robj"
+	      eval "concat_cmds=\"\${concat_cmds}$reload_cmds\""
 	      if test -n "$last_robj"; then
-	        eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
+	        eval "concat_cmds=\"\${concat_cmds}~\$RM $last_robj\""
 	      fi
 	      delfiles="$delfiles $output"
 	    else
 	      output=
 	      export_symbols="$output_objdir/$libname.exp"
 	      $opt_dry_run || $RM $export_symbols
 	      libobjs=$output
 	      # Append the command to create the export file.
 	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
-	      eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
+	      eval "concat_cmds=\"\$concat_cmds$export_symbols_cmds\""
 	      if test -n "$last_robj"; then
-		eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
+		eval "concat_cmds=\"\$concat_cmds~\$RM $last_robj\""
 	      fi
 	    fi
 	    test -n "$save_libobjs" &&
 	      func_verbose "creating a temporary reloadable object file: $output"
 if ${skipped_export-false}; then
 	    if test -n "$export_symbols" && test -n "$include_expsyms"; then
 	      tmp_export_symbols="$export_symbols"
 	      test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
-	      $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
+	      $opt_dry_run || $ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"
 	    fi
 	    if test -n "$orig_export_symbols"; then
 	      # The given exports_symbols file has to be filtered, so filter it.
 	      func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
 	  libobjs=$output
 	  # Restore the value of output.
 	  output=$save_output
 	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
-	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	    eval "libobjs=\"\$libobjs $whole_archive_flag_spec\""
 	    test "X$libobjs" = "X " && libobjs=
 	  fi
 	  # Expand the library linking commands again to reset the
 	  # value of $libobjs for piecewise linking.
 	  fi
 	fi
 	if test -n "$delfiles"; then
 	  # Append the command to remove temporary files to $cmds.
-	  eval cmds=\"\$cmds~\$RM $delfiles\"
+	  eval "cmds=\"\$cmds~\$RM $delfiles\""
 	fi
 	# Add any objects from preloaded convenience libraries
 	if test -n "$dlprefiles"; then
 	  gentop="$output_objdir/${outputname}x"
 	fi
 	save_ifs="$IFS"; IFS='~'
 	for cmd in $cmds; do
 	  IFS="$save_ifs"
-	  eval cmd=\"$cmd\"
+	  eval "cmd=\"$cmd\""
 	  $opt_silent || {
 	    func_quote_for_expand "$cmd"
 	    eval "func_echo $func_quote_for_expand_result"
 	  }
 	  $opt_dry_run || eval "$cmd" || {
 	done
 	IFS="$save_ifs"
 	# Restore the uninstalled library and exit
 	if test "$mode" = relink; then
-	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
+	  $opt_dry_run || (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
 	      func_show_eval '${RM}r "$gentop"'
 	    fi
 # turning comma into space..
 wl=
 if test -n "$convenience"; then
 	if test -n "$whole_archive_flag_spec"; then
-	  eval tmp_whole_archive_flags=\"$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'`
+	  reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
 	else
 	  gentop="$output_objdir/${obj}x"
 	  generated="$generated $gentop"
 	  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
+reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
 output="$obj"
 func_execute_cmds "$reload_cmds" 'exit $?'
 # Exit if we aren't doing a library object file.
 	fi
 	# Create an invalid libtool object if no PIC, so that we don't
 	# accidentally link it into a program.
 	# $show "echo timestamp > $libobj"
-	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
+	# $opt_dry_run || echo timestamp > $libobj || exit $?
 	exit $EXIT_SUCCESS
 fi
 if test -n "$pic_flag" || test "$pic_mode" != default; then
 	# Only do commands if we really have different PIC objects.
 	  func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
 case $host in
 *-*-rhapsody* | *-*-darwin1.[012])
 	# On Rhapsody replace the C library is the System framework
-	compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
+	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
-	finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
+	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
 	;;
 esac
 case $host in
 *-*-darwin*)
 	      finalize_command="$finalize_command ${wl}-bind_at_load"
 	    ;;
 	  esac
 	fi
 	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
-	compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
+	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
-	finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
+	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 	;;
 esac
 # move library search paths that coincide with paths to not yet
 		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 		;;
 	      esac
 	    fi
 	  else
-	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    eval "flag=\"$hardcode_libdir_flag_spec\""
 	    rpath="$rpath $flag"
 	  fi
 	elif test -n "$runpath_var"; then
 	  case "$perm_rpath " in
 	  *" $libdir "*) ;;
 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\"
+	eval "rpath=\" $hardcode_libdir_flag_spec\""
 fi
 compile_rpath="$rpath"
 rpath=
 hardcode_libdirs=
 		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 		;;
 	      esac
 	    fi
 	  else
-	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    eval "flag=\"$hardcode_libdir_flag_spec\""
 	    rpath="$rpath $flag"
 	  fi
 	elif test -n "$runpath_var"; then
 	  case "$finalize_perm_rpath " in
 	  *" $libdir "*) ;;
 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\"
+	eval "rpath=\" $hardcode_libdir_flag_spec\""
 fi
 finalize_rpath="$rpath"
 if test -n "$libobjs" && test "$build_old_libs" = yes; then
 	# Transform all the library objects into standard objects.
-	compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+	compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
-	finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+	finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
 fi
 func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
 # template prelinking step
 	func_execute_cmds "$prelink_cmds" 'exit $?'
 fi
 wrappers_required=yes
 case $host in
+*cegcc* | *mingw32ce*)
+# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
+wrappers_required=no
+;;
 *cygwin* | *mingw* )
 if test "$build_libtool_libs" != yes; then
 wrappers_required=no
 fi
-;;
-*cegcc)
-# Disable wrappers for cegcc, we are cross compiling anyway.
-wrappers_required=no
 ;;
 *)
 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
 wrappers_required=no
 fi
 ;;
 esac
 if test "$wrappers_required" = no; then
 	# Replace the output file specification.
-	compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
+	compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
 	link_command="$compile_command$compile_rpath"
 	# We have no uninstalled library dependencies, so finalize right now.
 	exit_status=0
 	func_show_eval "$link_command" 'exit_status=$?'
 if test "$no_install" = yes; then
 	# We don't need to create a wrapper script.
 	link_command="$compile_var$compile_command$compile_rpath"
 	# Replace the output file specification.
-	link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
+	link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
 	# Delete the old output file.
 	$opt_dry_run || $RM $output
 	# Link the executable and exit
 	func_show_eval "$link_command" 'exit $?'
 	exit $EXIT_SUCCESS
 	func_warning "\`$output' will be relinked during installation"
 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 "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
 	  else
 	    # fast_install is set to needless
 	    relink_command=
 	  fi
 	else
 	  relink_command="$finalize_var$finalize_command$finalize_rpath"
 	fi
 fi
 # Replace the output file specification.
-link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
+link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
 # Delete the old output files.
 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
 func_show_eval "$link_command" 'exit $?'
 	    func_quote_for_eval "$var_value"
 	    relink_command="$var=$func_quote_for_eval_result; 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 "$relink_command" | $SED "$sed_quote_subst"`
-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 not in dry run mode.
 $opt_dry_run || {
 	# win32 will think the script is a binary if it has
 	      func_basename "$obj"
 	      $ECHO "$func_basename_result"
 	    done | sort | sort -uc >/dev/null 2>&1); then
 	  :
 	else
-	  $ECHO "copying selected object files to avoid basename conflicts..."
+	  echo "copying selected object files to avoid basename conflicts..."
 	  gentop="$output_objdir/${outputname}x"
 	  generated="$generated $gentop"
 	  func_mkdir_p "$gentop"
 	  save_oldobjs=$oldobjs
 	  oldobjs=
 	      ;;
 	    *) oldobjs="$oldobjs $obj" ;;
 	    esac
 	  done
 	fi
-	eval cmds=\"$old_archive_cmds\"
+	eval "cmds=\"$old_archive_cmds\""
 	func_len " $cmds"
 	len=$func_len_result
 	if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
 	  cmds=$old_archive_cmds
 	  # Is there a better way of finding the last object in the list?
 	  for obj in $save_oldobjs
 	  do
 	    last_oldobj=$obj
 	  done
-	  eval test_cmds=\"$old_archive_cmds\"
+	  eval "test_cmds=\"$old_archive_cmds\""
 	  func_len " $test_cmds"
 	  len0=$func_len_result
 	  len=$len0
 	  for obj in $save_oldobjs
 	  do
 	      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\"
+	      eval "concat_cmds=\"\${concat_cmds}$old_archive_cmds\""
 	      objlist=
 	      len=$len0
 	    fi
 	  done
 	  RANLIB=$save_RANLIB
 	  oldobjs=$objlist
 	  if test "X$oldobjs" = "X" ; then
-	    eval cmds=\"\$concat_cmds\"
+	    eval "cmds=\"\$concat_cmds\""
 	  else
-	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
+	    eval "cmds=\"\$concat_cmds~\$old_archive_cmds\""
 	  fi
 	fi
 fi
 func_execute_cmds "$cmds" 'exit $?'
 done
 	  relink_command="$var=$func_quote_for_eval_result; 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 "$relink_command" | $SED "$sed_quote_subst"`
 if test "$hardcode_automatic" = yes ; then
 	relink_command=
 fi
 # Only create the output if not a dry run.
 	    for deplib in $dependency_libs; do
 	      case $deplib in
 	      *.la)
 		func_basename "$deplib"
 		name="$func_basename_result"
-		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+		libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
 		test -z "$libdir" && \
 		  func_fatal_error "\`$deplib' is not a valid libtool archive"
 		newdependency_libs="$newdependency_libs $libdir/$name"
 		;;
 	      *) newdependency_libs="$newdependency_libs $deplib" ;;
 	    for lib in $dlfiles; do
 	      case $lib in
 	      *.la)
 	        func_basename "$lib"
 		name="$func_basename_result"
-		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+		libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
 		test -z "$libdir" && \
 		  func_fatal_error "\`$lib' is not a valid libtool archive"
 		newdlfiles="$newdlfiles $libdir/$name"
 		;;
 	      *) newdlfiles="$newdlfiles $lib" ;;
 		# eventual linking with the app. that links it) if we
 		# didn't already link the preopened objects directly into
 		# the library:
 		func_basename "$lib"
 		name="$func_basename_result"
-		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+		libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
 		test -z "$libdir" && \
 		  func_fatal_error "\`$lib' is not a valid libtool archive"
 		newdlprefiles="$newdlprefiles $libdir/$name"
 		;;
 	      esac
 	    done
 	    dlprefiles="$newdlprefiles"
 	  fi
 	  $RM $output
 	  # place dlname in correct position for cygwin
+	  # In fact, it would be nice if we could use this code for all target
+	  # systems that can't hard-code library paths into their executables
+	  # and that have no shared library path variable independent of PATH,
+	  # but it turns out we can't easily determine that from inspecting
+	  # libtool variables, so we have to hard-code the OSs to which it
+	  # applies here; at the moment, that means platforms that use the PE
+	  # object format with DLL files.  See the long comment at the top of
+	  # tests/bindir.at for full details.
 	  tdlname=$dlname
 	  case $host,$output,$installed,$module,$dlname in
-	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
+	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
+	      # If a -bindir argument was supplied, place the dll there.
+	      if test "x$bindir" != x ;
+	      then
+		func_relative_path "$install_libdir" "$bindir"
+		tdlname=$func_relative_path_result$dlname
+	      else
+		# Otherwise fall back on heuristic.
+		tdlname=../bin/$dlname
+	      fi
+	      ;;
 	  esac
 	  $ECHO > $output "\
 # $outputname - a libtool library file
 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
 #
 # Local Variables:
 # mode:shell-script
 # sh-indentation:2
 # End:
 # vi:sw=2

Mercurial > hg > CbC > CbC_gcc

comparison ltmain.sh @ 55:77e2b8dfacca gcc-4.4.5