# ltmain.sh - Provide generalized library-building support services.

 # NOTE: Changing this file will not affect anything until you rerun configure.

 #

 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004

 # Free Software Foundation, Inc.

 # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996

 #

 # This program is free software; you can redistribute it and/or modify

 # it under the terms of the GNU General Public License as published by

 # the Free Software Foundation; either version 2 of the License, or

 # (at your option) any later version.

 #

 # This program is distributed in the hope that it will be useful, but

 # WITHOUT ANY WARRANTY; without even the implied warranty of

 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 # General Public License for more details.

 #

 # You should have received a copy of the GNU General Public License

 # along with this program; if not, write to the Free Software

 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

 #

 # As a special exception to the GNU General Public License, if you

 # distribute this file as part of a program that contains a

 # configuration script generated by Autoconf, you may include it under

 # the same distribution terms that you use for the rest of that program.

 basename="s,^.*/,,g"

 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh

 # is ksh but when the shell is invoked as "sh" and the current value of

 # the _XPG environment variable is not equal to 1 (one), the special

 # positional parameter $0, within a function call, is the name of the

 # function.

 progpath="$0"

 # The name of this program:

 progname=`echo "$progpath" | $SED $basename`

 modename="$progname"

 # Global variables:

 EXIT_SUCCESS=0

 EXIT_FAILURE=1

 PROGRAM=ltmain.sh

 PACKAGE=libtool

 VERSION=1.5.6

 TIMESTAMP=" (1.1220.2.95 2004/04/11 05:50:42) Debian$Rev: 224 $"

 # 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

 default_mode=

 help="Try \`$progname --help' for more information."

 magic="%%%MAGIC variable%%%"

 mkdir="mkdir"

 mv="mv -f"

 rm="rm -f"

 # Sed substitution that helps us do robust quoting.  It backslashifies

 # metacharacters that are still active within double-quoted strings.

 Xsed="${SED}"' -e 1s/^X//'

 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'

 # test EBCDIC or ASCII

 case `echo A|tr A '\301'` in

  A) # EBCDIC based system

   SP2NL="tr '\100' '\n'"

   NL2SP="tr '\r\n' '\100\100'"

   ;;

  *) # Assume ASCII based system

   SP2NL="tr '\040' '\012'"

   NL2SP="tr '\015\012' '\040\040'"

   ;;

 esac

 # NLS nuisances.

 # Only set LANG and LC_ALL to C if already set.

 # These must not be set unconditionally because not all systems understand

 # e.g. LANG=C (notably SCO).

 # We save the old values to restore during execute mode.

 if test "${LC_ALL+set}" = set; then

   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL

 fi

 if test "${LANG+set}" = set; then

   save_LANG="$LANG"; LANG=C; export LANG

 fi

 # Make sure IFS has a sensible default

 : ${IFS=" 	

 "}

 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then

   $echo "$modename: not configured to build any kind of library" 1>&2

   $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2

   exit $EXIT_FAILURE

 fi

 # Global variables.

 mode=$default_mode

 nonopt=

 prev=

 prevopt=

 run=

 show="$echo"

 show_help=

 execute_dlfiles=

 lo2o="s/\\.lo\$/.${objext}/"

 o2lo="s/\\.${objext}\$/.lo/"

 #####################################

 # Shell function definitions:

 # This seems to be the best place for them

 # func_win32_libid arg

 # return the library type of file 'arg'

 #

 # Need a lot of goo to handle *both* DLLs and import libs

 # Has to be a shell function in order to 'eat' the argument

 # that is supplied when $file_magic_command is called.

 func_win32_libid () {

   win32_libid_type="unknown"

   win32_fileres=`file -L $1 2>/dev/null`

   case $win32_fileres in

   *ar\ archive\ import\ library*) # definitely import

     win32_libid_type="x86 archive import"

     ;;

   *ar\ archive*) # could be an import, or static

     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \

       $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then

       win32_nmres=`eval $NM -f posix -A $1 | \

 	sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`

       if test "X$win32_nmres" = "Ximport" ; then

         win32_libid_type="x86 archive import"

       else

         win32_libid_type="x86 archive static"

       fi

     fi

     ;;

   *DLL*)

     win32_libid_type="x86 DLL"

     ;;

   *executable*) # but shell scripts are "executable" too...

     case $win32_fileres in

     *MS\ Windows\ PE\ Intel*)

       win32_libid_type="x86 DLL"

       ;;

     esac

     ;;

   esac

   $echo $win32_libid_type

 }

 # func_infer_tag arg

 # Infer tagged configuration to use if any are available and

 # if one wasn't chosen via the "--tag" command line option.

 # Only attempt this if the compiler in the base compile

 # command doesn't match the default compiler.

 # arg is usually of the form 'gcc ...'

 func_infer_tag () {

     if test -n "$available_tags" && test -z "$tagname"; then

       CC_quoted=

       for arg in $CC; do

 	case $arg in

 	  *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

 	  arg="\"$arg\""

 	  ;;

 	esac

 	CC_quoted="$CC_quoted $arg"

       done

       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` "*) ;;

       # 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

 	    # Evaluate the configuration.

 	    eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"

 	    CC_quoted=

 	    for arg in $CC; do

 	    # Double-quote args containing other shell metacharacters.

 	    case $arg in

 	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

 	      arg="\"$arg\""

 	      ;;

 	    esac

 	    CC_quoted="$CC_quoted $arg"

 	  done

 	    case "$@ " in

 	      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)

 	      # 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

 	      ;;

 	    esac

 	  fi

 	done

 	# If $tagname still isn't set, then no tagged configuration

 	# was found and let the user know that the "--tag" command

 	# line option must be used.

 	if test -z "$tagname"; then

 	  $echo "$modename: unable to infer tagged configuration"

 	  $echo "$modename: specify a tag with \`--tag'" 1>&2

 	  exit $EXIT_FAILURE

 #        else

 #          $echo "$modename: using $tagname tagged configuration"

 	fi

 	;;

       esac

     fi

 }

 # End of Shell function definitions

 #####################################

 # Darwin sucks

 eval std_shrext=\"$shrext_cmds\"

 # Parse our command line options once, thoroughly.

 while test "$#" -gt 0

 do

   arg="$1"

   shift

   case $arg in

   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;

   *) optarg= ;;

   esac

   # If the previous option needs an argument, assign it.

   if test -n "$prev"; then

     case $prev in

     execute_dlfiles)

       execute_dlfiles="$execute_dlfiles $arg"

       ;;

     tag)

       tagname="$arg"

       preserve_args="${preserve_args}=$arg"

       # Check whether tagname contains only valid characters

       case $tagname in

       *[!-_A-Za-z0-9,/]*)

 	$echo "$progname: invalid tag name: $tagname" 1>&2

 	exit $EXIT_FAILURE

 	;;

       esac

       case $tagname in

       CC)

 	# Don't test for the "default" C tag, as we know, it's there, but

 	# not specially marked.

 	;;

       *)

 	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then

 	  taglist="$taglist $tagname"

 	  # Evaluate the configuration.

 	  eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"

 	else

 	  $echo "$progname: ignoring unknown tag $tagname" 1>&2

 	fi

 	;;

       esac

       ;;

     *)

       eval "$prev=\$arg"

       ;;

     esac

     prev=

     prevopt=

     continue

   fi

   # Have we seen a non-optional argument yet?

   case $arg in

   --help)

     show_help=yes

     ;;

   --version)

     $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"

     $echo

     $echo "Copyright (C) 2003  Free Software Foundation, Inc."

     $echo "This is free software; see the source for copying conditions.  There is NO"

     $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."

     exit $EXIT_SUCCESS

     ;;

   --config)

     ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath

     # Now print the configurations for the tags.

     for tagname in $taglist; do

       ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"

     done

     exit $EXIT_SUCCESS

     ;;

   --debug)

     $echo "$progname: enabling shell trace mode"

     set -x

     preserve_args="$preserve_args $arg"

     ;;

   --dry-run | -n)

     run=:

     ;;

   --features)

     $echo "host: $host"

     if test "$build_libtool_libs" = yes; then

       $echo "enable shared libraries"

     else

       $echo "disable shared libraries"

     fi

     if test "$build_old_libs" = yes; then

       $echo "enable static libraries"

     else

       $echo "disable static libraries"

     fi

     exit $EXIT_SUCCESS

     ;;

   --finish) mode="finish" ;;

   --mode) prevopt="--mode" prev=mode ;;

   --mode=*) mode="$optarg" ;;

   --preserve-dup-deps) duplicate_deps="yes" ;;

   --quiet | --silent)

     show=:

     preserve_args="$preserve_args $arg"

     ;;

   --tag) prevopt="--tag" prev=tag ;;

   --tag=*)

     set tag "$optarg" ${1+"$@"}

     shift

     prev=tag

     preserve_args="$preserve_args --tag"

     ;;

   -dlopen)

     prevopt="-dlopen"

     prev=execute_dlfiles

     ;;

   -*)

     $echo "$modename: unrecognized option \`$arg'" 1>&2

     $echo "$help" 1>&2

     exit $EXIT_FAILURE

     ;;

   *)

     nonopt="$arg"

     break

     ;;

   esac

 done

 if test -n "$prevopt"; then

   $echo "$modename: option \`$prevopt' requires an argument" 1>&2

   $echo "$help" 1>&2

   exit $EXIT_FAILURE

 fi

 # If this variable is set in any of the actions, the command in it

 # will be execed at the end.  This prevents here-documents from being

 # left over by shells.

 exec_cmd=

 if test -z "$show_help"; then

   # Infer the operation mode.

   if test -z "$mode"; then

     $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2

     $echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2

     case $nonopt in

     *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)

       mode=link

       for arg

       do

 	case $arg in

 	-c)

 	   mode=compile

 	   break

 	   ;;

 	esac

       done

       ;;

     *db | *dbx | *strace | *truss)

       mode=execute

       ;;

     *install*|cp|mv)

       mode=install

       ;;

     *rm)

       mode=uninstall

       ;;

     *)

       # If we have no mode, but dlfiles were specified, then do execute mode.

       test -n "$execute_dlfiles" && mode=execute

       # Just use the default operation mode.

       if test -z "$mode"; then

 	if test -n "$nonopt"; then

 	  $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2

 	else

 	  $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2

 	fi

       fi

       ;;

     esac

   fi

   # Only execute mode is allowed to have -dlopen flags.

   if test -n "$execute_dlfiles" && test "$mode" != execute; then

     $echo "$modename: unrecognized option \`-dlopen'" 1>&2

     $echo "$help" 1>&2

     exit $EXIT_FAILURE

   fi

   # Change the help message to a mode-specific one.

   generic_help="$help"

   help="Try \`$modename --help --mode=$mode' for more information."

   # These modes are in order of execution frequency so that they run quickly.

   case $mode in

   # libtool compile mode

   compile)

     modename="$modename: compile"

     # Get the compilation command and the source file.

     base_compile=

     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"

     suppress_opt=yes

     suppress_output=

     arg_mode=normal

     libobj=

     later=

     for arg

     do

       case "$arg_mode" in

       arg  )

 	# do not "continue".  Instead, add this to base_compile

 	lastarg="$arg"

 	arg_mode=normal

 	;;

       target )

 	libobj="$arg"

 	arg_mode=normal

 	continue

 	;;

       normal )

 	# Accept any command-line options.

 	case $arg in

 	-o)

 	  if test -n "$libobj" ; then

 	    $echo "$modename: you cannot specify \`-o' more than once" 1>&2

 	    exit $EXIT_FAILURE

 	  fi

 	  arg_mode=target

 	  continue

 	  ;;

 	-static | -prefer-pic | -prefer-non-pic)

 	  later="$later $arg"

 	  continue

 	  ;;

 	-no-suppress)

 	  suppress_opt=no

 	  continue

 	  ;;

 	-Xcompiler)

 	  arg_mode=arg  #  the next one goes into the "base_compile" arg list

 	  continue      #  The current "srcfile" will either be retained or

 	  ;;            #  replaced later.  I would guess that would be a bug.

 	-Wc,*)

 	  args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`

 	  lastarg=

 	  save_ifs="$IFS"; IFS=','

  	  for arg in $args; do

 	    IFS="$save_ifs"

 	    # Double-quote args containing other shell metacharacters.

 	    # Many Bourne shells cannot handle close brackets correctly

 	    # in scan sets, so we specify it separately.

 	    case $arg in

 	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

 	      arg="\"$arg\""

 	      ;;

 	    esac

 	    lastarg="$lastarg $arg"

 	  done

 	  IFS="$save_ifs"

 	  lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`

 	  # Add the arguments to base_compile.

 	  base_compile="$base_compile $lastarg"

 	  continue

 	  ;;

 	* )

 	  # Accept the current argument as the source file.

 	  # The previous "srcfile" becomes the current argument.

 	  #

 	  lastarg="$srcfile"

 	  srcfile="$arg"

 	  ;;

 	esac  #  case $arg

 	;;

       esac    #  case $arg_mode

       # Aesthetically quote the previous argument.

       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`

       case $lastarg in

       # Double-quote args containing other shell metacharacters.

       # Many Bourne shells cannot handle close brackets correctly

       # in scan sets, so we specify it separately.

       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

 	lastarg="\"$lastarg\""

 	;;

       esac

       base_compile="$base_compile $lastarg"

     done # for arg

     case $arg_mode in

     arg)

       $echo "$modename: you must specify an argument for -Xcompile"

       exit $EXIT_FAILURE

       ;;

     target)

       $echo "$modename: you must specify a target with \`-o'" 1>&2

       exit $EXIT_FAILURE

       ;;

     *)

       # Get the name of the library object.

       [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`

       ;;

     esac

     # Recognize several different file suffixes.

     # If the user specifies -o file.o, it is replaced with file.lo

     xform='[cCFSifmso]'

     case $libobj in

     *.ada) xform=ada ;;

     *.adb) xform=adb ;;

     *.ads) xform=ads ;;

     *.asm) xform=asm ;;

     *.c++) xform=c++ ;;

     *.cc) xform=cc ;;

     *.ii) xform=ii ;;

     *.class) xform=class ;;

     *.cpp) xform=cpp ;;

     *.cxx) xform=cxx ;;

     *.f90) xform=f90 ;;

     *.for) xform=for ;;

     *.java) xform=java ;;

     esac

     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`

     case $libobj in

     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;

     *)

       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2

       exit $EXIT_FAILURE

       ;;

     esac

     func_infer_tag $base_compile

     for arg in $later; do

       case $arg in

       -static)

 	build_old_libs=yes

 	continue

 	;;

       -prefer-pic)

 	pic_mode=yes

 	continue

 	;;

       -prefer-non-pic)

 	pic_mode=no

 	continue

 	;;

       esac

     done

     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`

     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`

     if test "X$xdir" = "X$obj"; then

       xdir=

     else

       xdir=$xdir/

     fi

     lobj=${xdir}$objdir/$objname

     if test -z "$base_compile"; then

       $echo "$modename: you must specify a compilation command" 1>&2

       $echo "$help" 1>&2

       exit $EXIT_FAILURE

     fi

     # Delete any leftover library objects.

     if test "$build_old_libs" = yes; then

       removelist="$obj $lobj $libobj ${libobj}T"

     else

       removelist="$lobj $libobj ${libobj}T"

     fi

     $run $rm $removelist

     trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15

     # On Cygwin there's no "real" PIC flag so we must build both object types

     case $host_os in

     cygwin* | mingw* | pw32* | os2*)

       pic_mode=default

       ;;

     esac

     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then

       # non-PIC code in shared libraries is not supported

       pic_mode=default

     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}

       lockfile="$output_obj.lock"

       removelist="$removelist $output_obj $lockfile"

       trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15

     else

       output_obj=

       need_locks=no

       lockfile=

     fi

     # Lock this critical section if it is needed

     # We use this script file to make the link, it avoids creating a new file

     if test "$need_locks" = yes; then

       until $run ln "$progpath" "$lockfile" 2>/dev/null; do

 	$show "Waiting for $lockfile to be removed"

 	sleep 2

       done

     elif test "$need_locks" = warn; then

       if test -f "$lockfile"; then

 	$echo "\

 *** ERROR, $lockfile exists and contains:

 `cat $lockfile 2>/dev/null`

 This indicates that another process is trying to use the same

 temporary object file, and libtool could not work around it because

 your compiler does not support \`-c' and \`-o' together.  If you

 repeat this compilation, it may succeed, by chance, but you had better

 avoid parallel builds (make -j) in this platform, or get a better

 compiler."

 	$run $rm $removelist

 	exit $EXIT_FAILURE

       fi

       $echo $srcfile > "$lockfile"

     fi

     if test -n "$fix_srcfile_path"; then

       eval srcfile=\"$fix_srcfile_path\"

     fi

     $run $rm "$libobj" "${libobj}T"

     # Create a libtool object file (analogous to a ".la" file),

     # but don't create it if we're doing a dry run.

     test -z "$run" && cat > ${libobj}T <<EOF

 # $libobj - a libtool object file

 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP

 #

 # Please DO NOT delete this file!

 # It is necessary for linking the library.

 # Name of the PIC object.

 EOF

     # Only build a PIC object if we are building libtool libraries.

     if test "$build_libtool_libs" = yes; then

       # Without this assignment, base_compile gets emptied.

       fbsd_hideous_sh_bug=$base_compile

       if test "$pic_mode" != no; then

 	command="$base_compile $srcfile $pic_flag"

       else

 	# Don't build PIC code

 	command="$base_compile $srcfile"

       fi

       if test ! -d "${xdir}$objdir"; then

 	$show "$mkdir ${xdir}$objdir"

 	$run $mkdir ${xdir}$objdir

 	status=$?

 	if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then

 	  exit $status

 	fi

       fi

       if test -z "$output_obj"; then

 	# Place PIC objects in $objdir

 	command="$command -o $lobj"

       fi

       $run $rm "$lobj" "$output_obj"

       $show "$command"

       if $run eval "$command"; then :

       else

 	test -n "$output_obj" && $run $rm $removelist

 	exit $EXIT_FAILURE

       fi

       if test "$need_locks" = warn &&

 	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then

 	$echo "\

 *** ERROR, $lockfile contains:

 `cat $lockfile 2>/dev/null`

 but it should contain:

 $srcfile

 This indicates that another process is trying to use the same

 temporary object file, and libtool could not work around it because

 your compiler does not support \`-c' and \`-o' together.  If you

 repeat this compilation, it may succeed, by chance, but you had better

 avoid parallel builds (make -j) in this platform, or get a better

 compiler."

 	$run $rm $removelist

 	exit $EXIT_FAILURE

       fi

       # Just move the object if needed, then go on to compile the next one

       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then

 	$show "$mv $output_obj $lobj"

 	if $run $mv $output_obj $lobj; then :

 	else

 	  error=$?

 	  $run $rm $removelist

 	  exit $error

 	fi

       fi

       # Append the name of the PIC object to the libtool object file.

       test -z "$run" && cat >> ${libobj}T <<EOF

 pic_object='$objdir/$objname'

 EOF

       # Allow error messages only from the first compilation.

       if test "$suppress_opt" = yes; then

         suppress_output=' >/dev/null 2>&1'

       fi

     else

       # No PIC object so indicate it doesn't exist in the libtool

       # object file.

       test -z "$run" && cat >> ${libobj}T <<EOF

 pic_object=none

 EOF

     fi

     # Only build a position-dependent object if we build old libraries.

     if test "$build_old_libs" = yes; then

       if test "$pic_mode" != yes; then

 	# Don't build PIC code

 	command="$base_compile $srcfile"

       else

 	command="$base_compile $srcfile $pic_flag"

       fi

       if test "$compiler_c_o" = yes; then

 	command="$command -o $obj"

       fi

       # Suppress compiler output if we already did a PIC compilation.

       command="$command$suppress_output"

       $run $rm "$obj" "$output_obj"

       $show "$command"

       if $run eval "$command"; then :

       else

 	$run $rm $removelist

 	exit $EXIT_FAILURE

       fi

       if test "$need_locks" = warn &&

 	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then

 	$echo "\

 *** ERROR, $lockfile contains:

 `cat $lockfile 2>/dev/null`

 but it should contain:

 $srcfile

 This indicates that another process is trying to use the same

 temporary object file, and libtool could not work around it because

 your compiler does not support \`-c' and \`-o' together.  If you

 repeat this compilation, it may succeed, by chance, but you had better

 avoid parallel builds (make -j) in this platform, or get a better

 compiler."

 	$run $rm $removelist

 	exit $EXIT_FAILURE

       fi

       # Just move the object if needed

       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then

 	$show "$mv $output_obj $obj"

 	if $run $mv $output_obj $obj; then :

 	else

 	  error=$?

 	  $run $rm $removelist

 	  exit $error

 	fi

       fi

       # Append the name of the non-PIC object the libtool object file.

       # Only append if the libtool object file exists.

       test -z "$run" && cat >> ${libobj}T <<EOF

 # Name of the non-PIC object.

 non_pic_object='$objname'

 EOF

     else

       # Append the name of the non-PIC object the libtool object file.

       # Only append if the libtool object file exists.

       test -z "$run" && cat >> ${libobj}T <<EOF

 # Name of the non-PIC object.

 non_pic_object=none

 EOF

     fi

     $run $mv "${libobj}T" "${libobj}"

     # Unlock the critical section if it was locked

     if test "$need_locks" != no; then

       $run $rm "$lockfile"

     fi

     exit $EXIT_SUCCESS

     ;;

   # libtool link mode

   link | relink)

     modename="$modename: link"

     case $host in

     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)

       # It is impossible to link a dll without this setting, and

       # we shouldn't force the makefile maintainer to figure out

       # which system we are compiling for in order to pass an extra

       # flag for every libtool invocation.

       # allow_undefined=no

       # FIXME: Unfortunately, there are problems with the above when trying

       # to make a dll which has undefined symbols, in which case not

       # even a static library is built.  For now, we need to specify

       # -no-undefined on the libtool link line when we can be certain

       # that all symbols are satisfied, otherwise we get a static library.

       allow_undefined=yes

       ;;

     *)

       allow_undefined=yes

       ;;

     esac

     libtool_args="$nonopt"

     base_compile="$nonopt $@"

     compile_command="$nonopt"

     finalize_command="$nonopt"

     compile_rpath=

     finalize_rpath=

     compile_shlibpath=

     finalize_shlibpath=

     convenience=

     old_convenience=

     deplibs=

     old_deplibs=

     compiler_flags=

     linker_flags=

     dllsearchpath=

     lib_search_path=`pwd`

     inst_prefix_dir=

     avoid_version=no

     dlfiles=

     dlprefiles=

     dlself=no

     export_dynamic=no

     export_symbols=

     export_symbols_regex=

     generated=

     libobjs=

     ltlibs=

     module=no

     no_install=no

     objs=

     non_pic_objects=

     precious_files_regex=

     prefer_static_libs=no

     preload=no

     prev=

     prevarg=

     release=

     rpath=

     xrpath=

     perm_rpath=

     temp_rpath=

     thread_safe=no

     vinfo=

     vinfo_number=no

     func_infer_tag $base_compile

     # We need to know -static, to get the right output filenames.

     for arg

     do

       case $arg in

       -all-static | -static)

 	if test "X$arg" = "X-all-static"; then

 	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then

 	    $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2

 	  fi

 	  if test -n "$link_static_flag"; then

 	    dlopen_self=$dlopen_self_static

 	  fi

 	else

 	  if test -z "$pic_flag" && test -n "$link_static_flag"; then

 	    dlopen_self=$dlopen_self_static

 	  fi

 	fi

 	build_libtool_libs=no

 	build_old_libs=yes

 	prefer_static_libs=yes

 	break

 	;;

       esac

     done

     # See if our shared archives depend on static archives.

     test -n "$old_archive_from_new_cmds" && build_old_libs=yes

     # Go through the arguments, transforming them on the way.

     while test "$#" -gt 0; do

       arg="$1"

       shift

       case $arg in

       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

 	qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test

 	;;

       *) qarg=$arg ;;

       esac

       libtool_args="$libtool_args $qarg"

       # If the previous option needs an argument, assign it.

       if test -n "$prev"; then

 	case $prev in

 	output)

 	  compile_command="$compile_command @OUTPUT@"

 	  finalize_command="$finalize_command @OUTPUT@"

 	  ;;

 	esac

 	case $prev in

 	dlfiles|dlprefiles)

 	  if test "$preload" = no; then

 	    # Add the symbol object into the linking commands.

 	    compile_command="$compile_command @SYMFILE@"

 	    finalize_command="$finalize_command @SYMFILE@"

 	    preload=yes

 	  fi

 	  case $arg in

 	  *.la | *.lo) ;;  # We handle these cases below.

 	  force)

 	    if test "$dlself" = no; then

 	      dlself=needless

 	      export_dynamic=yes

 	    fi

 	    prev=

 	    continue

 	    ;;

 	  self)

 	    if test "$prev" = dlprefiles; then

 	      dlself=yes

 	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then

 	      dlself=yes

 	    else

 	      dlself=needless

 	      export_dynamic=yes

 	    fi

 	    prev=

 	    continue

 	    ;;

 	  *)

 	    if test "$prev" = dlfiles; then

 	      dlfiles="$dlfiles $arg"

 	    else

 	      dlprefiles="$dlprefiles $arg"

 	    fi

 	    prev=

 	    continue

 	    ;;

 	  esac

 	  ;;

 	expsyms)

 	  export_symbols="$arg"

 	  if test ! -f "$arg"; then

 	    $echo "$modename: symbol file \`$arg' does not exist"

 	    exit $EXIT_FAILURE

 	  fi

 	  prev=

 	  continue

 	  ;;

 	expsyms_regex)

 	  export_symbols_regex="$arg"

 	  prev=

 	  continue

 	  ;;

 	inst_prefix)

 	  inst_prefix_dir="$arg"

 	  prev=

 	  continue

 	  ;;

 	precious_regex)

 	  precious_files_regex="$arg"

 	  prev=

 	  continue

 	  ;;

 	release)

 	  release="-$arg"

 	  prev=

 	  continue

 	  ;;

 	objectlist)

 	  if test -f "$arg"; then

 	    save_arg=$arg

 	    moreargs=

 	    for fil in `cat $save_arg`

 	    do

 #	      moreargs="$moreargs $fil"

 	      arg=$fil

 	      # A libtool-controlled object.

 	      # Check to see that this really is a libtool object.

 	      if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

 		pic_object=

 		non_pic_object=

 		# Read the .lo file

 		# If there is no directory component, then add one.

 		case $arg in

 		*/* | *\\*) . $arg ;;

 		*) . ./$arg ;;

 		esac

 		if test -z "$pic_object" || \

 		   test -z "$non_pic_object" ||

 		   test "$pic_object" = none && \

 		   test "$non_pic_object" = none; then

 		  $echo "$modename: cannot find name of object for \`$arg'" 1>&2

 		  exit $EXIT_FAILURE

 		fi

 		# Extract subdirectory from the argument.

 		xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`

 		if test "X$xdir" = "X$arg"; then

 		  xdir=

 		else

 		  xdir="$xdir/"

 		fi

 		if test "$pic_object" != none; then

 		  # Prepend the subdirectory the object is found in.

 		  pic_object="$xdir$pic_object"

 		  if test "$prev" = dlfiles; then

 		    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then

 		      dlfiles="$dlfiles $pic_object"

 		      prev=

 		      continue

 		    else

 		      # If libtool objects are unsupported, then we need to preload.

 		      prev=dlprefiles

 		    fi

 		  fi

 		  # CHECK ME:  I think I busted this.  -Ossama

 		  if test "$prev" = dlprefiles; then

 		    # Preload the old-style object.

 		    dlprefiles="$dlprefiles $pic_object"

 		    prev=

 		  fi

 		  # A PIC object.

 		  libobjs="$libobjs $pic_object"

 		  arg="$pic_object"

 		fi

 		# Non-PIC object.

 		if test "$non_pic_object" != none; then

 		  # Prepend the subdirectory the object is found in.

 		  non_pic_object="$xdir$non_pic_object"

 		  # A standard non-PIC object

 		  non_pic_objects="$non_pic_objects $non_pic_object"

 		  if test -z "$pic_object" || test "$pic_object" = none ; then

 		    arg="$non_pic_object"

 		  fi

 		fi

 	      else

 		# Only an error if not doing a dry-run.

 		if test -z "$run"; then

 		  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2

 		  exit $EXIT_FAILURE

 		else

 		  # Dry-run case.

 		  # Extract subdirectory from the argument.

 		  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`

 		  if test "X$xdir" = "X$arg"; then

 		    xdir=

 		  else

 		    xdir="$xdir/"

 		  fi

 		  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`

 		  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`

 		  libobjs="$libobjs $pic_object"

 		  non_pic_objects="$non_pic_objects $non_pic_object"

 		fi

 	      fi

 	    done

 	  else

 	    $echo "$modename: link input file \`$save_arg' does not exist"

 	    exit $EXIT_FAILURE

 	  fi

 	  arg=$save_arg

 	  prev=

 	  continue

 	  ;;

 	rpath | xrpath)

 	  # We need an absolute path.

 	  case $arg in

 	  [\\/]* | [A-Za-z]:[\\/]*) ;;

 	  *)

 	    $echo "$modename: only absolute run-paths are allowed" 1>&2

 	    exit $EXIT_FAILURE

 	    ;;

 	  esac

 	  if test "$prev" = rpath; then

 	    case "$rpath " in

 	    *" $arg "*) ;;

 	    *) rpath="$rpath $arg" ;;

 	    esac

 	  else

 	    case "$xrpath " in

 	    *" $arg "*) ;;

 	    *) xrpath="$xrpath $arg" ;;

 	    esac

 	  fi

 	  prev=

 	  continue

 	  ;;

 	xcompiler)

 	  compiler_flags="$compiler_flags $qarg"

 	  prev=

 	  compile_command="$compile_command $qarg"

 	  finalize_command="$finalize_command $qarg"

 	  continue

 	  ;;

 	xlinker)

 	  linker_flags="$linker_flags $qarg"

 	  compiler_flags="$compiler_flags $wl$qarg"

 	  prev=

 	  compile_command="$compile_command $wl$qarg"

 	  finalize_command="$finalize_command $wl$qarg"

 	  continue

 	  ;;

 	xcclinker)

 	  linker_flags="$linker_flags $qarg"

 	  compiler_flags="$compiler_flags $qarg"

 	  prev=

 	  compile_command="$compile_command $qarg"

 	  finalize_command="$finalize_command $qarg"

 	  continue

 	  ;;

 	shrext)

   	  shrext_cmds="$arg"

 	  prev=

 	  continue

 	  ;;

 	*)

 	  eval "$prev=\"\$arg\""

 	  prev=

 	  continue

 	  ;;

 	esac

       fi # test -n "$prev"

       prevarg="$arg"

       case $arg in

       -all-static)

 	if test -n "$link_static_flag"; then

 	  compile_command="$compile_command $link_static_flag"

 	  finalize_command="$finalize_command $link_static_flag"

 	fi

 	continue

 	;;

       -allow-undefined)

 	# FIXME: remove this flag sometime in the future.

 	$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2

 	continue

 	;;

       -avoid-version)

 	avoid_version=yes

 	continue

 	;;

       -dlopen)

 	prev=dlfiles

 	continue

 	;;

       -dlpreopen)

 	prev=dlprefiles

 	continue

 	;;

       -export-dynamic)

 	export_dynamic=yes

 	continue

 	;;

       -export-symbols | -export-symbols-regex)

 	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then

 	  $echo "$modename: more than one -exported-symbols argument is not allowed"

 	  exit $EXIT_FAILURE

 	fi

 	if test "X$arg" = "X-export-symbols"; then

 	  prev=expsyms

 	else

 	  prev=expsyms_regex

 	fi

 	continue

 	;;

       -inst-prefix-dir)

 	prev=inst_prefix

 	continue

 	;;

       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*

       # so, if we see these flags be careful not to treat them like -L

       -L[A-Z][A-Z]*:*)

 	case $with_gcc/$host in

 	no/*-*-irix* | /*-*-irix*)

 	  compile_command="$compile_command $arg"

 	  finalize_command="$finalize_command $arg"

 	  ;;

 	esac

 	continue

 	;;

       -L*)

 	dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`

 	# We need an absolute path.

 	case $dir in

 	[\\/]* | [A-Za-z]:[\\/]*) ;;

 	*)

 	  absdir=`cd "$dir" && pwd`

 	  if test -z "$absdir"; then

 	    $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2

 	    exit $EXIT_FAILURE

 	  fi

 	  dir="$absdir"

 	  ;;

 	esac

 	case "$deplibs " in

 	*" -L$dir "*) ;;

 	*)

 	  deplibs="$deplibs -L$dir"

 	  lib_search_path="$lib_search_path $dir"

 	  ;;

 	esac

 	case $host in

 	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)

 	  case :$dllsearchpath: in

 	  *":$dir:"*) ;;

 	  *) dllsearchpath="$dllsearchpath:$dir";;

 	  esac

 	  ;;

 	esac

 	continue

 	;;

       -l*)

 	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then

 	  case $host in

 	  *-*-cygwin* | *-*-pw32* | *-*-beos*)

 	    # These systems don't actually have a C or math library (as such)

 	    continue

 	    ;;

 	  *-*-mingw* | *-*-os2*)

 	    # These systems don't actually have a C library (as such)

 	    test "X$arg" = "X-lc" && continue

 	    ;;

 	  *-*-openbsd* | *-*-freebsd*)

 	    # Do not include libc due to us having libc/libc_r.

 	    test "X$arg" = "X-lc" && continue

 	    ;;

 	  *-*-rhapsody* | *-*-darwin1.[012])

 	    # Rhapsody C and math libraries are in the System framework

 	    deplibs="$deplibs -framework System"

 	    continue

 	  esac

 	elif test "X$arg" = "X-lc_r"; then

 	 case $host in

 	 *-*-openbsd* | *-*-freebsd*)

 	   # Do not include libc_r directly, use -pthread flag.

 	   continue

 	   ;;

 	 esac

 	fi

 	deplibs="$deplibs $arg"

 	continue

 	;;

      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)

 	deplibs="$deplibs $arg"

 	continue

 	;;

       -module)

 	module=yes

 	continue

 	;;

       # gcc -m* arguments should be passed to the linker via $compiler_flags

       # in order to pass architecture information to the linker

       # (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo

       # but this is not reliable with gcc because gcc may use -mfoo to

       # select a different linker, different libraries, etc, while

       # -Wl,-mfoo simply passes -mfoo to the linker.

       -m*)

 	# Unknown arguments in both finalize_command and compile_command need

 	# to be aesthetically quoted because they are evaled later.

 	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`

 	case $arg in

 	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

 	  arg="\"$arg\""

 	  ;;

 	esac

         compile_command="$compile_command $arg"

         finalize_command="$finalize_command $arg"

         if test "$with_gcc" = "yes" ; then

           compiler_flags="$compiler_flags $arg"

         fi

         continue

         ;;

       -shrext)

 	prev=shrext

 	continue

 	;;

       -no-fast-install)

 	fast_install=no

 	continue

 	;;

       -no-install)

 	case $host in

 	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)

 	  # The PATH hackery in wrapper scripts is required on Windows

 	  # in order for the loader to find any dlls it needs.

 	  $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2

 	  $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2

 	  fast_install=no

 	  ;;

 	*) no_install=yes ;;

 	esac

 	continue

 	;;

       -no-undefined)

 	allow_undefined=no

 	continue

 	;;

       -objectlist)

 	prev=objectlist

 	continue

 	;;

       -o) prev=output ;;

       -precious-files-regex)

 	prev=precious_regex

 	continue

 	;;

       -release)

 	prev=release

 	continue

 	;;

       -rpath)

 	prev=rpath

 	continue

 	;;

       -R)

 	prev=xrpath

 	continue

 	;;

       -R*)

 	dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`

 	# We need an absolute path.

 	case $dir in

 	[\\/]* | [A-Za-z]:[\\/]*) ;;

 	*)

 	  $echo "$modename: only absolute run-paths are allowed" 1>&2

 	  exit $EXIT_FAILURE

 	  ;;

 	esac

 	case "$xrpath " in

 	*" $dir "*) ;;

 	*) xrpath="$xrpath $dir" ;;

 	esac

 	continue

 	;;

       -static)

 	# The effects of -static are defined in a previous loop.

 	# We used to do the same as -all-static on platforms that

 	# didn't have a PIC flag, but the assumption that the effects

 	# would be equivalent was wrong.  It would break on at least

 	# Digital Unix and AIX.

 	continue

 	;;

       -thread-safe)

 	thread_safe=yes

 	continue

 	;;

       -version-info)

 	prev=vinfo

 	continue

 	;;

       -version-number)

 	prev=vinfo

 	vinfo_number=yes

 	continue

 	;;

       -Wc,*)

 	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`

 	arg=

 	save_ifs="$IFS"; IFS=','

 	for flag in $args; do

 	  IFS="$save_ifs"

 	  case $flag in

 	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

 	    flag="\"$flag\""

 	    ;;

 	  esac

 	  arg="$arg $wl$flag"

 	  compiler_flags="$compiler_flags $flag"

 	done

 	IFS="$save_ifs"

 	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`

 	;;

       -Wl,*)

 	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`

 	arg=

 	save_ifs="$IFS"; IFS=','

 	for flag in $args; do

 	  IFS="$save_ifs"

 	  case $flag in

 	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

 	    flag="\"$flag\""

 	    ;;

 	  esac

 	  arg="$arg $wl$flag"

 	  compiler_flags="$compiler_flags $wl$flag"

 	  linker_flags="$linker_flags $flag"

 	done

 	IFS="$save_ifs"

 	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`

 	;;

       -Xcompiler)

 	prev=xcompiler

 	continue

 	;;

       -Xlinker)

 	prev=xlinker

 	continue

 	;;

       -XCClinker)

 	prev=xcclinker

 	continue

 	;;

       # Some other compiler flag.

       -* | +*)

 	# Unknown arguments in both finalize_command and compile_command need

 	# to be aesthetically quoted because they are evaled later.

 	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`

 	case $arg in

 	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

 	  arg="\"$arg\""

 	  ;;

 	esac

 	;;

       *.$objext)

 	# A standard object.

 	objs="$objs $arg"

 	;;

       *.lo)

 	# A libtool-controlled object.

 	# Check to see that this really is a libtool object.

 	if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

 	  pic_object=

 	  non_pic_object=

 	  # Read the .lo file

 	  # If there is no directory component, then add one.

 	  case $arg in

 	  */* | *\\*) . $arg ;;

 	  *) . ./$arg ;;

 	  esac

 	  if test -z "$pic_object" || \

 	     test -z "$non_pic_object" ||

 	     test "$pic_object" = none && \

 	     test "$non_pic_object" = none; then

 	    $echo "$modename: cannot find name of object for \`$arg'" 1>&2

 	    exit $EXIT_FAILURE

 	  fi

 	  # Extract subdirectory from the argument.

 	  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`

 	  if test "X$xdir" = "X$arg"; then

 	    xdir=

  	  else

 	    xdir="$xdir/"

 	  fi

 	  if test "$pic_object" != none; then

 	    # Prepend the subdirectory the object is found in.

 	    pic_object="$xdir$pic_object"

 	    if test "$prev" = dlfiles; then

 	      if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then

 		dlfiles="$dlfiles $pic_object"

 		prev=

 		continue

 	      else

 		# If libtool objects are unsupported, then we need to preload.

 		prev=dlprefiles

 	      fi

 	    fi

 	    # CHECK ME:  I think I busted this.  -Ossama

 	    if test "$prev" = dlprefiles; then

 	      # Preload the old-style object.

 	      dlprefiles="$dlprefiles $pic_object"

 	      prev=

 	    fi

 	    # A PIC object.

 	    libobjs="$libobjs $pic_object"

 	    arg="$pic_object"

 	  fi

 	  # Non-PIC object.

 	  if test "$non_pic_object" != none; then

 	    # Prepend the subdirectory the object is found in.

 	    non_pic_object="$xdir$non_pic_object"

 	    # A standard non-PIC object

 	    non_pic_objects="$non_pic_objects $non_pic_object"

 	    if test -z "$pic_object" || test "$pic_object" = none ; then

 	      arg="$non_pic_object"

 	    fi

 	  fi

 	else

 	  # Only an error if not doing a dry-run.

 	  if test -z "$run"; then

 	    $echo "$modename: \`$arg' is not a valid libtool object" 1>&2

 	    exit $EXIT_FAILURE

 	  else

 	    # Dry-run case.

 	    # Extract subdirectory from the argument.

 	    xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`

 	    if test "X$xdir" = "X$arg"; then

 	      xdir=

 	    else

 	      xdir="$xdir/"

 	    fi

 	    pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`

 	    non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`

 	    libobjs="$libobjs $pic_object"

 	    non_pic_objects="$non_pic_objects $non_pic_object"

 	  fi

 	fi

 	;;

       *.$libext)

 	# An archive.

 	deplibs="$deplibs $arg"

 	old_deplibs="$old_deplibs $arg"

 	continue

 	;;

       *.la)

 	# A libtool-controlled library.

 	if test "$prev" = dlfiles; then

 	  # This library was specified with -dlopen.

 	  dlfiles="$dlfiles $arg"

 	  prev=

 	elif test "$prev" = dlprefiles; then

 	  # The library was specified with -dlpreopen.

 	  dlprefiles="$dlprefiles $arg"

 	  prev=

 	else

 	  deplibs="$deplibs $arg"

 	fi

 	continue

 	;;

       # Some other compiler argument.

       *)

 	# Unknown arguments in both finalize_command and compile_command need

 	# to be aesthetically quoted because they are evaled later.

 	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`

 	case $arg in

 	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

 	  arg="\"$arg\""

 	  ;;

 	esac

 	;;

       esac # arg

       # Now actually substitute the argument into the commands.

       if test -n "$arg"; then

 	compile_command="$compile_command $arg"

 	finalize_command="$finalize_command $arg"

       fi

     done # argument parsing loop

     if test -n "$prev"; then

       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2

       $echo "$help" 1>&2

       exit $EXIT_FAILURE

     fi

     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then

       eval arg=\"$export_dynamic_flag_spec\"

       compile_command="$compile_command $arg"

       finalize_command="$finalize_command $arg"

     fi

     oldlibs=

     # calculate the name of the file, without its directory

     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`

     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\'\`

     else

       shlib_search_path=

     fi

     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"

     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"

     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`

     if test "X$output_objdir" = "X$output"; then

       output_objdir="$objdir"

     else

       output_objdir="$output_objdir/$objdir"

     fi

     # Create the object directory.

     if test ! -d "$output_objdir"; then

       $show "$mkdir $output_objdir"

       $run $mkdir $output_objdir

       status=$?

       if test "$status" -ne 0 && test ! -d "$output_objdir"; then

 	exit $status

       fi

     fi

     # Determine the type of output

     case $output in

     "")

       $echo "$modename: you must specify an output file" 1>&2

       $echo "$help" 1>&2

       exit $EXIT_FAILURE

       ;;

     *.$libext) linkmode=oldlib ;;

     *.lo | *.$objext) linkmode=obj ;;

     *.la) linkmode=lib ;;

     *) linkmode=prog ;; # Anything else should be a program.

     esac

     case $host in

     *cygwin* | *mingw* | *pw32*)

       # don't eliminate duplications in $postdeps and $predeps

       duplicate_compiler_generated_deps=yes

       ;;

     *)

       duplicate_compiler_generated_deps=$duplicate_deps

       ;;

     esac

     specialdeplibs=

     libs=

     # Find all interdependent deplibs by searching for libraries

     # that are linked more than once (e.g. -la -lb -la)

     for deplib in $deplibs; do

       if test "X$duplicate_deps" = "Xyes" ; then

 	case "$libs " in

 	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

 	esac

       fi

       libs="$libs $deplib"

     done

     if test "$linkmode" = lib; then

       libs="$predeps $libs $compiler_lib_search_path $postdeps"

       # Compute libraries that are listed more than once in $predeps

       # $postdeps and mark them as special (i.e., whose duplicates are

       # not to be eliminated).

       pre_post_deps=

       if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then

 	for pre_post_dep in $predeps $postdeps; do

 	  case "$pre_post_deps " in

 	  *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;

 	  esac

 	  pre_post_deps="$pre_post_deps $pre_post_dep"

 	done

       fi

       pre_post_deps=

     fi

     deplibs=

     newdependency_libs=

     newlib_search_path=

     need_relink=no # whether we're linking any uninstalled libtool libraries

     notinst_deplibs= # not-installed libtool libraries

     notinst_path= # paths that contain not-installed libtool libraries

     case $linkmode in

     lib)

 	passes="conv link"

 	for file in $dlfiles $dlprefiles; do

 	  case $file in

 	  *.la) ;;

 	  *)

 	    $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2

 	    exit $EXIT_FAILURE

 	    ;;

 	  esac

 	done

 	;;

     prog)

 	compile_deplibs=

 	finalize_deplibs=

 	alldeplibs=no

 	newdlfiles=

 	newdlprefiles=

 	passes="conv scan dlopen dlpreopen link"

 	;;

     *)  passes="conv"

 	;;

     esac

     for pass in $passes; do

       if test "$linkmode,$pass" = "lib,link" ||

 	 test "$linkmode,$pass" = "prog,scan"; then

 	libs="$deplibs"

 	deplibs=

       fi

       if test "$linkmode" = prog; then

 	case $pass in

 	dlopen) libs="$dlfiles" ;;

 	dlpreopen) libs="$dlprefiles" ;;

 	link)

 	  libs="$deplibs %DEPLIBS%"

 	  test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"

 	  ;;

 	esac

       fi

       if test "$pass" = dlopen; then

 	# Collect dlpreopened libraries

 	save_deplibs="$deplibs"

 	deplibs=

       fi

       for deplib in $libs; do

 	lib=

 	found=no

 	case $deplib in

 	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)

 	  if test "$linkmode,$pass" = "prog,link"; then

 	    compile_deplibs="$deplib $compile_deplibs"

 	    finalize_deplibs="$deplib $finalize_deplibs"

 	  else

 	    deplibs="$deplib $deplibs"

 	  fi

 	  continue

 	  ;;

 	-l*)

 	  if test "$linkmode" != lib && test "$linkmode" != prog; then

 	    $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2

 	    continue

 	  fi

 	  name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`

 	  for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do

 	    for search_ext in .la $std_shrext .so .a; do

 	      # Search the libtool library

 	      lib="$searchdir/lib${name}${search_ext}"

 	      if test -f "$lib"; then

 		if test "$search_ext" = ".la"; then

 		  found=yes

 		else

 		  found=no

 		fi

 		break 2

 	      fi

 	    done

 	  done

 	  if test "$found" != yes; then

 	    # deplib doesn't seem to be a libtool library

 	    if test "$linkmode,$pass" = "prog,link"; then

 	      compile_deplibs="$deplib $compile_deplibs"

 	      finalize_deplibs="$deplib $finalize_deplibs"

 	    else

 	      deplibs="$deplib $deplibs"

 	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

 	    fi

 	    continue

 	  else # deplib is a libtool library

 	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,

 	    # We need to do some special things here, and not later.

 	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

 	      case " $predeps $postdeps " in

 	      *" $deplib "*)

 		if (${SED} -e '2q' $lib |

                     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

 		  library_names=

 		  old_library=

 		  case $lib in

 		  */* | *\\*) . $lib ;;

 		  *) . ./$lib ;;

 		  esac

 		  for l in $old_library $library_names; do

 		    ll="$l"

 		  done

 		  if test "X$ll" = "X$old_library" ; then # only static version available

 		    found=no

 		    ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`

 		    test "X$ladir" = "X$lib" && ladir="."

 		    lib=$ladir/$old_library

 		    if test "$linkmode,$pass" = "prog,link"; then

 		      compile_deplibs="$deplib $compile_deplibs"

 		      finalize_deplibs="$deplib $finalize_deplibs"

 		    else

 		      deplibs="$deplib $deplibs"

 		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

 		    fi

 		    continue

 		  fi

 		fi

 	        ;;

 	      *) ;;

 	      esac

 	    fi

 	  fi

 	  ;; # -l

 	-L*)

 	  case $linkmode in

 	  lib)

 	    deplibs="$deplib $deplibs"

 	    test "$pass" = conv && continue

 	    newdependency_libs="$deplib $newdependency_libs"

 	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`

 	    ;;

 	  prog)

 	    if test "$pass" = conv; then

 	      deplibs="$deplib $deplibs"

 	      continue

 	    fi

 	    if test "$pass" = scan; then

 	      deplibs="$deplib $deplibs"

 	    else

 	      compile_deplibs="$deplib $compile_deplibs"

 	      finalize_deplibs="$deplib $finalize_deplibs"

 	    fi

 	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`

 	    ;;

 	  *)

 	    $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2

 	    ;;

 	  esac # linkmode

 	  continue

 	  ;; # -L

 	-R*)

 	  if test "$pass" = link; then

 	    dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`

 	    # Make sure the xrpath contains only unique directories.

 	    case "$xrpath " in

 	    *" $dir "*) ;;

 	    *) xrpath="$xrpath $dir" ;;

 	    esac

 	  fi

 	  deplibs="$deplib $deplibs"

 	  continue

 	  ;;

 	*.la) lib="$deplib" ;;

 	*.$libext)

 	  if test "$pass" = conv; then

 	    deplibs="$deplib $deplibs"

 	    continue

 	  fi

 	  case $linkmode in

 	  lib)

 	    if test "$deplibs_check_method" != pass_all; then

 	      $echo

 	      $echo "*** Warning: Trying to link with static lib archive $deplib."

 	      $echo "*** I have the capability to make that library automatically link in when"

 	      $echo "*** you link to this library.  But I can only do this if you have a"

 	      $echo "*** shared version of the library, which you do not appear to have"

 	      $echo "*** because the file extensions .$libext of this argument makes me believe"

 	      $echo "*** that it is just a static archive that I should not used here."

 	    else

 	      $echo

 	      $echo "*** Warning: Linking the shared library $output against the"

 	      $echo "*** static library $deplib is not portable!"

 	      deplibs="$deplib $deplibs"

 	    fi

 	    continue

 	    ;;

 	  prog)

 	    if test "$pass" != link; then

 	      deplibs="$deplib $deplibs"

 	    else

 	      compile_deplibs="$deplib $compile_deplibs"

 	      finalize_deplibs="$deplib $finalize_deplibs"

 	    fi

 	    continue

 	    ;;

 	  esac # linkmode

 	  ;; # *.$libext

 	*.lo | *.$objext)

 	  if test "$pass" = conv; then

 	    deplibs="$deplib $deplibs"

 	  elif test "$linkmode" = prog; then

 	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then

 	      # If there is no dlopen support or we're linking statically,

 	      # we need to preload.

 	      newdlprefiles="$newdlprefiles $deplib"

 	      compile_deplibs="$deplib $compile_deplibs"

 	      finalize_deplibs="$deplib $finalize_deplibs"

 	    else

 	      newdlfiles="$newdlfiles $deplib"

 	    fi

 	  fi

 	  continue

 	  ;;

 	%DEPLIBS%)

 	  alldeplibs=yes

 	  continue

 	  ;;

 	esac # case $deplib

 	if test "$found" = yes || test -f "$lib"; then :

 	else

 	  $echo "$modename: cannot find the library \`$lib'" 1>&2

 	  exit $EXIT_FAILURE

 	fi

 	# Check to see that this really is a libtool archive.

 	if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :

 	else

 	  $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2

 	  exit $EXIT_FAILURE

 	fi

 	ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`

 	test "X$ladir" = "X$lib" && ladir="."

 	dlname=

 	dlopen=

 	dlpreopen=

 	libdir=

 	library_names=

 	old_library=

 	# If the library was installed with an old release of libtool,

 	# it will not redefine variables installed, or shouldnotlink

 	installed=yes

 	shouldnotlink=no

 	# Read the .la file

 	case $lib in

 	*/* | *\\*) . $lib ;;

 	*) . ./$lib ;;

 	esac

 	if test "$linkmode,$pass" = "lib,link" ||

 	   test "$linkmode,$pass" = "prog,scan" ||

 	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then

 	  test -n "$dlopen" && dlfiles="$dlfiles $dlopen"

 	  test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"

 	fi

 	if test "$pass" = conv; then

 	  # Only check for convenience libraries

 	  deplibs="$lib $deplibs"

 	  if test -z "$libdir"; then

 	    if test -z "$old_library"; then

 	      $echo "$modename: cannot find name of link library for \`$lib'" 1>&2

 	      exit $EXIT_FAILURE

 	    fi

 	    # It is a libtool convenience library, so add in its objects.

 	    convenience="$convenience $ladir/$objdir/$old_library"

 	    old_convenience="$old_convenience $ladir/$objdir/$old_library"

 	    tmp_libs=

 	    for deplib in $dependency_libs; do

 	      deplibs="$deplib $deplibs"

               if test "X$duplicate_deps" = "Xyes" ; then

 	        case "$tmp_libs " in

 	        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

 	        esac

               fi

 	      tmp_libs="$tmp_libs $deplib"

 	    done

 	  elif test "$linkmode" != prog && test "$linkmode" != lib; then

 	    $echo "$modename: \`$lib' is not a convenience library" 1>&2

 	    exit $EXIT_FAILURE

 	  fi

 	  continue

 	fi # $pass = conv

 	# Get the name of the library we link against.

 	linklib=

 	for l in $old_library $library_names; do

 	  linklib="$l"

 	done

 	if test -z "$linklib"; then

 	  $echo "$modename: cannot find name of link library for \`$lib'" 1>&2

 	  exit $EXIT_FAILURE

 	fi

 	# This library was specified with -dlopen.

 	if test "$pass" = dlopen; then

 	  if test -z "$libdir"; then

 	    $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2

 	    exit $EXIT_FAILURE

 	  fi

 	  if test -z "$dlname" ||

 	     test "$dlopen_support" != yes ||

 	     test "$build_libtool_libs" = no; then

 	    # If there is no dlname, no dlopen support or we're linking

 	    # statically, we need to preload.  We also need to preload any

 	    # dependent libraries so libltdl's deplib preloader doesn't

 	    # bomb out in the load deplibs phase.

 	    dlprefiles="$dlprefiles $lib $dependency_libs"

 	  else

 	    newdlfiles="$newdlfiles $lib"

 	  fi

 	  continue

 	fi # $pass = dlopen

 	# We need an absolute path.

 	case $ladir in

 	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;

 	*)

 	  abs_ladir=`cd "$ladir" && pwd`

 	  if test -z "$abs_ladir"; then

 	    $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2

 	    $echo "$modename: passing it literally to the linker, although it might fail" 1>&2

 	    abs_ladir="$ladir"

 	  fi

 	  ;;

 	esac

 	laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`

 	# Find the relevant object directory and library name.

 	if test "X$installed" = Xyes; then

 	  if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then

 	    $echo "$modename: warning: library \`$lib' was moved." 1>&2

 	    dir="$ladir"

 	    absdir="$abs_ladir"

 	    libdir="$abs_ladir"

 	  else

 	    dir="$libdir"

 	    absdir="$libdir"

 	  fi

 	else

 	  dir="$ladir/$objdir"

 	  absdir="$abs_ladir/$objdir"

 	  # Remove this search path later

 	  notinst_path="$notinst_path $abs_ladir"

 	fi # $installed = yes

 	name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`

 	# This library was specified with -dlpreopen.

 	if test "$pass" = dlpreopen; then

 	  if test -z "$libdir"; then

 	    $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2

 	    exit $EXIT_FAILURE

 	  fi

 	  # Prefer using a static library (so that no silly _DYNAMIC symbols

 	  # are required to link).

 	  if test -n "$old_library"; then

 	    newdlprefiles="$newdlprefiles $dir/$old_library"

 	  # Otherwise, use the dlname, so that lt_dlopen finds it.

 	  elif test -n "$dlname"; then

 	    newdlprefiles="$newdlprefiles $dir/$dlname"

 	  else

 	    newdlprefiles="$newdlprefiles $dir/$linklib"

 	  fi

 	fi # $pass = dlpreopen

 	if test -z "$libdir"; then

 	  # Link the convenience library

 	  if test "$linkmode" = lib; then

 	    deplibs="$dir/$old_library $deplibs"

 	  elif test "$linkmode,$pass" = "prog,link"; then

 	    compile_deplibs="$dir/$old_library $compile_deplibs"

 	    finalize_deplibs="$dir/$old_library $finalize_deplibs"

 	  else

 	    deplibs="$lib $deplibs" # used for prog,scan pass

 	  fi

 	  continue

 	fi

 	if test "$linkmode" = prog && test "$pass" != link; then

 	  newlib_search_path="$newlib_search_path $ladir"

 	  deplibs="$lib $deplibs"

 	  linkalldeplibs=no

 	  if test "$link_all_deplibs" != no || test -z "$library_names" ||

 	     test "$build_libtool_libs" = no; then

 	    linkalldeplibs=yes

 	  fi

 	  tmp_libs=

 	  for deplib in $dependency_libs; do

 	    case $deplib in

 	    -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test

 	    esac

 	    # Need to link against all dependency_libs?

 	    if test "$linkalldeplibs" = yes; then

 	      deplibs="$deplib $deplibs"

 	    else

 	      # Need to hardcode shared library paths

 	      # or/and link against static libraries

 	      newdependency_libs="$deplib $newdependency_libs"

 	    fi

 	    if test "X$duplicate_deps" = "Xyes" ; then

 	      case "$tmp_libs " in

 	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

 	      esac

 	    fi

 	    tmp_libs="$tmp_libs $deplib"

 	  done # for deplib

 	  continue

 	fi # $linkmode = prog...

 	if test "$linkmode,$pass" = "prog,link"; then

 	  if test -n "$library_names" &&

 	     { test "$prefer_static_libs" = no || test -z "$old_library"; }; then

 	    # We need to hardcode the library path

 	    if test -n "$shlibpath_var"; then

 	      # Make sure the rpath contains only unique directories.

 	      case "$temp_rpath " in

 	      *" $dir "*) ;;

 	      *" $absdir "*) ;;

 	      *) temp_rpath="$temp_rpath $dir" ;;

 	      esac

 	    fi

 	    # Hardcode the library path.

 	    # Skip directories that are in the system default run-time

 	    # search path.

 	    case " $sys_lib_dlsearch_path " in

 	    *" $absdir "*) ;;

 	    *)

 	      case "$compile_rpath " in

 	      *" $absdir "*) ;;

 	      *) compile_rpath="$compile_rpath $absdir"

 	      esac

 	      ;;

 	    esac

 	    case " $sys_lib_dlsearch_path " in

 	    *" $libdir "*) ;;

 	    *)

 	      case "$finalize_rpath " in

 	      *" $libdir "*) ;;

 	      *) finalize_rpath="$finalize_rpath $libdir"

 	      esac

 	      ;;

 	    esac

 	  fi # $linkmode,$pass = prog,link...

 	  if test "$alldeplibs" = yes &&

 	     { test "$deplibs_check_method" = pass_all ||

 	       { test "$build_libtool_libs" = yes &&

 		 test -n "$library_names"; }; }; then

 	    # We only need to search for static libraries

 	    continue

 	  fi

 	fi

 	link_static=no # Whether the deplib will be linked statically

 	if test -n "$library_names" &&

 	   { test "$prefer_static_libs" = no || test -z "$old_library"; }; then

 	  if test "$installed" = no; then

 	    notinst_deplibs="$notinst_deplibs $lib"

 	    need_relink=yes

 	  fi

 	  # This is a shared library

 	  # Warn about portability, can't link against -module's on

 	  # some systems (darwin)

 	  if test "$shouldnotlink" = yes && test "$pass" = link ; then

 	    $echo

 	    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

 	    $echo "*** $linklib is not portable!"

 	  fi

 	  if test "$linkmode" = lib &&

 	     test "$hardcode_into_libs" = yes; then

 	    # Hardcode the library path.

 	    # Skip directories that are in the system default run-time

 	    # search path.

 	    case " $sys_lib_dlsearch_path " in

 	    *" $absdir "*) ;;

 	    *)

 	      case "$compile_rpath " in

 	      *" $absdir "*) ;;

 	      *) compile_rpath="$compile_rpath $absdir"

 	      esac

 	      ;;

 	    esac

 	    case " $sys_lib_dlsearch_path " in

 	    *" $libdir "*) ;;

 	    *)

 	      case "$finalize_rpath " in

 	      *" $libdir "*) ;;

 	      *) finalize_rpath="$finalize_rpath $libdir"

 	      esac

 	      ;;

 	    esac

 	  fi

 	  if test -n "$old_archive_from_expsyms_cmds"; then

 	    # figure out the soname

 	    set dummy $library_names

 	    realname="$2"

 	    shift; shift

 	    libname=`eval \\$echo \"$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

 	      case $host in

 	      *cygwin* | mingw*)

 		major=`expr $current - $age`

 		versuffix="-$major"

 		;;

 	      esac

 	      eval soname=\"$soname_spec\"

 	    else

 	      soname="$realname"

 	    fi

 	    # Make a new name for the extract_expsyms_cmds to use

 	    soroot="$soname"

 	    soname=`$echo $soroot | ${SED} -e 's/^.*\///'`

 	    newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"

 	    # If the library has no export list, then create one now

 	    if test -f "$output_objdir/$soname-def"; then :

 	    else

 	      $show "extracting exported symbol list from \`$soname'"

 	      save_ifs="$IFS"; IFS='~'

 	      cmds=$extract_expsyms_cmds

 	      for cmd in $cmds; do

 		IFS="$save_ifs"

 		eval cmd=\"$cmd\"

 		$show "$cmd"

 		$run eval "$cmd" || exit $?

 	      done

 	      IFS="$save_ifs"

 	    fi

 	    # Create $newlib

 	    if test -f "$output_objdir/$newlib"; then :; else

 	      $show "generating import library for \`$soname'"

 	      save_ifs="$IFS"; IFS='~'

 	      cmds=$old_archive_from_expsyms_cmds

 	      for cmd in $cmds; do

 		IFS="$save_ifs"

 		eval cmd=\"$cmd\"

 		$show "$cmd"

 		$run eval "$cmd" || exit $?

 	      done

 	      IFS="$save_ifs"

 	    fi

 	    # make sure the library variables are pointing to the new library

 	    dir=$output_objdir

 	    linklib=$newlib

 	  fi # test -n "$old_archive_from_expsyms_cmds"

 	  if test "$linkmode" = prog || test "$mode" != relink; then

 	    add_shlibpath=

 	    add_dir=

 	    add=

 	    lib_linked=yes

 	    case $hardcode_action in

 	    immediate | unsupported)

 	      if test "$hardcode_direct" = no; then

 		add="$dir/$linklib"

 		case $host in

 		  *-*-sco3.2v5* ) add_dir="-L$dir" ;;

 		  *-*-darwin* )

 		    # if the lib is a module then we can not link against

 		    # it, someone is ignoring the new warnings I added

 		    if /usr/bin/file -L $add 2> /dev/null | $EGREP "bundle" >/dev/null ; then

 		      $echo "** Warning, lib $linklib is a module, not a shared library"

 		      if test -z "$old_library" ; then

 		        $echo

 		        $echo "** And there doesn't seem to be a static archive available"

 		        $echo "** The link will probably fail, sorry"

 		      else

 		        add="$dir/$old_library"

 		      fi

 		    fi

 		esac

 	      elif test "$hardcode_minus_L" = no; then

 		case $host in

 		*-*-sunos*) add_shlibpath="$dir" ;;

 		esac

 		add_dir="-L$dir"

 		add="-l$name"

 	      elif test "$hardcode_shlibpath_var" = no; then

 		add_shlibpath="$dir"

 		add="-l$name"

 	      else

 		lib_linked=no

 	      fi

 	      ;;

 	    relink)

 	      if test "$hardcode_direct" = yes; then

 		add="$dir/$linklib"

 	      elif test "$hardcode_minus_L" = yes; then

 		add_dir="-L$dir"

 		# Try looking first in the location we're being installed to.

 		if test -n "$inst_prefix_dir"; then

 		  case "$libdir" in

 		    [\\/]*)

 		      add_dir="$add_dir -L$inst_prefix_dir$libdir"

 		      ;;

 		  esac

 		fi

 		add="-l$name"

 	      elif test "$hardcode_shlibpath_var" = yes; then

 		add_shlibpath="$dir"

 		add="-l$name"

 	      else

 		lib_linked=no

 	      fi

 	      ;;

 	    *) lib_linked=no ;;

 	    esac

 	    if test "$lib_linked" != yes; then

 	      $echo "$modename: configuration error: unsupported hardcode properties"

 	      exit $EXIT_FAILURE

 	    fi

 	    if test -n "$add_shlibpath"; then

 	      case :$compile_shlibpath: in

 	      *":$add_shlibpath:"*) ;;

 	      *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;

 	      esac

 	    fi

 	    if test "$linkmode" = prog; then

 	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"

 	      test -n "$add" && compile_deplibs="$add $compile_deplibs"

 	    else

 	      test -n "$add_dir" && deplibs="$add_dir $deplibs"

 	      test -n "$add" && deplibs="$add $deplibs"

 	      if test "$hardcode_direct" != yes && \

 		 test "$hardcode_minus_L" != yes && \

 		 test "$hardcode_shlibpath_var" = yes; then

 		case :$finalize_shlibpath: in

 		*":$libdir:"*) ;;

 		*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;

 		esac

 	      fi

 	    fi

 	  fi

 	  if test "$linkmode" = prog || test "$mode" = relink; then

 	    add_shlibpath=

 	    add_dir=

 	    add=

 	    # Finalize command for both is simple: just hardcode it.

 	    if test "$hardcode_direct" = yes; then

 	      add="$libdir/$linklib"

 	    elif test "$hardcode_minus_L" = yes; then

 	      add_dir="-L$libdir"

 	      add="-l$name"

 	    elif test "$hardcode_shlibpath_var" = yes; then

 	      case :$finalize_shlibpath: in

 	      *":$libdir:"*) ;;

 	      *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;

 	      esac

 	      add="-l$name"

 	    elif test "$hardcode_automatic" = yes; then

 	      if test -n "$inst_prefix_dir" &&

 		 test -f "$inst_prefix_dir$libdir/$linklib" ; then

 	        add="$inst_prefix_dir$libdir/$linklib"

 	      else

 	        add="$libdir/$linklib"

 	      fi

 	    else

 	      # We cannot seem to hardcode it, guess we'll fake it.

 	      add_dir="-L$libdir"

 	      # Try looking first in the location we're being installed to.

 	      if test -n "$inst_prefix_dir"; then

 		case "$libdir" in

 		  [\\/]*)

 		    add_dir="$add_dir -L$inst_prefix_dir$libdir"

 		    ;;

 		esac

 	      fi

 	      add="-l$name"

 	    fi

 	    if test "$linkmode" = prog; then

 	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"

 	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"

 	    else

 	      test -n "$add_dir" && deplibs="$add_dir $deplibs"

 	      test -n "$add" && deplibs="$add $deplibs"

 	    fi

 	  fi

 	elif test "$linkmode" = prog; then

 	  # Here we assume that one of hardcode_direct or hardcode_minus_L

 	  # is not unsupported.  This is valid on all known static and

 	  # shared platforms.

 	  if test "$hardcode_direct" != unsupported; then

 	    test -n "$old_library" && linklib="$old_library"

 	    compile_deplibs="$dir/$linklib $compile_deplibs"

 	    finalize_deplibs="$dir/$linklib $finalize_deplibs"

 	  else

 	    compile_deplibs="-l$name -L$dir $compile_deplibs"

 	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"

 	  fi

 	elif test "$build_libtool_libs" = yes; then

 	  # Not a shared library

 	  if test "$deplibs_check_method" != pass_all; then

 	    # 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 "*** 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 "*** 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."

 	    if test "$module" = yes; then

 	      $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 "*** is linked with the -dlopen flag to resolve symbols at runtime."

 	      if test -z "$global_symbol_pipe"; then

 		$echo

 		$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 "*** not find such a program.  So, this module is probably useless."

 		$echo "*** \`nm' from GNU binutils and a full rebuild may help."

 	      fi

 	      if test "$build_old_libs" = no; then

 		build_libtool_libs=module

 		build_old_libs=yes

 	      else

 		build_libtool_libs=no

 	      fi

 	    fi

 	  else

 	    convenience="$convenience $dir/$old_library"

 	    old_convenience="$old_convenience $dir/$old_library"

 	    deplibs="$dir/$old_library $deplibs"

 	    link_static=yes

 	  fi

 	fi # link shared/static library?

 	if test "$linkmode" = lib; then

 	  if test -n "$dependency_libs" &&

 	     { test "$hardcode_into_libs" != yes ||

 	       test "$build_old_libs" = yes ||

 	       test "$link_static" = yes; }; then

 	    # Extract -R from dependency_libs

 	    temp_deplibs=

 	    for libdir in $dependency_libs; do

 	      case $libdir in

 	      -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`

 		   case " $xrpath " in

 		   *" $temp_xrpath "*) ;;

 		   *) xrpath="$xrpath $temp_xrpath";;

 		   esac;;

 	      *) temp_deplibs="$temp_deplibs $libdir";;

 	      esac

 	    done

 	    dependency_libs="$temp_deplibs"

 	  fi

 	  newlib_search_path="$newlib_search_path $absdir"

 	  # Link against this library

 	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"

 	  # ... and its dependency_libs

 	  tmp_libs=

 	  for deplib in $dependency_libs; do

 	    newdependency_libs="$deplib $newdependency_libs"

 	    if test "X$duplicate_deps" = "Xyes" ; then

 	      case "$tmp_libs " in

 	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

 	      esac

 	    fi

 	    tmp_libs="$tmp_libs $deplib"

 	  done

 	  if test "$link_all_deplibs" != no; then

 	    # Add the search paths of all dependency libraries

 	    for deplib in $dependency_libs; do

 	      case $deplib in

 	      -L*) path="$deplib" ;;

 	      *.la)

 		dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`

 		test "X$dir" = "X$deplib" && dir="."

 		# We need an absolute path.

 		case $dir in

 		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;

 		*)

 		  absdir=`cd "$dir" && pwd`

 		  if test -z "$absdir"; then

 		    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2

 		    absdir="$dir"

 		  fi

 		  ;;

 		esac

 		if grep "^installed=no" $deplib > /dev/null; then

 		  path="$absdir/$objdir"

 		else

 		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`

 		  if test -z "$libdir"; then

 		    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2

 		    exit $EXIT_FAILURE

 		  fi

 		  if test "$absdir" != "$libdir"; then

 		    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2

 		  fi

 		  path="$absdir"

 		fi

 		depdepl=

 		case $host in

 		*-*-darwin*)

 		  # we do not want to link against static libs,

 		  # but need to link against shared

 		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`

 		  if test -n "$deplibrary_names" ; then

 		    for tmp in $deplibrary_names ; do

 		      depdepl=$tmp

 		    done

 		    if test -f "$path/$depdepl" ; then

 		      depdepl="$path/$depdepl"

 		    fi

 		    # do not add paths which are already there

 		    case " $newlib_search_path " in

 		    *" $path "*) ;;

 		    *) newlib_search_path="$newlib_search_path $path";;

 		    esac

 		  fi

 		  path=""

 		  ;;

 		*)

 		  path="-L$path"

 		  ;;

 		esac