# 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, 2005

 # 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 #

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

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

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

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

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

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

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

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

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

 # function.

 progpath="$0"

 # 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.20

 TIMESTAMP=" (1.1220.2.287 2005/08/31 18:54:15)"

 # See if we are running on zsh, and set the options which allow our

 # commands through without removal of \ escapes.

 if test -n "${ZSH_VERSION+set}" ; then

   setopt NO_GLOB_SUBST

 fi

 # 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 X|tr X '\101'` in

  A) # ASCII based system

     # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr

   SP2NL='tr \040 \012'

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

   ;;

  *) # EBCDIC based system

   SP2NL='tr \100 \n'

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

   ;;

 esac

 # NLS nuisances.

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

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

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

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

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

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

 fi

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

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

 fi

 # Make sure IFS has a sensible default

 lt_nl='

 '

 IFS=" 	$lt_nl"

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

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

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

   exit $EXIT_FAILURE

 fi

 # Global variables.

 mode=$default_mode

 nonopt=

 prev=

 prevopt=

 run=

 show="$echo"

 show_help=

 execute_dlfiles=

 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

 }

 # func_extract_an_archive dir oldlib

 func_extract_an_archive ()

 {

     f_ex_an_ar_dir="$1"; shift

     f_ex_an_ar_oldlib="$1"

     $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"

     $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?

     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then

      :

     else

       $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2

       exit $EXIT_FAILURE

     fi

 }

 # func_extract_archives gentop oldlib ...

 func_extract_archives ()

 {

     my_gentop="$1"; shift

     my_oldlibs=${1+"$@"}

     my_oldobjs=""

     my_xlib=""

     my_xabs=""

     my_xdir=""

     my_status=""

     $show "${rm}r $my_gentop"

     $run ${rm}r "$my_gentop"

     $show "$mkdir $my_gentop"

     $run $mkdir "$my_gentop"

     my_status=$?

     if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then

       exit $my_status

     fi

     for my_xlib in $my_oldlibs; do

       # Extract the objects.

       case $my_xlib in

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

 	*) my_xabs=`pwd`"/$my_xlib" ;;

       esac

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

       my_xdir="$my_gentop/$my_xlib"

       $show "${rm}r $my_xdir"

       $run ${rm}r "$my_xdir"

       $show "$mkdir $my_xdir"

       $run $mkdir "$my_xdir"

       status=$?

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

 	exit $status

       fi

       case $host in

       *-darwin*)

 	$show "Extracting $my_xabs"

 	# Do not bother doing anything if just a dry run

 	if test -z "$run"; then

 	  darwin_orig_dir=`pwd`

 	  cd $my_xdir || exit $?

 	  darwin_archive=$my_xabs

 	  darwin_curdir=`pwd`

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

 	  darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`

 	  if test -n "$darwin_arches"; then 

 	    darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`

 	    darwin_arch=

 	    $show "$darwin_base_archive has multiple architectures $darwin_arches"

 	    for darwin_arch in  $darwin_arches ; do

 	      mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"

 	      lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"

 	      cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"

 	      func_extract_an_archive "`pwd`" "${darwin_base_archive}"

 	      cd "$darwin_curdir"

 	      $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"

 	    done # $darwin_arches

       ## Okay now we have a bunch of thin objects, gotta fatten them up :)

 	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`

 	    darwin_file=

 	    darwin_files=

 	    for darwin_file in $darwin_filelist; do

 	      darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`

 	      lipo -create -output "$darwin_file" $darwin_files

 	    done # $darwin_filelist

 	    ${rm}r unfat-$$

 	    cd "$darwin_orig_dir"

 	  else

 	    cd "$darwin_orig_dir"

  	    func_extract_an_archive "$my_xdir" "$my_xabs"

 	  fi # $darwin_arches

 	fi # $run

 	;;

       *)

         func_extract_an_archive "$my_xdir" "$my_xabs"

         ;;

       esac

       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`

     done

     func_extract_archives_result="$my_oldobjs"

 }

 # End of Shell function definitions

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

 # Darwin sucks

 eval std_shrext=\"$shrext_cmds\"

 # 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) 2005  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 $?

     ;;

   --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 $?

     ;;

   --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 $?

     ;;

   --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, and some SunOS ksh mistreat backslash-escaping

       # in scan sets (worked around with variable expansion),

       # and furthermore cannot handle '|' '&' '(' ')' in scan sets 

       # at all, so we specify them separately.

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

 	lastarg="\"$lastarg\""

 	;;

       esac

       base_compile="$base_compile $lastarg"

     done # for arg

     case $arg_mode in

     arg)

       $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

     qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`

     case $qlibobj in

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

 	qlibobj="\"$qlibobj\"" ;;

     esac

     test "X$libobj" != "X$qlibobj" \

 	&& $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"' 	&()|`$[]' \

 	&& $echo "$modename: libobj name \`$libobj' may not contain shell special characters."

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

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

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

       xdir=

     else

       xdir=$xdir/

     fi

     lobj=${xdir}$objdir/$objname

     if test -z "$base_compile"; then

       $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

     qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`

     case $qsrcfile in

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

       qsrcfile="\"$qsrcfile\"" ;;

     esac

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

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

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

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

 # $libobj - a libtool object file

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

 #

 # Please DO NOT delete this file!

 # It is necessary for linking the library.

 # Name of the PIC object.

 EOF

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

     if test "$build_libtool_libs" = yes; then

       # Without this assignment, base_compile gets emptied.

       fbsd_hideous_sh_bug=$base_compile

       if test "$pic_mode" != no; then

 	command="$base_compile $qsrcfile $pic_flag"

       else

 	# Don't build PIC code

 	command="$base_compile $qsrcfile"

       fi

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

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

 	$run $mkdir ${xdir}$objdir

 	status=$?

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

 	  exit $status

 	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 $qsrcfile"

       else

 	command="$base_compile $qsrcfile $pic_flag"

       fi

       if test "$compiler_c_o" = yes; then

 	command="$command -o $obj"

       fi

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

       command="$command$suppress_output"

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

       $show "$command"

       if $run eval "$command"; then :

       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

 	  ;;

         darwin_framework)

 	  compiler_flags="$compiler_flags $arg"

 	  compile_command="$compile_command $arg"

 	  finalize_command="$finalize_command $arg"

 	  prev=

 	  continue

 	  ;;

 	*)

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

 	  prev=

 	  continue

 	  ;;

 	esac

       fi # test -n "$prev"

       prevarg="$arg"

       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

 	;;

       -framework|-arch)

         prev=darwin_framework

         compiler_flags="$compiler_flags $arg"

 	compile_command="$compile_command $arg"

 	finalize_command="$finalize_command $arg"

         continue

         ;;

       -inst-prefix-dir)

 	prev=inst_prefix

 	continue

 	;;

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

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

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

 	case $with_gcc/$host in

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

 	  compile_command="$compile_command $arg"

 	  finalize_command="$finalize_command $arg"

 	  ;;

 	esac

 	continue

 	;;

       -L*)

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

 	# We need an absolute path.

 	case $dir in

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

 	*)

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

 	  if test -z "$absdir"; then

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

 	    exit $EXIT_FAILURE

 	  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* | *-*-dragonfly*)

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

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

 	    ;;

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

 	    # Rhapsody C and math libraries are in the System framework

 	    deplibs="$deplibs -framework System"

 	    continue

 	  esac

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

 	 case $host in

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

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

 	   continue

 	   ;;

 	 esac

 	fi

 	deplibs="$deplibs $arg"

 	continue

 	;;

       # Tru64 UNIX uses -model [arg] to determine the layout of C++

       # classes, name mangling, and exception handling.

       -model)

 	compile_command="$compile_command $arg"

 	compiler_flags="$compiler_flags $arg"

 	finalize_command="$finalize_command $arg"

 	prev=xcompiler

 	continue

 	;;

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

 	compiler_flags="$compiler_flags $arg"

 	compile_command="$compile_command $arg"

 	finalize_command="$finalize_command $arg"

 	continue

 	;;

       -module)

 	module=yes

 	continue

 	;;

       # -64, -mips[0-9] enable 64-bit mode on the SGI compiler

       # -r[0-9][0-9]* specifies the processor on the SGI compiler

       # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler

       # +DA*, +DD* enable 64-bit mode on the HP compiler

       # -q* pass through compiler args for the IBM compiler

       # -m* pass through architecture-specific compiler args for GCC

       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-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% $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

 	    compiler_flags="$compiler_flags $deplib"

 	  fi

 	  continue

 	  ;;

 	-l*)

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

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

 	    continue

 	  fi

 	  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)

 	    valid_a_lib=no

 	    case $deplibs_check_method in

 	      match_pattern*)

 		set dummy $deplibs_check_method

 	        match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`

 		if eval $echo \"$deplib\" 2>/dev/null \

 		    | $SED 10q \

 		    | $EGREP "$match_pattern_regex" > /dev/null; then

 		  valid_a_lib=yes

 		fi

 		;;

 	      pass_all)

 		valid_a_lib=yes

 		;;

             esac

 	    if test "$valid_a_lib" != yes; then

 	      $echo

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

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

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

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

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

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

 	    else

 	      $echo

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

 	      $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

 	avoidtemprpath=

 	# Read the .la file

 	case $lib in

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

 	*) . ./$lib ;;

 	esac

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

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

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

 	  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

 	  test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes

 	else

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

 	    dir="$ladir"

 	    absdir="$abs_ladir"

 	    # Remove this search path later

 	    notinst_path="$notinst_path $abs_ladir"

 	  else

 	    dir="$ladir/$objdir"

 	    absdir="$abs_ladir/$objdir"

 	    # Remove this search path later

 	    notinst_path="$notinst_path $abs_ladir"

 	  fi

 	fi # $installed = yes

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

 	# This library was specified with -dlpreopen.

 	if test "$pass" = dlpreopen; then

 	  if test -z "$libdir"; then

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

 	    exit $EXIT_FAILURE

 	  fi

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

 	  # 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" && test -z "$avoidtemprpath" ; then

 	      # Make sure the rpath contains only unique directories.

 	      case "$temp_rpath " in

 	      *" $dir "*) ;;

 	      *" $absdir "*) ;;

 	      *) temp_rpath="$temp_rpath $absdir" ;;

 	      esac

 	    fi

 	    # Hardcode the library path.

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

 	    # search path.

 	    case " $sys_lib_dlsearch_path " in

 	    *" $absdir "*) ;;

 	    *)

 	      case "$compile_rpath " in

 	      *" $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