dmapi/ltmain.sh

   1 # ltmain.sh - Provide generalized library-building support services.
   2 # NOTE: Changing this file will not affect anything until you rerun configure.
   3 #
   4 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004
   5 # Free Software Foundation, Inc.
   6 # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful, but
  14 # WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 # General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program; if not, write to the Free Software
  20 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21 #
  22 # As a special exception to the GNU General Public License, if you
  23 # distribute this file as part of a program that contains a
  24 # configuration script generated by Autoconf, you may include it under
  25 # the same distribution terms that you use for the rest of that program.
  26
  27 basename="s,^.*/,,g"
  28
  29 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
  30 # is ksh but when the shell is invoked as "sh" and the current value of
  31 # the _XPG environment variable is not equal to 1 (one), the special
  32 # positional parameter $0, within a function call, is the name of the
  33 # function.
  34 progpath="$0"
  35
  36 # The name of this program:
  37 progname=`echo "$progpath" | $SED $basename`
  38 modename="$progname"
  39
  40 # Global variables:
  41 EXIT_SUCCESS=0
  42 EXIT_FAILURE=1
  43
  44 PROGRAM=ltmain.sh
  45 PACKAGE=libtool
  46 VERSION=1.5.8
  47 TIMESTAMP=" (1.1220.2.118 2004/08/07 12:24:38)"
  48
  49 # See if we are running on zsh, and set the options which allow our
  50 # commands through without removal of \ escapes.
  51 if test -n "${ZSH_VERSION+set}" ; then
  52   setopt NO_GLOB_SUBST
  53 fi
  54
  55 # Check that we have a working $echo.
  56 if test "X$1" = X--no-reexec; then
  57   # Discard the --no-reexec flag, and continue.
  58   shift
  59 elif test "X$1" = X--fallback-echo; then
  60   # Avoid inline document here, it may be left over
  61   :
  62 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
  63   # Yippee, $echo works!
  64   :
  65 else
  66   # Restart under the correct shell, and then maybe $echo will work.
  67   exec $SHELL "$progpath" --no-reexec ${1+"$@"}
  68 fi
  69
  70 if test "X$1" = X--fallback-echo; then
  71   # used as fallback echo
  72   shift
  73   cat <<EOF
  74 $*
  75 EOF
  76   exit $EXIT_SUCCESS
  77 fi
  78
  79 default_mode=
  80 help="Try \`$progname --help' for more information."
  81 magic="%%%MAGIC variable%%%"
  82 mkdir="mkdir"
  83 mv="mv -f"
  84 rm="rm -f"
  85
  86 # Sed substitution that helps us do robust quoting.  It backslashifies
  87 # metacharacters that are still active within double-quoted strings.
  88 Xsed="${SED}"' -e 1s/^X//'
  89 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
  90 # test EBCDIC or ASCII
  91 case `echo A|tr A '\301'` in
  92  A) # EBCDIC based system
  93   SP2NL="tr '\100' '\n'"
  94   NL2SP="tr '\r\n' '\100\100'"
  95   ;;
  96  *) # Assume ASCII based system
  97   SP2NL="tr '\040' '\012'"
  98   NL2SP="tr '\015\012' '\040\040'"
  99   ;;
 100 esac
 101
 102 # NLS nuisances.
 103 # Only set LANG and LC_ALL to C if already set.
 104 # These must not be set unconditionally because not all systems understand
 105 # e.g. LANG=C (notably SCO).
 106 # We save the old values to restore during execute mode.
 107 if test "${LC_ALL+set}" = set; then
 108   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
 109 fi
 110 if test "${LANG+set}" = set; then
 111   save_LANG="$LANG"; LANG=C; export LANG
 112 fi
 113
 114 # Make sure IFS has a sensible default
 115 : ${IFS="
 116 "}
 117
 118 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
 119   $echo "$modename: not configured to build any kind of library" 1>&2
 120   $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
 121   exit $EXIT_FAILURE
 122 fi
 123
 124 # Global variables.
 125 mode=$default_mode
 126 nonopt=
 127 prev=
 128 prevopt=
 129 run=
 130 show="$echo"
 131 show_help=
 132 execute_dlfiles=
 133 lo2o="s/\\.lo\$/.${objext}/"
 134 o2lo="s/\\.${objext}\$/.lo/"
 135
 136 #####################################
 137 # Shell function definitions:
 138 # This seems to be the best place for them
 139
 140 # func_win32_libid arg
 141 # return the library type of file 'arg'
 142 #
 143 # Need a lot of goo to handle *both* DLLs and import libs
 144 # Has to be a shell function in order to 'eat' the argument
 145 # that is supplied when $file_magic_command is called.
 146 func_win32_libid () {
 147   win32_libid_type="unknown"
 148   win32_fileres=`file -L $1 2>/dev/null`
 149   case $win32_fileres in
 150   *ar\ archive\ import\ library*) # definitely import
 151     win32_libid_type="x86 archive import"
 152     ;;
 153   *ar\ archive*) # could be an import, or static
 154     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
 155       $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
 156       win32_nmres=`eval $NM -f posix -A $1 | \
 157         sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`
 158       if test "X$win32_nmres" = "Ximport" ; then
 159         win32_libid_type="x86 archive import"
 160       else
 161         win32_libid_type="x86 archive static"
 162       fi
 163     fi
 164     ;;
 165   *DLL*)
 166     win32_libid_type="x86 DLL"
 167     ;;
 168   *executable*) # but shell scripts are "executable" too...
 169     case $win32_fileres in
 170     *MS\ Windows\ PE\ Intel*)
 171       win32_libid_type="x86 DLL"
 172       ;;
 173     esac
 174     ;;
 175   esac
 176   $echo $win32_libid_type
 177 }
 178
 179
 180 # func_infer_tag arg
 181 # Infer tagged configuration to use if any are available and
 182 # if one wasn't chosen via the "--tag" command line option.
 183 # Only attempt this if the compiler in the base compile
 184 # command doesn't match the default compiler.
 185 # arg is usually of the form 'gcc ...'
 186 func_infer_tag () {
 187     if test -n "$available_tags" && test -z "$tagname"; then
 188       CC_quoted=
 189       for arg in $CC; do
 190         case $arg in
 191           *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
 192           arg="\"$arg\""
 193           ;;
 194         esac
 195         CC_quoted="$CC_quoted $arg"
 196       done
 197       case $@ in
 198       # Blanks in the command may have been stripped by the calling shell,
 199       # but not from the CC environment variable when configure was run.
 200       " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
 201       # Blanks at the start of $base_compile will cause this to fail
 202       # if we don't check for them as well.
 203       *)
 204         for z in $available_tags; do
 205           if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
 206             # Evaluate the configuration.
 207             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
 208             CC_quoted=
 209             for arg in $CC; do
 210             # Double-quote args containing other shell metacharacters.
 211             case $arg in
 212               *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 213               arg="\"$arg\""
 214               ;;
 215             esac
 216             CC_quoted="$CC_quoted $arg"
 217           done
 218             case "$@ " in
 219               " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
 220               # The compiler in the base compile command matches
 221               # the one in the tagged configuration.
 222               # Assume this is the tagged configuration we want.
 223               tagname=$z
 224               break
 225               ;;
 226             esac
 227           fi
 228         done
 229         # If $tagname still isn't set, then no tagged configuration
 230         # was found and let the user know that the "--tag" command
 231         # line option must be used.
 232         if test -z "$tagname"; then
 233           $echo "$modename: unable to infer tagged configuration"
 234           $echo "$modename: specify a tag with \`--tag'" 1>&2
 235           exit $EXIT_FAILURE
 236 #        else
 237 #          $echo "$modename: using $tagname tagged configuration"
 238         fi
 239         ;;
 240       esac
 241     fi
 242 }
 243
 244
 245 # func_extract_archives gentop oldlib ...
 246 func_extract_archives () {
 247     my_gentop="$1"; shift
 248     my_oldlibs=${1+"$@"}
 249     my_oldobjs=""
 250     my_xlib=""
 251     my_xabs=""
 252     my_xdir=""
 253     my_status=""
 254
 255     $show "${rm}r $my_gentop"
 256     $run ${rm}r "$my_gentop"
 257     $show "$mkdir $my_gentop"
 258     $run $mkdir "$my_gentop"
 259     my_status=$?
 260     if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
 261       exit $my_status
 262     fi
 263
 264     for my_xlib in $my_oldlibs; do
 265       # Extract the objects.
 266       case $my_xlib in
 267         [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
 268         *) my_xabs=`pwd`"/$my_xlib" ;;
 269       esac
 270       my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
 271       my_xdir="$my_gentop/$my_xlib"
 272
 273       $show "${rm}r $my_xdir"
 274       $run ${rm}r "$my_xdir"
 275       $show "$mkdir $my_xdir"
 276       $run $mkdir "$my_xdir"
 277       status=$?
 278       if test "$status" -ne 0 && test ! -d "$my_xdir"; then
 279         exit $status
 280       fi
 281       case $host in
 282       *-darwin*)
 283         $show "Extracting $my_xabs"
 284         # Do not bother doing anything if just a dry run
 285         if test -z "$run"; then
 286           darwin_orig_dir=`pwd`
 287           cd $my_xdir || exit $?
 288           darwin_archive=$my_xabs
 289           darwin_curdir=`pwd`
 290           darwin_base_archive=`basename $darwin_archive`
 291           darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
 292           if test -n "$darwin_arches"; then
 293             darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
 294             darwin_arch=
 295             $show "$darwin_base_archive has multiple architectures $darwin_arches"
 296             for darwin_arch in  $darwin_arches ; do
 297               mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
 298               lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
 299               # Remove the table of contents from the thin files.
 300               $AR -d "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" __.SYMDEF 2>/dev/null || true
 301               $AR -d "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" __.SYMDEF\ SORTED 2>/dev/null || true
 302               cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
 303               $AR -xo "${darwin_base_archive}"
 304               rm "${darwin_base_archive}"
 305               cd "$darwin_curdir"
 306             done # $darwin_arches
 307       ## Okay now we have a bunch of thin objects, gotta fatten them up :)
 308             darwin_filelist=`find unfat-$$ -type f | xargs basename | sort -u | $NL2SP`
 309             darwin_file=
 310             darwin_files=
 311             for darwin_file in $darwin_filelist; do
 312               darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
 313               lipo -create -output "$darwin_file" $darwin_files
 314             done # $darwin_filelist
 315             rm -rf unfat-$$
 316             cd "$darwin_orig_dir"
 317           else
 318             cd $darwin_orig_dir
 319             (cd $my_xdir && $AR x $my_xabs) || exit $?
 320           fi # $darwin_arches
 321         fi # $run
 322       ;;
 323       *)
 324         # We will extract separately just the conflicting names and we will
 325         # no longer touch any unique names. It is faster to leave these
 326         # extract automatically by $AR in one run.
 327         $show "(cd $my_xdir && $AR x $my_xabs)"
 328         $run eval "(cd \$my_xdir && $AR x \$my_xabs)" || exit $?
 329         if ($AR t "$my_xabs" | sort | sort -uc >/dev/null 2>&1); then
 330           :
 331         else
 332           $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
 333           $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
 334           $AR t "$my_xabs" | sort | uniq -cd | while read -r count name
 335           do
 336             i=1
 337             while test "$i" -le "$count"
 338             do
 339               # Put our $i before any first dot (extension)
 340               # Never overwrite any file
 341               name_to="$name"
 342               while test "X$name_to" = "X$name" || test -f "$my_xdir/$name_to"
 343               do
 344                 name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
 345               done
 346               $show "(cd $my_xdir && $AR xN $i $my_xabs '$name' && $mv '$name' '$name_to')"
 347               $run eval "(cd \$my_xdir && $AR xN $i \$my_xabs '$name' && $mv '$name' '$name_to')" || exit $?
 348               i=`expr $i + 1`
 349             done
 350           done
 351         fi
 352         ;;
 353       esac
 354       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
 355     done
 356
 357     func_extract_archives_result="$my_oldobjs"
 358 }
 359 # End of Shell function definitions
 360 #####################################
 361
 362 # Darwin sucks
 363 eval std_shrext=\"$shrext_cmds\"
 364
 365 # Parse our command line options once, thoroughly.
 366 while test "$#" -gt 0
 367 do
 368   arg="$1"
 369   shift
 370
 371   case $arg in
 372   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
 373   *) optarg= ;;
 374   esac
 375
 376   # If the previous option needs an argument, assign it.
 377   if test -n "$prev"; then
 378     case $prev in
 379     execute_dlfiles)
 380       execute_dlfiles="$execute_dlfiles $arg"
 381       ;;
 382     tag)
 383       tagname="$arg"
 384       preserve_args="${preserve_args}=$arg"
 385
 386       # Check whether tagname contains only valid characters
 387       case $tagname in
 388       *[!-_A-Za-z0-9,/]*)
 389         $echo "$progname: invalid tag name: $tagname" 1>&2
 390         exit $EXIT_FAILURE
 391         ;;
 392       esac
 393
 394       case $tagname in
 395       CC)
 396         # Don't test for the "default" C tag, as we know, it's there, but
 397         # not specially marked.
 398         ;;
 399       *)
 400         if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
 401           taglist="$taglist $tagname"
 402           # Evaluate the configuration.
 403           eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
 404         else
 405           $echo "$progname: ignoring unknown tag $tagname" 1>&2
 406         fi
 407         ;;
 408       esac
 409       ;;
 410     *)
 411       eval "$prev=\$arg"
 412       ;;
 413     esac
 414
 415     prev=
 416     prevopt=
 417     continue
 418   fi
 419
 420   # Have we seen a non-optional argument yet?
 421   case $arg in
 422   --help)
 423     show_help=yes
 424     ;;
 425
 426   --version)
 427     $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
 428     $echo
 429     $echo "Copyright (C) 2003  Free Software Foundation, Inc."
 430     $echo "This is free software; see the source for copying conditions.  There is NO"
 431     $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
 432     exit $EXIT_SUCCESS
 433     ;;
 434
 435   --config)
 436     ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
 437     # Now print the configurations for the tags.
 438     for tagname in $taglist; do
 439       ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
 440     done
 441     exit $EXIT_SUCCESS
 442     ;;
 443
 444   --debug)
 445     $echo "$progname: enabling shell trace mode"
 446     set -x
 447     preserve_args="$preserve_args $arg"
 448     ;;
 449
 450   --dry-run | -n)
 451     run=:
 452     ;;
 453
 454   --features)
 455     $echo "host: $host"
 456     if test "$build_libtool_libs" = yes; then
 457       $echo "enable shared libraries"
 458     else
 459       $echo "disable shared libraries"
 460     fi
 461     if test "$build_old_libs" = yes; then
 462       $echo "enable static libraries"
 463     else
 464       $echo "disable static libraries"
 465     fi
 466     exit $EXIT_SUCCESS
 467     ;;
 468
 469   --finish) mode="finish" ;;
 470
 471   --mode) prevopt="--mode" prev=mode ;;
 472   --mode=*) mode="$optarg" ;;
 473
 474   --preserve-dup-deps) duplicate_deps="yes" ;;
 475
 476   --quiet | --silent)
 477     show=:
 478     preserve_args="$preserve_args $arg"
 479     ;;
 480
 481   --tag) prevopt="--tag" prev=tag ;;
 482   --tag=*)
 483     set tag "$optarg" ${1+"$@"}
 484     shift
 485     prev=tag
 486     preserve_args="$preserve_args --tag"
 487     ;;
 488
 489   -dlopen)
 490     prevopt="-dlopen"
 491     prev=execute_dlfiles
 492     ;;
 493
 494   -*)
 495     $echo "$modename: unrecognized option \`$arg'" 1>&2
 496     $echo "$help" 1>&2
 497     exit $EXIT_FAILURE
 498     ;;
 499
 500   *)
 501     nonopt="$arg"
 502     break
 503     ;;
 504   esac
 505 done
 506
 507 if test -n "$prevopt"; then
 508   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
 509   $echo "$help" 1>&2
 510   exit $EXIT_FAILURE
 511 fi
 512
 513 # If this variable is set in any of the actions, the command in it
 514 # will be execed at the end.  This prevents here-documents from being
 515 # left over by shells.
 516 exec_cmd=
 517
 518 if test -z "$show_help"; then
 519
 520   # Infer the operation mode.
 521   if test -z "$mode"; then
 522     $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
 523     $echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2
 524     case $nonopt in
 525     *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
 526       mode=link
 527       for arg
 528       do
 529         case $arg in
 530         -c)
 531            mode=compile
 532            break
 533            ;;
 534         esac
 535       done
 536       ;;
 537     *db | *dbx | *strace | *truss)
 538       mode=execute
 539       ;;
 540     *install*|cp|mv)
 541       mode=install
 542       ;;
 543     *rm)
 544       mode=uninstall
 545       ;;
 546     *)
 547       # If we have no mode, but dlfiles were specified, then do execute mode.
 548       test -n "$execute_dlfiles" && mode=execute
 549
 550       # Just use the default operation mode.
 551       if test -z "$mode"; then
 552         if test -n "$nonopt"; then
 553           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
 554         else
 555           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
 556         fi
 557       fi
 558       ;;
 559     esac
 560   fi
 561
 562   # Only execute mode is allowed to have -dlopen flags.
 563   if test -n "$execute_dlfiles" && test "$mode" != execute; then
 564     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
 565     $echo "$help" 1>&2
 566     exit $EXIT_FAILURE
 567   fi
 568
 569   # Change the help message to a mode-specific one.
 570   generic_help="$help"
 571   help="Try \`$modename --help --mode=$mode' for more information."
 572
 573   # These modes are in order of execution frequency so that they run quickly.
 574   case $mode in
 575   # libtool compile mode
 576   compile)
 577     modename="$modename: compile"
 578     # Get the compilation command and the source file.
 579     base_compile=
 580     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
 581     suppress_opt=yes
 582     suppress_output=
 583     arg_mode=normal
 584     libobj=
 585     later=
 586
 587     for arg
 588     do
 589       case "$arg_mode" in
 590       arg  )
 591         # do not "continue".  Instead, add this to base_compile
 592         lastarg="$arg"
 593         arg_mode=normal
 594         ;;
 595
 596       target )
 597         libobj="$arg"
 598         arg_mode=normal
 599         continue
 600         ;;
 601
 602       normal )
 603         # Accept any command-line options.
 604         case $arg in
 605         -o)
 606           if test -n "$libobj" ; then
 607             $echo "$modename: you cannot specify \`-o' more than once" 1>&2
 608             exit $EXIT_FAILURE
 609           fi
 610           arg_mode=target
 611           continue
 612           ;;
 613
 614         -static | -prefer-pic | -prefer-non-pic)
 615           later="$later $arg"
 616           continue
 617           ;;
 618
 619         -no-suppress)
 620           suppress_opt=no
 621           continue
 622           ;;
 623
 624         -Xcompiler)
 625           arg_mode=arg  #  the next one goes into the "base_compile" arg list
 626           continue      #  The current "srcfile" will either be retained or
 627           ;;            #  replaced later.  I would guess that would be a bug.
 628
 629         -Wc,*)
 630           args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
 631           lastarg=
 632           save_ifs="$IFS"; IFS=','
 633           for arg in $args; do
 634             IFS="$save_ifs"
 635
 636             # Double-quote args containing other shell metacharacters.
 637             # Many Bourne shells cannot handle close brackets correctly
 638             # in scan sets, so we specify it separately.
 639             case $arg in
 640               *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 641               arg="\"$arg\""
 642               ;;
 643             esac
 644             lastarg="$lastarg $arg"
 645           done
 646           IFS="$save_ifs"
 647           lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
 648
 649           # Add the arguments to base_compile.
 650           base_compile="$base_compile $lastarg"
 651           continue
 652           ;;
 653
 654         * )
 655           # Accept the current argument as the source file.
 656           # The previous "srcfile" becomes the current argument.
 657           #
 658           lastarg="$srcfile"
 659           srcfile="$arg"
 660           ;;
 661         esac  #  case $arg
 662         ;;
 663       esac    #  case $arg_mode
 664
 665       # Aesthetically quote the previous argument.
 666       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
 667
 668       case $lastarg in
 669       # Double-quote args containing other shell metacharacters.
 670       # Many Bourne shells cannot handle close brackets correctly
 671       # in scan sets, so we specify it separately.
 672       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 673         lastarg="\"$lastarg\""
 674         ;;
 675       esac
 676
 677       base_compile="$base_compile $lastarg"
 678     done # for arg
 679
 680     case $arg_mode in
 681     arg)
 682       $echo "$modename: you must specify an argument for -Xcompile"
 683       exit $EXIT_FAILURE
 684       ;;
 685     target)
 686       $echo "$modename: you must specify a target with \`-o'" 1>&2
 687       exit $EXIT_FAILURE
 688       ;;
 689     *)
 690       # Get the name of the library object.
 691       [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
 692       ;;
 693     esac
 694
 695     # Recognize several different file suffixes.
 696     # If the user specifies -o file.o, it is replaced with file.lo
 697     xform='[cCFSifmso]'
 698     case $libobj in
 699     *.ada) xform=ada ;;
 700     *.adb) xform=adb ;;
 701     *.ads) xform=ads ;;
 702     *.asm) xform=asm ;;
 703     *.c++) xform=c++ ;;
 704     *.cc) xform=cc ;;
 705     *.ii) xform=ii ;;
 706     *.class) xform=class ;;
 707     *.cpp) xform=cpp ;;
 708     *.cxx) xform=cxx ;;
 709     *.f90) xform=f90 ;;
 710     *.for) xform=for ;;
 711     *.java) xform=java ;;
 712     esac
 713
 714     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
 715
 716     case $libobj in
 717     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
 718     *)
 719       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
 720       exit $EXIT_FAILURE
 721       ;;
 722     esac
 723
 724     func_infer_tag $base_compile
 725
 726     for arg in $later; do
 727       case $arg in
 728       -static)
 729         build_old_libs=yes
 730         continue
 731         ;;
 732
 733       -prefer-pic)
 734         pic_mode=yes
 735         continue
 736         ;;
 737
 738       -prefer-non-pic)
 739         pic_mode=no
 740         continue
 741         ;;
 742       esac
 743     done
 744
 745     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
 746     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
 747     if test "X$xdir" = "X$obj"; then
 748       xdir=
 749     else
 750       xdir=$xdir/
 751     fi
 752     lobj=${xdir}$objdir/$objname
 753
 754     if test -z "$base_compile"; then
 755       $echo "$modename: you must specify a compilation command" 1>&2
 756       $echo "$help" 1>&2
 757       exit $EXIT_FAILURE
 758     fi
 759
 760     # Delete any leftover library objects.
 761     if test "$build_old_libs" = yes; then
 762       removelist="$obj $lobj $libobj ${libobj}T"
 763     else
 764       removelist="$lobj $libobj ${libobj}T"
 765     fi
 766
 767     $run $rm $removelist
 768     trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
 769
 770     # On Cygwin there's no "real" PIC flag so we must build both object types
 771     case $host_os in
 772     cygwin* | mingw* | pw32* | os2*)
 773       pic_mode=default
 774       ;;
 775     esac
 776     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
 777       # non-PIC code in shared libraries is not supported
 778       pic_mode=default
 779     fi
 780
 781     # Calculate the filename of the output object if compiler does
 782     # not support -o with -c
 783     if test "$compiler_c_o" = no; then
 784       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
 785       lockfile="$output_obj.lock"
 786       removelist="$removelist $output_obj $lockfile"
 787       trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
 788     else
 789       output_obj=
 790       need_locks=no
 791       lockfile=
 792     fi
 793
 794     # Lock this critical section if it is needed
 795     # We use this script file to make the link, it avoids creating a new file
 796     if test "$need_locks" = yes; then
 797       until $run ln "$progpath" "$lockfile" 2>/dev/null; do
 798         $show "Waiting for $lockfile to be removed"
 799         sleep 2
 800       done
 801     elif test "$need_locks" = warn; then
 802       if test -f "$lockfile"; then
 803         $echo "\
 804 *** ERROR, $lockfile exists and contains:
 805 `cat $lockfile 2>/dev/null`
 806
 807 This indicates that another process is trying to use the same
 808 temporary object file, and libtool could not work around it because
 809 your compiler does not support \`-c' and \`-o' together.  If you
 810 repeat this compilation, it may succeed, by chance, but you had better
 811 avoid parallel builds (make -j) in this platform, or get a better
 812 compiler."
 813
 814         $run $rm $removelist
 815         exit $EXIT_FAILURE
 816       fi
 817       $echo $srcfile > "$lockfile"
 818     fi
 819
 820     if test -n "$fix_srcfile_path"; then
 821       eval srcfile=\"$fix_srcfile_path\"
 822     fi
 823
 824     $run $rm "$libobj" "${libobj}T"
 825
 826     # Create a libtool object file (analogous to a ".la" file),
 827     # but don't create it if we're doing a dry run.
 828     test -z "$run" && cat > ${libobj}T <<EOF
 829 # $libobj - a libtool object file
 830 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 831 #
 832 # Please DO NOT delete this file!
 833 # It is necessary for linking the library.
 834
 835 # Name of the PIC object.
 836 EOF
 837
 838     # Only build a PIC object if we are building libtool libraries.
 839     if test "$build_libtool_libs" = yes; then
 840       # Without this assignment, base_compile gets emptied.
 841       fbsd_hideous_sh_bug=$base_compile
 842
 843       if test "$pic_mode" != no; then
 844         command="$base_compile $srcfile $pic_flag"
 845       else
 846         # Don't build PIC code
 847         command="$base_compile $srcfile"
 848       fi
 849
 850       if test ! -d "${xdir}$objdir"; then
 851         $show "$mkdir ${xdir}$objdir"
 852         $run $mkdir ${xdir}$objdir
 853         status=$?
 854         if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then
 855           exit $status
 856         fi
 857       fi
 858
 859       if test -z "$output_obj"; then
 860         # Place PIC objects in $objdir
 861         command="$command -o $lobj"
 862       fi
 863
 864       $run $rm "$lobj" "$output_obj"
 865
 866       $show "$command"
 867       if $run eval "$command"; then :
 868       else
 869         test -n "$output_obj" && $run $rm $removelist
 870         exit $EXIT_FAILURE
 871       fi
 872
 873       if test "$need_locks" = warn &&
 874          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 875         $echo "\
 876 *** ERROR, $lockfile contains:
 877 `cat $lockfile 2>/dev/null`
 878
 879 but it should contain:
 880 $srcfile
 881
 882 This indicates that another process is trying to use the same
 883 temporary object file, and libtool could not work around it because
 884 your compiler does not support \`-c' and \`-o' together.  If you
 885 repeat this compilation, it may succeed, by chance, but you had better
 886 avoid parallel builds (make -j) in this platform, or get a better
 887 compiler."
 888
 889         $run $rm $removelist
 890         exit $EXIT_FAILURE
 891       fi
 892
 893       # Just move the object if needed, then go on to compile the next one
 894       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
 895         $show "$mv $output_obj $lobj"
 896         if $run $mv $output_obj $lobj; then :
 897         else
 898           error=$?
 899           $run $rm $removelist
 900           exit $error
 901         fi
 902       fi
 903
 904       # Append the name of the PIC object to the libtool object file.
 905       test -z "$run" && cat >> ${libobj}T <<EOF
 906 pic_object='$objdir/$objname'
 907
 908 EOF
 909
 910       # Allow error messages only from the first compilation.
 911       if test "$suppress_opt" = yes; then
 912         suppress_output=' >/dev/null 2>&1'
 913       fi
 914     else
 915       # No PIC object so indicate it doesn't exist in the libtool
 916       # object file.
 917       test -z "$run" && cat >> ${libobj}T <<EOF
 918 pic_object=none
 919
 920 EOF
 921     fi
 922
 923     # Only build a position-dependent object if we build old libraries.
 924     if test "$build_old_libs" = yes; then
 925       if test "$pic_mode" != yes; then
 926         # Don't build PIC code
 927         command="$base_compile $srcfile"
 928       else
 929         command="$base_compile $srcfile $pic_flag"
 930       fi
 931       if test "$compiler_c_o" = yes; then
 932         command="$command -o $obj"
 933       fi
 934
 935       # Suppress compiler output if we already did a PIC compilation.
 936       command="$command$suppress_output"
 937       $run $rm "$obj" "$output_obj"
 938       $show "$command"
 939       if $run eval "$command"; then :
 940       else
 941         $run $rm $removelist
 942         exit $EXIT_FAILURE
 943       fi
 944
 945       if test "$need_locks" = warn &&
 946          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 947         $echo "\
 948 *** ERROR, $lockfile contains:
 949 `cat $lockfile 2>/dev/null`
 950
 951 but it should contain:
 952 $srcfile
 953
 954 This indicates that another process is trying to use the same
 955 temporary object file, and libtool could not work around it because
 956 your compiler does not support \`-c' and \`-o' together.  If you
 957 repeat this compilation, it may succeed, by chance, but you had better
 958 avoid parallel builds (make -j) in this platform, or get a better
 959 compiler."
 960
 961         $run $rm $removelist
 962         exit $EXIT_FAILURE
 963       fi
 964
 965       # Just move the object if needed
 966       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
 967         $show "$mv $output_obj $obj"
 968         if $run $mv $output_obj $obj; then :
 969         else
 970           error=$?
 971           $run $rm $removelist
 972           exit $error
 973         fi
 974       fi
 975
 976       # Append the name of the non-PIC object the libtool object file.
 977       # Only append if the libtool object file exists.
 978       test -z "$run" && cat >> ${libobj}T <<EOF
 979 # Name of the non-PIC object.
 980 non_pic_object='$objname'
 981
 982 EOF
 983     else
 984       # Append the name of the non-PIC object the libtool object file.
 985       # Only append if the libtool object file exists.
 986       test -z "$run" && cat >> ${libobj}T <<EOF
 987 # Name of the non-PIC object.
 988 non_pic_object=none
 989
 990 EOF
 991     fi
 992
 993     $run $mv "${libobj}T" "${libobj}"
 994
 995     # Unlock the critical section if it was locked
 996     if test "$need_locks" != no; then
 997       $run $rm "$lockfile"
 998     fi
 999
1000     exit $EXIT_SUCCESS
1001     ;;
1002
1003   # libtool link mode
1004   link | relink)
1005     modename="$modename: link"
1006     case $host in
1007     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1008       # It is impossible to link a dll without this setting, and
1009       # we shouldn't force the makefile maintainer to figure out
1010       # which system we are compiling for in order to pass an extra
1011       # flag for every libtool invocation.
1012       # allow_undefined=no
1013
1014       # FIXME: Unfortunately, there are problems with the above when trying
1015       # to make a dll which has undefined symbols, in which case not
1016       # even a static library is built.  For now, we need to specify
1017       # -no-undefined on the libtool link line when we can be certain
1018       # that all symbols are satisfied, otherwise we get a static library.
1019       allow_undefined=yes
1020       ;;
1021     *)
1022       allow_undefined=yes
1023       ;;
1024     esac
1025     libtool_args="$nonopt"
1026     base_compile="$nonopt $@"
1027     compile_command="$nonopt"
1028     finalize_command="$nonopt"
1029
1030     compile_rpath=
1031     finalize_rpath=
1032     compile_shlibpath=
1033     finalize_shlibpath=
1034     convenience=
1035     old_convenience=
1036     deplibs=
1037     old_deplibs=
1038     compiler_flags=
1039     linker_flags=
1040     dllsearchpath=
1041     lib_search_path=`pwd`
1042     inst_prefix_dir=
1043
1044     avoid_version=no
1045     dlfiles=
1046     dlprefiles=
1047     dlself=no
1048     export_dynamic=no
1049     export_symbols=
1050     export_symbols_regex=
1051     generated=
1052     libobjs=
1053     ltlibs=
1054     module=no
1055     no_install=no
1056     objs=
1057     non_pic_objects=
1058     precious_files_regex=
1059     prefer_static_libs=no
1060     preload=no
1061     prev=
1062     prevarg=
1063     release=
1064     rpath=
1065     xrpath=
1066     perm_rpath=
1067     temp_rpath=
1068     thread_safe=no
1069     vinfo=
1070     vinfo_number=no
1071
1072     func_infer_tag $base_compile
1073
1074     # We need to know -static, to get the right output filenames.
1075     for arg
1076     do
1077       case $arg in
1078       -all-static | -static)
1079         if test "X$arg" = "X-all-static"; then
1080           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
1081             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
1082           fi
1083           if test -n "$link_static_flag"; then
1084             dlopen_self=$dlopen_self_static
1085           fi
1086         else
1087           if test -z "$pic_flag" && test -n "$link_static_flag"; then
1088             dlopen_self=$dlopen_self_static
1089           fi
1090         fi
1091         build_libtool_libs=no
1092         build_old_libs=yes
1093         prefer_static_libs=yes
1094         break
1095         ;;
1096       esac
1097     done
1098
1099     # See if our shared archives depend on static archives.
1100     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
1101
1102     # Go through the arguments, transforming them on the way.
1103     while test "$#" -gt 0; do
1104       arg="$1"
1105       shift
1106       case $arg in
1107       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
1108         qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
1109         ;;
1110       *) qarg=$arg ;;
1111       esac
1112       libtool_args="$libtool_args $qarg"
1113
1114       # If the previous option needs an argument, assign it.
1115       if test -n "$prev"; then
1116         case $prev in
1117         output)
1118           compile_command="$compile_command @OUTPUT@"
1119           finalize_command="$finalize_command @OUTPUT@"
1120           ;;
1121         esac
1122
1123         case $prev in
1124         dlfiles|dlprefiles)
1125           if test "$preload" = no; then
1126             # Add the symbol object into the linking commands.
1127             compile_command="$compile_command @SYMFILE@"
1128             finalize_command="$finalize_command @SYMFILE@"
1129             preload=yes
1130           fi
1131           case $arg in
1132           *.la | *.lo) ;;  # We handle these cases below.
1133           force)
1134             if test "$dlself" = no; then
1135               dlself=needless
1136               export_dynamic=yes
1137             fi
1138             prev=
1139             continue
1140             ;;
1141           self)
1142             if test "$prev" = dlprefiles; then
1143               dlself=yes
1144             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
1145               dlself=yes
1146             else
1147               dlself=needless
1148               export_dynamic=yes
1149             fi
1150             prev=
1151             continue
1152             ;;
1153           *)
1154             if test "$prev" = dlfiles; then
1155               dlfiles="$dlfiles $arg"
1156             else
1157               dlprefiles="$dlprefiles $arg"
1158             fi
1159             prev=
1160             continue
1161             ;;
1162           esac
1163           ;;
1164         expsyms)
1165           export_symbols="$arg"
1166           if test ! -f "$arg"; then
1167             $echo "$modename: symbol file \`$arg' does not exist"
1168             exit $EXIT_FAILURE
1169           fi
1170           prev=
1171           continue
1172           ;;
1173         expsyms_regex)
1174           export_symbols_regex="$arg"
1175           prev=
1176           continue
1177           ;;
1178         inst_prefix)
1179           inst_prefix_dir="$arg"
1180           prev=
1181           continue
1182           ;;
1183         precious_regex)
1184           precious_files_regex="$arg"
1185           prev=
1186           continue
1187           ;;
1188         release)
1189           release="-$arg"
1190           prev=
1191           continue
1192           ;;
1193         objectlist)
1194           if test -f "$arg"; then
1195             save_arg=$arg
1196             moreargs=
1197             for fil in `cat $save_arg`
1198             do
1199 #             moreargs="$moreargs $fil"
1200               arg=$fil
1201               # A libtool-controlled object.
1202
1203               # Check to see that this really is a libtool object.
1204               if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1205                 pic_object=
1206                 non_pic_object=
1207
1208                 # Read the .lo file
1209                 # If there is no directory component, then add one.
1210                 case $arg in
1211                 */* | *\\*) . $arg ;;
1212                 *) . ./$arg ;;
1213                 esac
1214
1215                 if test -z "$pic_object" || \
1216                    test -z "$non_pic_object" ||
1217                    test "$pic_object" = none && \
1218                    test "$non_pic_object" = none; then
1219                   $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1220                   exit $EXIT_FAILURE
1221                 fi
1222
1223                 # Extract subdirectory from the argument.
1224                 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1225                 if test "X$xdir" = "X$arg"; then
1226                   xdir=
1227                 else
1228                   xdir="$xdir/"
1229                 fi
1230
1231                 if test "$pic_object" != none; then
1232                   # Prepend the subdirectory the object is found in.
1233                   pic_object="$xdir$pic_object"
1234
1235                   if test "$prev" = dlfiles; then
1236                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1237                       dlfiles="$dlfiles $pic_object"
1238                       prev=
1239                       continue
1240                     else
1241                       # If libtool objects are unsupported, then we need to preload.
1242                       prev=dlprefiles
1243                     fi
1244                   fi
1245
1246                   # CHECK ME:  I think I busted this.  -Ossama
1247                   if test "$prev" = dlprefiles; then
1248                     # Preload the old-style object.
1249                     dlprefiles="$dlprefiles $pic_object"
1250                     prev=
1251                   fi
1252
1253                   # A PIC object.
1254                   libobjs="$libobjs $pic_object"
1255                   arg="$pic_object"
1256                 fi
1257
1258                 # Non-PIC object.
1259                 if test "$non_pic_object" != none; then
1260                   # Prepend the subdirectory the object is found in.
1261                   non_pic_object="$xdir$non_pic_object"
1262
1263                   # A standard non-PIC object
1264                   non_pic_objects="$non_pic_objects $non_pic_object"
1265                   if test -z "$pic_object" || test "$pic_object" = none ; then
1266                     arg="$non_pic_object"
1267                   fi
1268                 fi
1269               else
1270                 # Only an error if not doing a dry-run.
1271                 if test -z "$run"; then
1272                   $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1273                   exit $EXIT_FAILURE
1274                 else
1275                   # Dry-run case.
1276
1277                   # Extract subdirectory from the argument.
1278                   xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1279                   if test "X$xdir" = "X$arg"; then
1280                     xdir=
1281                   else
1282                     xdir="$xdir/"
1283                   fi
1284
1285                   pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1286                   non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1287                   libobjs="$libobjs $pic_object"
1288                   non_pic_objects="$non_pic_objects $non_pic_object"
1289                 fi
1290               fi
1291             done
1292           else
1293             $echo "$modename: link input file \`$save_arg' does not exist"
1294             exit $EXIT_FAILURE
1295           fi
1296           arg=$save_arg
1297           prev=
1298           continue
1299           ;;
1300         rpath | xrpath)
1301           # We need an absolute path.
1302           case $arg in
1303           [\\/]* | [A-Za-z]:[\\/]*) ;;
1304           *)
1305             $echo "$modename: only absolute run-paths are allowed" 1>&2
1306             exit $EXIT_FAILURE
1307             ;;
1308           esac
1309           if test "$prev" = rpath; then
1310             case "$rpath " in
1311             *" $arg "*) ;;
1312             *) rpath="$rpath $arg" ;;
1313             esac
1314           else
1315             case "$xrpath " in
1316             *" $arg "*) ;;
1317             *) xrpath="$xrpath $arg" ;;
1318             esac
1319           fi
1320           prev=
1321           continue
1322           ;;
1323         xcompiler)
1324           compiler_flags="$compiler_flags $qarg"
1325           prev=
1326           compile_command="$compile_command $qarg"
1327           finalize_command="$finalize_command $qarg"
1328           continue
1329           ;;
1330         xlinker)
1331           linker_flags="$linker_flags $qarg"
1332           compiler_flags="$compiler_flags $wl$qarg"
1333           prev=
1334           compile_command="$compile_command $wl$qarg"
1335           finalize_command="$finalize_command $wl$qarg"
1336           continue
1337           ;;
1338         xcclinker)
1339           linker_flags="$linker_flags $qarg"
1340           compiler_flags="$compiler_flags $qarg"
1341           prev=
1342           compile_command="$compile_command $qarg"
1343           finalize_command="$finalize_command $qarg"
1344           continue
1345           ;;
1346         shrext)
1347           shrext_cmds="$arg"
1348           prev=
1349           continue
1350           ;;
1351         *)
1352           eval "$prev=\"\$arg\""
1353           prev=
1354           continue
1355           ;;
1356         esac
1357       fi # test -n "$prev"
1358
1359       prevarg="$arg"
1360
1361       case $arg in
1362       -all-static)
1363         if test -n "$link_static_flag"; then
1364           compile_command="$compile_command $link_static_flag"
1365           finalize_command="$finalize_command $link_static_flag"
1366         fi
1367         continue
1368         ;;
1369
1370       -allow-undefined)
1371         # FIXME: remove this flag sometime in the future.
1372         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1373         continue
1374         ;;
1375
1376       -avoid-version)
1377         avoid_version=yes
1378         continue
1379         ;;
1380
1381       -dlopen)
1382         prev=dlfiles
1383         continue
1384         ;;
1385
1386       -dlpreopen)
1387         prev=dlprefiles
1388         continue
1389         ;;
1390
1391       -export-dynamic)
1392         export_dynamic=yes
1393         continue
1394         ;;
1395
1396       -export-symbols | -export-symbols-regex)
1397         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1398           $echo "$modename: more than one -exported-symbols argument is not allowed"
1399           exit $EXIT_FAILURE
1400         fi
1401         if test "X$arg" = "X-export-symbols"; then
1402           prev=expsyms
1403         else
1404           prev=expsyms_regex
1405         fi
1406         continue
1407         ;;
1408
1409       -inst-prefix-dir)
1410         prev=inst_prefix
1411         continue
1412         ;;
1413
1414       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1415       # so, if we see these flags be careful not to treat them like -L
1416       -L[A-Z][A-Z]*:*)
1417         case $with_gcc/$host in
1418         no/*-*-irix* | /*-*-irix*)
1419           compile_command="$compile_command $arg"
1420           finalize_command="$finalize_command $arg"
1421           ;;
1422         esac
1423         continue
1424         ;;
1425
1426       -L*)
1427         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1428         # We need an absolute path.
1429         case $dir in
1430         [\\/]* | [A-Za-z]:[\\/]*) ;;
1431         *)
1432           absdir=`cd "$dir" && pwd`
1433           if test -z "$absdir"; then
1434             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1435             exit $EXIT_FAILURE
1436           fi
1437           dir="$absdir"
1438           ;;
1439         esac
1440         case "$deplibs " in
1441         *" -L$dir "*) ;;
1442         *)
1443           deplibs="$deplibs -L$dir"
1444           lib_search_path="$lib_search_path $dir"
1445           ;;
1446         esac
1447         case $host in
1448         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1449           case :$dllsearchpath: in
1450           *":$dir:"*) ;;
1451           *) dllsearchpath="$dllsearchpath:$dir";;
1452           esac
1453           ;;
1454         esac
1455         continue
1456         ;;
1457
1458       -l*)
1459         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1460           case $host in
1461           *-*-cygwin* | *-*-pw32* | *-*-beos*)
1462             # These systems don't actually have a C or math library (as such)
1463             continue
1464             ;;
1465           *-*-mingw* | *-*-os2*)
1466             # These systems don't actually have a C library (as such)
1467             test "X$arg" = "X-lc" && continue
1468             ;;
1469           *-*-openbsd* | *-*-freebsd*)
1470             # Do not include libc due to us having libc/libc_r.
1471             test "X$arg" = "X-lc" && continue
1472             ;;
1473           *-*-rhapsody* | *-*-darwin1.[012])
1474             # Rhapsody C and math libraries are in the System framework
1475             deplibs="$deplibs -framework System"
1476             continue
1477           esac
1478         elif test "X$arg" = "X-lc_r"; then
1479          case $host in
1480          *-*-openbsd* | *-*-freebsd*)
1481            # Do not include libc_r directly, use -pthread flag.
1482            continue
1483            ;;
1484          esac
1485         fi
1486         deplibs="$deplibs $arg"
1487         continue
1488         ;;
1489
1490      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1491         deplibs="$deplibs $arg"
1492         continue
1493         ;;
1494
1495       -module)
1496         module=yes
1497         continue
1498         ;;
1499
1500       # gcc -m* arguments should be passed to the linker via $compiler_flags
1501       # in order to pass architecture information to the linker
1502       # (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo
1503       # but this is not reliable with gcc because gcc may use -mfoo to
1504       # select a different linker, different libraries, etc, while
1505       # -Wl,-mfoo simply passes -mfoo to the linker.
1506       -m*)
1507         # Unknown arguments in both finalize_command and compile_command need
1508         # to be aesthetically quoted because they are evaled later.
1509         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1510         case $arg in
1511         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1512           arg="\"$arg\""
1513           ;;
1514         esac
1515         compile_command="$compile_command $arg"
1516         finalize_command="$finalize_command $arg"
1517         if test "$with_gcc" = "yes" ; then
1518           compiler_flags="$compiler_flags $arg"
1519         fi
1520         continue
1521         ;;
1522
1523       -shrext)
1524         prev=shrext
1525         continue
1526         ;;
1527
1528       -no-fast-install)
1529         fast_install=no
1530         continue
1531         ;;
1532
1533       -no-install)
1534         case $host in
1535         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1536           # The PATH hackery in wrapper scripts is required on Windows
1537           # in order for the loader to find any dlls it needs.
1538           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1539           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1540           fast_install=no
1541           ;;
1542         *) no_install=yes ;;
1543         esac
1544         continue
1545         ;;
1546
1547       -no-undefined)
1548         allow_undefined=no
1549         continue
1550         ;;
1551
1552       -objectlist)
1553         prev=objectlist
1554         continue
1555         ;;
1556
1557       -o) prev=output ;;
1558
1559       -precious-files-regex)
1560         prev=precious_regex
1561         continue
1562         ;;
1563
1564       -release)
1565         prev=release
1566         continue
1567         ;;
1568
1569       -rpath)
1570         prev=rpath
1571         continue
1572         ;;
1573
1574       -R)
1575         prev=xrpath
1576         continue
1577         ;;
1578
1579       -R*)
1580         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1581         # We need an absolute path.
1582         case $dir in
1583         [\\/]* | [A-Za-z]:[\\/]*) ;;
1584         *)
1585           $echo "$modename: only absolute run-paths are allowed" 1>&2
1586           exit $EXIT_FAILURE
1587           ;;
1588         esac
1589         case "$xrpath " in
1590         *" $dir "*) ;;
1591         *) xrpath="$xrpath $dir" ;;
1592         esac
1593         continue
1594         ;;
1595
1596       -static)
1597         # The effects of -static are defined in a previous loop.
1598         # We used to do the same as -all-static on platforms that
1599         # didn't have a PIC flag, but the assumption that the effects
1600         # would be equivalent was wrong.  It would break on at least
1601         # Digital Unix and AIX.
1602         continue
1603         ;;
1604
1605       -thread-safe)
1606         thread_safe=yes
1607         continue
1608         ;;
1609
1610       -version-info)
1611         prev=vinfo
1612         continue
1613         ;;
1614       -version-number)
1615         prev=vinfo
1616         vinfo_number=yes
1617         continue
1618         ;;
1619
1620       -Wc,*)
1621         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1622         arg=
1623         save_ifs="$IFS"; IFS=','
1624         for flag in $args; do
1625           IFS="$save_ifs"
1626           case $flag in
1627             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1628             flag="\"$flag\""
1629             ;;
1630           esac
1631           arg="$arg $wl$flag"
1632           compiler_flags="$compiler_flags $flag"
1633         done
1634         IFS="$save_ifs"
1635         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1636         ;;
1637
1638       -Wl,*)
1639         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1640         arg=
1641         save_ifs="$IFS"; IFS=','
1642         for flag in $args; do
1643           IFS="$save_ifs"
1644           case $flag in
1645             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1646             flag="\"$flag\""
1647             ;;
1648           esac
1649           arg="$arg $wl$flag"
1650           compiler_flags="$compiler_flags $wl$flag"
1651           linker_flags="$linker_flags $flag"
1652         done
1653         IFS="$save_ifs"
1654         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1655         ;;
1656
1657       -Xcompiler)
1658         prev=xcompiler
1659         continue
1660         ;;
1661
1662       -Xlinker)
1663         prev=xlinker
1664         continue
1665         ;;
1666
1667       -XCClinker)
1668         prev=xcclinker
1669         continue
1670         ;;
1671
1672       # Some other compiler flag.
1673       -* | +*)
1674         # Unknown arguments in both finalize_command and compile_command need
1675         # to be aesthetically quoted because they are evaled later.
1676         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1677         case $arg in
1678         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1679           arg="\"$arg\""
1680           ;;
1681         esac
1682         ;;
1683
1684       *.$objext)
1685         # A standard object.
1686         objs="$objs $arg"
1687         ;;
1688
1689       *.lo)
1690         # A libtool-controlled object.
1691
1692         # Check to see that this really is a libtool object.
1693         if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1694           pic_object=
1695           non_pic_object=
1696
1697           # Read the .lo file
1698           # If there is no directory component, then add one.
1699           case $arg in
1700           */* | *\\*) . $arg ;;
1701           *) . ./$arg ;;
1702           esac
1703
1704           if test -z "$pic_object" || \
1705              test -z "$non_pic_object" ||
1706              test "$pic_object" = none && \
1707              test "$non_pic_object" = none; then
1708             $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1709             exit $EXIT_FAILURE
1710           fi
1711
1712           # Extract subdirectory from the argument.
1713           xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1714           if test "X$xdir" = "X$arg"; then
1715             xdir=
1716           else
1717             xdir="$xdir/"
1718           fi
1719
1720           if test "$pic_object" != none; then
1721             # Prepend the subdirectory the object is found in.
1722             pic_object="$xdir$pic_object"
1723
1724             if test "$prev" = dlfiles; then
1725               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1726                 dlfiles="$dlfiles $pic_object"
1727                 prev=
1728                 continue
1729               else
1730                 # If libtool objects are unsupported, then we need to preload.
1731                 prev=dlprefiles
1732               fi
1733             fi
1734
1735             # CHECK ME:  I think I busted this.  -Ossama
1736             if test "$prev" = dlprefiles; then
1737               # Preload the old-style object.
1738               dlprefiles="$dlprefiles $pic_object"
1739               prev=
1740             fi
1741
1742             # A PIC object.
1743             libobjs="$libobjs $pic_object"
1744             arg="$pic_object"
1745           fi
1746
1747           # Non-PIC object.
1748           if test "$non_pic_object" != none; then
1749             # Prepend the subdirectory the object is found in.
1750             non_pic_object="$xdir$non_pic_object"
1751
1752             # A standard non-PIC object
1753             non_pic_objects="$non_pic_objects $non_pic_object"
1754             if test -z "$pic_object" || test "$pic_object" = none ; then
1755               arg="$non_pic_object"
1756             fi
1757           fi
1758         else
1759           # Only an error if not doing a dry-run.
1760           if test -z "$run"; then
1761             $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1762             exit $EXIT_FAILURE
1763           else
1764             # Dry-run case.
1765
1766             # Extract subdirectory from the argument.
1767             xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1768             if test "X$xdir" = "X$arg"; then
1769               xdir=
1770             else
1771               xdir="$xdir/"
1772             fi
1773
1774             pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1775             non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1776             libobjs="$libobjs $pic_object"
1777             non_pic_objects="$non_pic_objects $non_pic_object"
1778           fi
1779         fi
1780         ;;
1781
1782       *.$libext)
1783         # An archive.
1784         deplibs="$deplibs $arg"
1785         old_deplibs="$old_deplibs $arg"
1786         continue
1787         ;;
1788
1789       *.la)
1790         # A libtool-controlled library.
1791
1792         if test "$prev" = dlfiles; then
1793           # This library was specified with -dlopen.
1794           dlfiles="$dlfiles $arg"
1795           prev=
1796         elif test "$prev" = dlprefiles; then
1797           # The library was specified with -dlpreopen.
1798           dlprefiles="$dlprefiles $arg"
1799           prev=
1800         else
1801           deplibs="$deplibs $arg"
1802         fi
1803         continue
1804         ;;
1805
1806       # Some other compiler argument.
1807       *)
1808         # Unknown arguments in both finalize_command and compile_command need
1809         # to be aesthetically quoted because they are evaled later.
1810         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1811         case $arg in
1812         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1813           arg="\"$arg\""
1814           ;;
1815         esac
1816         ;;
1817       esac # arg
1818
1819       # Now actually substitute the argument into the commands.
1820       if test -n "$arg"; then
1821         compile_command="$compile_command $arg"
1822         finalize_command="$finalize_command $arg"
1823       fi
1824     done # argument parsing loop
1825
1826     if test -n "$prev"; then
1827       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1828       $echo "$help" 1>&2
1829       exit $EXIT_FAILURE
1830     fi
1831
1832     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1833       eval arg=\"$export_dynamic_flag_spec\"
1834       compile_command="$compile_command $arg"
1835       finalize_command="$finalize_command $arg"
1836     fi
1837
1838     oldlibs=
1839     # calculate the name of the file, without its directory
1840     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1841     libobjs_save="$libobjs"
1842
1843     if test -n "$shlibpath_var"; then
1844       # get the directories listed in $shlibpath_var
1845       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1846     else
1847       shlib_search_path=
1848     fi
1849     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1850     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1851
1852     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1853     if test "X$output_objdir" = "X$output"; then
1854       output_objdir="$objdir"
1855     else
1856       output_objdir="$output_objdir/$objdir"
1857     fi
1858     # Create the object directory.
1859     if test ! -d "$output_objdir"; then
1860       $show "$mkdir $output_objdir"
1861       $run $mkdir $output_objdir
1862       status=$?
1863       if test "$status" -ne 0 && test ! -d "$output_objdir"; then
1864         exit $status
1865       fi
1866     fi
1867
1868     # Determine the type of output
1869     case $output in
1870     "")
1871       $echo "$modename: you must specify an output file" 1>&2
1872       $echo "$help" 1>&2
1873       exit $EXIT_FAILURE
1874       ;;
1875     *.$libext) linkmode=oldlib ;;
1876     *.lo | *.$objext) linkmode=obj ;;
1877     *.la) linkmode=lib ;;
1878     *) linkmode=prog ;; # Anything else should be a program.
1879     esac
1880
1881     case $host in
1882     *cygwin* | *mingw* | *pw32*)
1883       # don't eliminate duplications in $postdeps and $predeps
1884       duplicate_compiler_generated_deps=yes
1885       ;;
1886     *)
1887       duplicate_compiler_generated_deps=$duplicate_deps
1888       ;;
1889     esac
1890     specialdeplibs=
1891
1892     libs=
1893     # Find all interdependent deplibs by searching for libraries
1894     # that are linked more than once (e.g. -la -lb -la)
1895     for deplib in $deplibs; do
1896       if test "X$duplicate_deps" = "Xyes" ; then
1897         case "$libs " in
1898         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1899         esac
1900       fi
1901       libs="$libs $deplib"
1902     done
1903
1904     if test "$linkmode" = lib; then
1905       libs="$predeps $libs $compiler_lib_search_path $postdeps"
1906
1907       # Compute libraries that are listed more than once in $predeps
1908       # $postdeps and mark them as special (i.e., whose duplicates are
1909       # not to be eliminated).
1910       pre_post_deps=
1911       if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
1912         for pre_post_dep in $predeps $postdeps; do
1913           case "$pre_post_deps " in
1914           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1915           esac
1916           pre_post_deps="$pre_post_deps $pre_post_dep"
1917         done
1918       fi
1919       pre_post_deps=
1920     fi
1921
1922     deplibs=
1923     newdependency_libs=
1924     newlib_search_path=
1925     need_relink=no # whether we're linking any uninstalled libtool libraries
1926     notinst_deplibs= # not-installed libtool libraries
1927     notinst_path= # paths that contain not-installed libtool libraries
1928     case $linkmode in
1929     lib)
1930         passes="conv link"
1931         for file in $dlfiles $dlprefiles; do
1932           case $file in
1933           *.la) ;;
1934           *)
1935             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1936             exit $EXIT_FAILURE
1937             ;;
1938           esac
1939         done
1940         ;;
1941     prog)
1942         compile_deplibs=
1943         finalize_deplibs=
1944         alldeplibs=no
1945         newdlfiles=
1946         newdlprefiles=
1947         passes="conv scan dlopen dlpreopen link"
1948         ;;
1949     *)  passes="conv"
1950         ;;
1951     esac
1952     for pass in $passes; do
1953       if test "$linkmode,$pass" = "lib,link" ||
1954          test "$linkmode,$pass" = "prog,scan"; then
1955         libs="$deplibs"
1956         deplibs=
1957       fi
1958       if test "$linkmode" = prog; then
1959         case $pass in
1960         dlopen) libs="$dlfiles" ;;
1961         dlpreopen) libs="$dlprefiles" ;;
1962         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1963         esac
1964       fi
1965       if test "$pass" = dlopen; then
1966         # Collect dlpreopened libraries
1967         save_deplibs="$deplibs"
1968         deplibs=
1969       fi
1970       for deplib in $libs; do
1971         lib=
1972         found=no
1973         case $deplib in
1974         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1975           if test "$linkmode,$pass" = "prog,link"; then
1976             compile_deplibs="$deplib $compile_deplibs"
1977             finalize_deplibs="$deplib $finalize_deplibs"
1978           else
1979             deplibs="$deplib $deplibs"
1980           fi
1981           continue
1982           ;;
1983         -l*)
1984           if test "$linkmode" != lib && test "$linkmode" != prog; then
1985             $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
1986             continue
1987           fi
1988           if test "$pass" = conv; then
1989             deplibs="$deplib $deplibs"
1990             continue
1991           fi
1992           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1993           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1994             for search_ext in .la $std_shrext .so .a; do
1995               # Search the libtool library
1996               lib="$searchdir/lib${name}${search_ext}"
1997               if test -f "$lib"; then
1998                 if test "$search_ext" = ".la"; then
1999                   found=yes
2000                 else
2001                   found=no
2002                 fi
2003                 break 2
2004               fi
2005             done
2006           done
2007           if test "$found" != yes; then
2008             # deplib doesn't seem to be a libtool library
2009             if test "$linkmode,$pass" = "prog,link"; then
2010               compile_deplibs="$deplib $compile_deplibs"
2011               finalize_deplibs="$deplib $finalize_deplibs"
2012             else
2013               deplibs="$deplib $deplibs"
2014               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2015             fi
2016             continue
2017           else # deplib is a libtool library
2018             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
2019             # We need to do some special things here, and not later.
2020             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
2021               case " $predeps $postdeps " in
2022               *" $deplib "*)
2023                 if (${SED} -e '2q' $lib |
2024                     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2025                   library_names=
2026                   old_library=
2027                   case $lib in
2028                   */* | *\\*) . $lib ;;
2029                   *) . ./$lib ;;
2030                   esac
2031                   for l in $old_library $library_names; do
2032                     ll="$l"
2033                   done
2034                   if test "X$ll" = "X$old_library" ; then # only static version available
2035                     found=no
2036                     ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2037                     test "X$ladir" = "X$lib" && ladir="."
2038                     lib=$ladir/$old_library
2039                     if test "$linkmode,$pass" = "prog,link"; then
2040                       compile_deplibs="$deplib $compile_deplibs"
2041                       finalize_deplibs="$deplib $finalize_deplibs"
2042                     else
2043                       deplibs="$deplib $deplibs"
2044                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2045                     fi
2046                     continue
2047                   fi
2048                 fi
2049                 ;;
2050               *) ;;
2051               esac
2052             fi
2053           fi
2054           ;; # -l
2055         -L*)
2056           case $linkmode in
2057           lib)
2058             deplibs="$deplib $deplibs"
2059             test "$pass" = conv && continue
2060             newdependency_libs="$deplib $newdependency_libs"
2061             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2062             ;;
2063           prog)
2064             if test "$pass" = conv; then
2065               deplibs="$deplib $deplibs"
2066               continue
2067             fi
2068             if test "$pass" = scan; then
2069               deplibs="$deplib $deplibs"
2070             else
2071               compile_deplibs="$deplib $compile_deplibs"
2072               finalize_deplibs="$deplib $finalize_deplibs"
2073             fi
2074             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2075             ;;
2076           *)
2077             $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
2078             ;;
2079           esac # linkmode
2080           continue
2081           ;; # -L
2082         -R*)
2083           if test "$pass" = link; then
2084             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
2085             # Make sure the xrpath contains only unique directories.
2086             case "$xrpath " in
2087             *" $dir "*) ;;
2088             *) xrpath="$xrpath $dir" ;;
2089             esac
2090           fi
2091           deplibs="$deplib $deplibs"
2092           continue
2093           ;;
2094         *.la) lib="$deplib" ;;
2095         *.$libext)
2096           if test "$pass" = conv; then
2097             deplibs="$deplib $deplibs"
2098             continue
2099           fi
2100           case $linkmode in
2101           lib)
2102             valid_a_lib=no
2103             case $deplibs_check_method in
2104               match_pattern*)
2105                 set dummy $deplibs_check_method
2106                 match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2107                 if eval $echo \"$deplib\" 2>/dev/null \
2108                     | $SED 10q \
2109                     | $EGREP "$match_pattern_regex" > /dev/null; then
2110                   valid_a_lib=yes
2111                 fi
2112                 ;;
2113               pass_all)
2114                 valid_a_lib=yes
2115                 ;;
2116             esac
2117             if test "$valid_a_lib" != yes; then
2118               $echo
2119               $echo "*** Warning: Trying to link with static lib archive $deplib."
2120               $echo "*** I have the capability to make that library automatically link in when"
2121               $echo "*** you link to this library.  But I can only do this if you have a"
2122               $echo "*** shared version of the library, which you do not appear to have"
2123               $echo "*** because the file extensions .$libext of this argument makes me believe"
2124               $echo "*** that it is just a static archive that I should not used here."
2125             else
2126               $echo
2127               $echo "*** Warning: Linking the shared library $output against the"
2128               $echo "*** static library $deplib is not portable!"
2129               deplibs="$deplib $deplibs"
2130             fi
2131             continue
2132             ;;
2133           prog)
2134             if test "$pass" != link; then
2135               deplibs="$deplib $deplibs"
2136             else
2137               compile_deplibs="$deplib $compile_deplibs"
2138               finalize_deplibs="$deplib $finalize_deplibs"
2139             fi
2140             continue
2141             ;;
2142           esac # linkmode
2143           ;; # *.$libext
2144         *.lo | *.$objext)
2145           if test "$pass" = conv; then
2146             deplibs="$deplib $deplibs"
2147           elif test "$linkmode" = prog; then
2148             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2149               # If there is no dlopen support or we're linking statically,
2150               # we need to preload.
2151               newdlprefiles="$newdlprefiles $deplib"
2152               compile_deplibs="$deplib $compile_deplibs"
2153               finalize_deplibs="$deplib $finalize_deplibs"
2154             else
2155               newdlfiles="$newdlfiles $deplib"
2156             fi
2157           fi
2158           continue
2159           ;;
2160         %DEPLIBS%)
2161           alldeplibs=yes
2162           continue
2163           ;;
2164         esac # case $deplib
2165         if test "$found" = yes || test -f "$lib"; then :
2166         else
2167           $echo "$modename: cannot find the library \`$lib'" 1>&2
2168           exit $EXIT_FAILURE
2169         fi
2170
2171         # Check to see that this really is a libtool archive.
2172         if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2173         else
2174           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2175           exit $EXIT_FAILURE
2176         fi
2177
2178         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2179         test "X$ladir" = "X$lib" && ladir="."
2180
2181         dlname=
2182         dlopen=
2183         dlpreopen=
2184         libdir=
2185         library_names=
2186         old_library=
2187         # If the library was installed with an old release of libtool,
2188         # it will not redefine variables installed, or shouldnotlink
2189         installed=yes
2190         shouldnotlink=no
2191
2192         # Read the .la file
2193         case $lib in
2194         */* | *\\*) . $lib ;;
2195         *) . ./$lib ;;
2196         esac
2197
2198         if test "$linkmode,$pass" = "lib,link" ||
2199            test "$linkmode,$pass" = "prog,scan" ||
2200            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2201           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2202           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2203         fi
2204
2205         if test "$pass" = conv; then
2206           # Only check for convenience libraries
2207           deplibs="$lib $deplibs"
2208           if test -z "$libdir"; then
2209             if test -z "$old_library"; then
2210               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2211               exit $EXIT_FAILURE
2212             fi
2213             # It is a libtool convenience library, so add in its objects.
2214             convenience="$convenience $ladir/$objdir/$old_library"
2215             old_convenience="$old_convenience $ladir/$objdir/$old_library"
2216             tmp_libs=
2217             for deplib in $dependency_libs; do
2218               deplibs="$deplib $deplibs"
2219               if test "X$duplicate_deps" = "Xyes" ; then
2220                 case "$tmp_libs " in
2221                 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2222                 esac
2223               fi
2224               tmp_libs="$tmp_libs $deplib"
2225             done
2226           elif test "$linkmode" != prog && test "$linkmode" != lib; then
2227             $echo "$modename: \`$lib' is not a convenience library" 1>&2
2228             exit $EXIT_FAILURE
2229           fi
2230           continue
2231         fi # $pass = conv
2232
2233
2234         # Get the name of the library we link against.
2235         linklib=
2236         for l in $old_library $library_names; do
2237           linklib="$l"
2238         done
2239         if test -z "$linklib"; then
2240           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2241           exit $EXIT_FAILURE
2242         fi
2243
2244         # This library was specified with -dlopen.
2245         if test "$pass" = dlopen; then
2246           if test -z "$libdir"; then
2247             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2248             exit $EXIT_FAILURE
2249           fi
2250           if test -z "$dlname" ||
2251              test "$dlopen_support" != yes ||
2252              test "$build_libtool_libs" = no; then
2253             # If there is no dlname, no dlopen support or we're linking
2254             # statically, we need to preload.  We also need to preload any
2255             # dependent libraries so libltdl's deplib preloader doesn't
2256             # bomb out in the load deplibs phase.
2257             dlprefiles="$dlprefiles $lib $dependency_libs"
2258           else
2259             newdlfiles="$newdlfiles $lib"
2260           fi
2261           continue
2262         fi # $pass = dlopen
2263
2264         # We need an absolute path.
2265         case $ladir in
2266         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2267         *)
2268           abs_ladir=`cd "$ladir" && pwd`
2269           if test -z "$abs_ladir"; then
2270             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2271             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2272             abs_ladir="$ladir"
2273           fi
2274           ;;
2275         esac
2276         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2277
2278         # Find the relevant object directory and library name.
2279         if test "X$installed" = Xyes; then
2280           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2281             $echo "$modename: warning: library \`$lib' was moved." 1>&2
2282             dir="$ladir"
2283             absdir="$abs_ladir"
2284             libdir="$abs_ladir"
2285           else
2286             dir="$libdir"
2287             absdir="$libdir"
2288           fi
2289         else
2290           if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2291             dir="$ladir"
2292             absdir="$abs_ladir"
2293             # Remove this search path later
2294             notinst_path="$notinst_path $abs_ladir"
2295           else
2296             dir="$ladir/$objdir"
2297             absdir="$abs_ladir/$objdir"
2298             # Remove this search path later
2299             notinst_path="$notinst_path $abs_ladir"
2300           fi
2301         fi # $installed = yes
2302         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2303
2304         # This library was specified with -dlpreopen.
2305         if test "$pass" = dlpreopen; then
2306           if test -z "$libdir"; then
2307             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2308             exit $EXIT_FAILURE
2309           fi
2310           # Prefer using a static library (so that no silly _DYNAMIC symbols
2311           # are required to link).
2312           if test -n "$old_library"; then
2313             newdlprefiles="$newdlprefiles $dir/$old_library"
2314           # Otherwise, use the dlname, so that lt_dlopen finds it.
2315           elif test -n "$dlname"; then
2316             newdlprefiles="$newdlprefiles $dir/$dlname"
2317           else
2318             newdlprefiles="$newdlprefiles $dir/$linklib"
2319           fi
2320         fi # $pass = dlpreopen
2321
2322         if test -z "$libdir"; then
2323           # Link the convenience library
2324           if test "$linkmode" = lib; then
2325             deplibs="$dir/$old_library $deplibs"
2326           elif test "$linkmode,$pass" = "prog,link"; then
2327             compile_deplibs="$dir/$old_library $compile_deplibs"
2328             finalize_deplibs="$dir/$old_library $finalize_deplibs"
2329           else
2330             deplibs="$lib $deplibs" # used for prog,scan pass
2331           fi
2332           continue
2333         fi
2334
2335
2336         if test "$linkmode" = prog && test "$pass" != link; then
2337           newlib_search_path="$newlib_search_path $ladir"
2338           deplibs="$lib $deplibs"
2339
2340           linkalldeplibs=no
2341           if test "$link_all_deplibs" != no || test -z "$library_names" ||
2342              test "$build_libtool_libs" = no; then
2343             linkalldeplibs=yes
2344           fi
2345
2346           tmp_libs=
2347           for deplib in $dependency_libs; do
2348             case $deplib in
2349             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2350             esac
2351             # Need to link against all dependency_libs?
2352             if test "$linkalldeplibs" = yes; then
2353               deplibs="$deplib $deplibs"
2354             else
2355               # Need to hardcode shared library paths
2356               # or/and link against static libraries
2357               newdependency_libs="$deplib $newdependency_libs"
2358             fi
2359             if test "X$duplicate_deps" = "Xyes" ; then
2360               case "$tmp_libs " in
2361               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2362               esac
2363             fi
2364             tmp_libs="$tmp_libs $deplib"
2365           done # for deplib
2366           continue
2367         fi # $linkmode = prog...
2368
2369         if test "$linkmode,$pass" = "prog,link"; then
2370           if test -n "$library_names" &&
2371              { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2372             # We need to hardcode the library path
2373             if test -n "$shlibpath_var"; then
2374               # Make sure the rpath contains only unique directories.
2375               case "$temp_rpath " in
2376               *" $dir "*) ;;
2377               *" $absdir "*) ;;
2378               *) temp_rpath="$temp_rpath $dir" ;;
2379               esac
2380             fi
2381
2382             # Hardcode the library path.
2383             # Skip directories that are in the system default run-time
2384             # search path.
2385             case " $sys_lib_dlsearch_path " in
2386             *" $absdir "*) ;;
2387             *)
2388               case "$compile_rpath " in
2389               *" $absdir "*) ;;
2390               *) compile_rpath="$compile_rpath $absdir"
2391               esac
2392               ;;
2393             esac
2394             case " $sys_lib_dlsearch_path " in
2395             *" $libdir "*) ;;
2396             *)
2397               case "$finalize_rpath " in
2398               *" $libdir "*) ;;
2399               *) finalize_rpath="$finalize_rpath $libdir"
2400               esac
2401               ;;
2402             esac
2403           fi # $linkmode,$pass = prog,link...
2404
2405           if test "$alldeplibs" = yes &&
2406              { test "$deplibs_check_method" = pass_all ||
2407                { test "$build_libtool_libs" = yes &&
2408                  test -n "$library_names"; }; }; then
2409             # We only need to search for static libraries
2410             continue
2411           fi
2412         fi
2413
2414         link_static=no # Whether the deplib will be linked statically
2415         if test -n "$library_names" &&
2416            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2417           if test "$installed" = no; then
2418             notinst_deplibs="$notinst_deplibs $lib"
2419             need_relink=yes
2420           fi
2421           # This is a shared library
2422
2423           # Warn about portability, can't link against -module's on
2424           # some systems (darwin)
2425           if test "$shouldnotlink" = yes && test "$pass" = link ; then
2426             $echo
2427             if test "$linkmode" = prog; then
2428               $echo "*** Warning: Linking the executable $output against the loadable module"
2429             else
2430               $echo "*** Warning: Linking the shared library $output against the loadable module"
2431             fi
2432             $echo "*** $linklib is not portable!"
2433           fi
2434           if test "$linkmode" = lib &&
2435              test "$hardcode_into_libs" = yes; then
2436             # Hardcode the library path.
2437             # Skip directories that are in the system default run-time
2438             # search path.
2439             case " $sys_lib_dlsearch_path " in
2440             *" $absdir "*) ;;
2441             *)
2442               case "$compile_rpath " in
2443               *" $absdir "*) ;;
2444               *) compile_rpath="$compile_rpath $absdir"
2445               esac
2446               ;;
2447             esac
2448             case " $sys_lib_dlsearch_path " in
2449             *" $libdir "*) ;;
2450             *)
2451               case "$finalize_rpath " in
2452               *" $libdir "*) ;;
2453               *) finalize_rpath="$finalize_rpath $libdir"
2454               esac
2455               ;;
2456             esac
2457           fi
2458
2459           if test -n "$old_archive_from_expsyms_cmds"; then
2460             # figure out the soname
2461             set dummy $library_names
2462             realname="$2"
2463             shift; shift
2464             libname=`eval \\$echo \"$libname_spec\"`
2465             # use dlname if we got it. it's perfectly good, no?
2466             if test -n "$dlname"; then
2467               soname="$dlname"
2468             elif test -n "$soname_spec"; then
2469               # bleh windows
2470               case $host in
2471               *cygwin* | mingw*)
2472                 major=`expr $current - $age`
2473                 versuffix="-$major"
2474                 ;;
2475               esac
2476               eval soname=\"$soname_spec\"
2477             else
2478               soname="$realname"
2479             fi
2480
2481             # Make a new name for the extract_expsyms_cmds to use
2482             soroot="$soname"
2483             soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2484             newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2485
2486             # If the library has no export list, then create one now
2487             if test -f "$output_objdir/$soname-def"; then :
2488             else
2489               $show "extracting exported symbol list from \`$soname'"
2490               save_ifs="$IFS"; IFS='~'
2491               cmds=$extract_expsyms_cmds
2492               for cmd in $cmds; do
2493                 IFS="$save_ifs"
2494                 eval cmd=\"$cmd\"
2495                 $show "$cmd"
2496                 $run eval "$cmd" || exit $?
2497               done
2498               IFS="$save_ifs"
2499             fi
2500
2501             # Create $newlib
2502             if test -f "$output_objdir/$newlib"; then :; else
2503               $show "generating import library for \`$soname'"
2504               save_ifs="$IFS"; IFS='~'
2505               cmds=$old_archive_from_expsyms_cmds
2506               for cmd in $cmds; do
2507                 IFS="$save_ifs"
2508                 eval cmd=\"$cmd\"
2509                 $show "$cmd"
2510                 $run eval "$cmd" || exit $?
2511               done
2512               IFS="$save_ifs"
2513             fi
2514             # make sure the library variables are pointing to the new library
2515             dir=$output_objdir
2516             linklib=$newlib
2517           fi # test -n "$old_archive_from_expsyms_cmds"
2518
2519           if test "$linkmode" = prog || test "$mode" != relink; then
2520             add_shlibpath=
2521             add_dir=
2522             add=
2523             lib_linked=yes
2524             case $hardcode_action in
2525             immediate | unsupported)
2526               if test "$hardcode_direct" = no; then
2527                 add="$dir/$linklib"
2528                 case $host in
2529                   *-*-sco3.2v5* ) add_dir="-L$dir" ;;
2530                   *-*-darwin* )
2531                     # if the lib is a module then we can not link against
2532                     # it, someone is ignoring the new warnings I added
2533                     if /usr/bin/file -L $add 2> /dev/null | $EGREP "bundle" >/dev/null ; then
2534                       $echo "** Warning, lib $linklib is a module, not a shared library"
2535                       if test -z "$old_library" ; then
2536                         $echo
2537                         $echo "** And there doesn't seem to be a static archive available"
2538                         $echo "** The link will probably fail, sorry"
2539                       else
2540                         add="$dir/$old_library"
2541                       fi
2542                     fi
2543                 esac
2544               elif test "$hardcode_minus_L" = no; then
2545                 case $host in
2546                 *-*-sunos*) add_shlibpath="$dir" ;;
2547                 esac
2548                 add_dir="-L$dir"
2549                 add="-l$name"
2550               elif test "$hardcode_shlibpath_var" = no; then
2551                 add_shlibpath="$dir"
2552                 add="-l$name"
2553               else
2554                 lib_linked=no
2555               fi
2556               ;;
2557             relink)
2558               if test "$hardcode_direct" = yes; then
2559                 add="$dir/$linklib"
2560               elif test "$hardcode_minus_L" = yes; then
2561                 add_dir="-L$dir"
2562                 # Try looking first in the location we're being installed to.
2563                 if test -n "$inst_prefix_dir"; then
2564                   case "$libdir" in
2565                     [\\/]*)
2566                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
2567                       ;;
2568                   esac
2569                 fi
2570                 add="-l$name"
2571               elif test "$hardcode_shlibpath_var" = yes; then
2572                 add_shlibpath="$dir"
2573                 add="-l$name"
2574               else
2575                 lib_linked=no
2576               fi
2577               ;;
2578             *) lib_linked=no ;;
2579             esac
2580
2581             if test "$lib_linked" != yes; then
2582               $echo "$modename: configuration error: unsupported hardcode properties"
2583               exit $EXIT_FAILURE
2584             fi
2585
2586             if test -n "$add_shlibpath"; then
2587               case :$compile_shlibpath: in
2588               *":$add_shlibpath:"*) ;;
2589               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2590               esac
2591             fi
2592             if test "$linkmode" = prog; then
2593               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2594               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2595             else
2596               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2597               test -n "$add" && deplibs="$add $deplibs"
2598               if test "$hardcode_direct" != yes && \
2599                  test "$hardcode_minus_L" != yes && \
2600                  test "$hardcode_shlibpath_var" = yes; then
2601                 case :$finalize_shlibpath: in
2602                 *":$libdir:"*) ;;
2603                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2604                 esac
2605               fi
2606             fi
2607           fi
2608
2609           if test "$linkmode" = prog || test "$mode" = relink; then
2610             add_shlibpath=
2611             add_dir=
2612             add=
2613             # Finalize command for both is simple: just hardcode it.
2614             if test "$hardcode_direct" = yes; then
2615               add="$libdir/$linklib"
2616             elif test "$hardcode_minus_L" = yes; then
2617               add_dir="-L$libdir"
2618               add="-l$name"
2619             elif test "$hardcode_shlibpath_var" = yes; then
2620               case :$finalize_shlibpath: in
2621               *":$libdir:"*) ;;
2622               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2623               esac
2624               add="-l$name"
2625             elif test "$hardcode_automatic" = yes; then
2626               if test -n "$inst_prefix_dir" &&
2627                  test -f "$inst_prefix_dir$libdir/$linklib" ; then
2628                 add="$inst_prefix_dir$libdir/$linklib"
2629               else
2630                 add="$libdir/$linklib"
2631               fi
2632             else
2633               # We cannot seem to hardcode it, guess we'll fake it.
2634               add_dir="-L$libdir"
2635               # Try looking first in the location we're being installed to.
2636               if test -n "$inst_prefix_dir"; then
2637                 case "$libdir" in
2638                   [\\/]*)
2639                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
2640                     ;;
2641                 esac
2642               fi
2643               add="-l$name"
2644             fi
2645
2646             if test "$linkmode" = prog; then
2647               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2648               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2649             else
2650               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2651               test -n "$add" && deplibs="$add $deplibs"
2652             fi
2653           fi
2654         elif test "$linkmode" = prog; then
2655           # Here we assume that one of hardcode_direct or hardcode_minus_L
2656           # is not unsupported.  This is valid on all known static and
2657           # shared platforms.
2658           if test "$hardcode_direct" != unsupported; then
2659             test -n "$old_library" && linklib="$old_library"
2660             compile_deplibs="$dir/$linklib $compile_deplibs"
2661             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2662           else
2663             compile_deplibs="-l$name -L$dir $compile_deplibs"
2664             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2665           fi
2666         elif test "$build_libtool_libs" = yes; then
2667           # Not a shared library
2668           if test "$deplibs_check_method" != pass_all; then
2669             # We're trying link a shared library against a static one
2670             # but the system doesn't support it.
2671
2672             # Just print a warning and add the library to dependency_libs so
2673             # that the program can be linked against the static library.
2674             $echo
2675             $echo "*** Warning: This system can not link to static lib archive $lib."
2676             $echo "*** I have the capability to make that library automatically link in when"
2677             $echo "*** you link to this library.  But I can only do this if you have a"
2678             $echo "*** shared version of the library, which you do not appear to have."
2679             if test "$module" = yes; then
2680               $echo "*** But as you try to build a module library, libtool will still create "
2681               $echo "*** a static module, that should work as long as the dlopening application"
2682               $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2683               if test -z "$global_symbol_pipe"; then
2684                 $echo
2685                 $echo "*** However, this would only work if libtool was able to extract symbol"
2686                 $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2687                 $echo "*** not find such a program.  So, this module is probably useless."
2688                 $echo "*** \`nm' from GNU binutils and a full rebuild may help."
2689               fi
2690               if test "$build_old_libs" = no; then
2691                 build_libtool_libs=module
2692                 build_old_libs=yes
2693               else
2694                 build_libtool_libs=no
2695               fi
2696             fi
2697           else
2698             convenience="$convenience $dir/$old_library"
2699             old_convenience="$old_convenience $dir/$old_library"
2700             deplibs="$dir/$old_library $deplibs"
2701             link_static=yes
2702           fi
2703         fi # link shared/static library?
2704
2705         if test "$linkmode" = lib; then
2706           if test -n "$dependency_libs" &&
2707              { test "$hardcode_into_libs" != yes ||
2708                test "$build_old_libs" = yes ||
2709                test "$link_static" = yes; }; then
2710             # Extract -R from dependency_libs
2711             temp_deplibs=
2712             for libdir in $dependency_libs; do
2713               case $libdir in
2714               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2715                    case " $xrpath " in
2716                    *" $temp_xrpath "*) ;;
2717                    *) xrpath="$xrpath $temp_xrpath";;
2718                    esac;;
2719               *) temp_deplibs="$temp_deplibs $libdir";;
2720               esac
2721             done
2722             dependency_libs="$temp_deplibs"
2723           fi
2724
2725           newlib_search_path="$newlib_search_path $absdir"
2726           # Link against this library
2727           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2728           # ... and its dependency_libs
2729           tmp_libs=
2730           for deplib in $dependency_libs; do
2731             newdependency_libs="$deplib $newdependency_libs"
2732             if test "X$duplicate_deps" = "Xyes" ; then
2733               case "$tmp_libs " in
2734               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2735               esac
2736             fi
2737             tmp_libs="$tmp_libs $deplib"
2738           done
2739
2740           if test "$link_all_deplibs" != no; then
2741             # Add the search paths of all dependency libraries
2742             for deplib in $dependency_libs; do
2743               case $deplib in
2744               -L*) path="$deplib" ;;
2745               *.la)
2746                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2747                 test "X$dir" = "X$deplib" && dir="."
2748                 # We need an absolute path.
2749                 case $dir in
2750                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2751                 *)
2752                   absdir=`cd "$dir" && pwd`
2753                   if test -z "$absdir"; then
2754                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2755                     absdir="$dir"
2756                   fi
2757                   ;;
2758                 esac
2759                 if grep "^installed=no" $deplib > /dev/null; then
2760                   path="$absdir/$objdir"
2761                 else
2762                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2763                   if test -z "$libdir"; then
2764                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2765                     exit $EXIT_FAILURE
2766                   fi
2767                   if test "$absdir" != "$libdir"; then
2768                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2769                   fi
2770                   path="$absdir"
2771                 fi
2772                 depdepl=
2773                 case $host in
2774                 *-*-darwin*)
2775                   # we do not want to link against static libs,
2776                   # but need to link against shared
2777                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2778                   if test -n "$deplibrary_names" ; then
2779                     for tmp in $deplibrary_names ; do
2780                       depdepl=$tmp
2781                     done
2782                     if test -f "$path/$depdepl" ; then
2783                       depdepl="$path/$depdepl"
2784                     fi
2785                     # do not add paths which are already there
2786                     case " $newlib_search_path " in
2787                     *" $path "*) ;;
2788                     *) newlib_search_path="$newlib_search_path $path";;
2789                     esac
2790                   fi
2791                   path=""
2792                   ;;
2793                 *)
2794                   path="-L$path"
2795                   ;;
2796                 esac
2797                 ;;
2798               -l*)
2799                 case $host in
2800                 *-*-darwin*)
2801                   # Again, we only want to link against shared libraries
2802                   eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2803                   for tmp in $newlib_search_path ; do
2804                     if test -f "$tmp/lib$tmp_libs.dylib" ; then
2805                       eval depdepl="$tmp/lib$tmp_libs.dylib"
2806                       break
2807                     fi
2808                   done
2809                   path=""
2810                   ;;
2811                 *) continue ;;
2812                 esac
2813                 ;;
2814               *) continue ;;
2815               esac
2816               case " $deplibs " in
2817               *" $depdepl "*) ;;
2818               *) deplibs="$depdepl $deplibs" ;;
2819               esac
2820               case " $deplibs " in
2821               *" $path "*) ;;
2822               *) deplibs="$deplibs $path" ;;
2823               esac
2824             done
2825           fi # link_all_deplibs != no
2826         fi # linkmode = lib
2827       done # for deplib in $libs
2828       dependency_libs="$newdependency_libs"
2829       if test "$pass" = dlpreopen; then
2830         # Link the dlpreopened libraries before other libraries
2831         for deplib in $save_deplibs; do
2832           deplibs="$deplib $deplibs"
2833         done
2834       fi
2835       if test "$pass" != dlopen; then
2836         if test "$pass" != conv; then
2837           # Make sure lib_search_path contains only unique directories.
2838           lib_search_path=
2839           for dir in $newlib_search_path; do
2840             case "$lib_search_path " in
2841             *" $dir "*) ;;
2842             *) lib_search_path="$lib_search_path $dir" ;;
2843             esac
2844           done
2845           newlib_search_path=
2846         fi
2847
2848         if test "$linkmode,$pass" != "prog,link"; then
2849           vars="deplibs"
2850         else
2851           vars="compile_deplibs finalize_deplibs"
2852         fi
2853         for var in $vars dependency_libs; do
2854           # Add libraries to $var in reverse order
2855           eval tmp_libs=\"\$$var\"
2856           new_libs=
2857           for deplib in $tmp_libs; do
2858             # FIXME: Pedantically, this is the right thing to do, so
2859             #        that some nasty dependency loop isn't accidentally
2860             #        broken:
2861             #new_libs="$deplib $new_libs"
2862             # Pragmatically, this seems to cause very few problems in
2863             # practice:
2864             case $deplib in
2865             -L*) new_libs="$deplib $new_libs" ;;
2866             -R*) ;;
2867             *)
2868               # And here is the reason: when a library appears more
2869               # than once as an explicit dependence of a library, or
2870               # is implicitly linked in more than once by the
2871               # compiler, it is considered special, and multiple
2872               # occurrences thereof are not removed.  Compare this
2873               # with having the same library being listed as a
2874               # dependency of multiple other libraries: in this case,
2875               # we know (pedantically, we assume) the library does not
2876               # need to be listed more than once, so we keep only the
2877               # last copy.  This is not always right, but it is rare
2878               # enough that we require users that really mean to play
2879               # such unportable linking tricks to link the library
2880               # using -Wl,-lname, so that libtool does not consider it
2881               # for duplicate removal.
2882               case " $specialdeplibs " in
2883               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2884               *)
2885                 case " $new_libs " in
2886                 *" $deplib "*) ;;
2887                 *) new_libs="$deplib $new_libs" ;;
2888                 esac
2889                 ;;
2890               esac
2891               ;;
2892             esac
2893           done
2894           tmp_libs=
2895           for deplib in $new_libs; do
2896             case $deplib in
2897             -L*)
2898               case " $tmp_libs " in
2899               *" $deplib "*) ;;
2900               *) tmp_libs="$tmp_libs $deplib" ;;
2901               esac
2902               ;;
2903             *) tmp_libs="$tmp_libs $deplib" ;;
2904             esac
2905           done
2906           eval $var=\"$tmp_libs\"
2907         done # for var
2908       fi
2909       # Last step: remove runtime libs from dependency_libs
2910       # (they stay in deplibs)
2911       tmp_libs=
2912       for i in $dependency_libs ; do
2913         case " $predeps $postdeps $compiler_lib_search_path " in
2914         *" $i "*)
2915           i=""
2916           ;;
2917         esac
2918         if test -n "$i" ; then
2919           tmp_libs="$tmp_libs $i"
2920         fi
2921       done
2922       dependency_libs=$tmp_libs
2923     done # for pass
2924     if test "$linkmode" = prog; then
2925       dlfiles="$newdlfiles"
2926       dlprefiles="$newdlprefiles"
2927     fi
2928
2929     case $linkmode in
2930     oldlib)
2931       if test -n "$deplibs"; then
2932         $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
2933       fi
2934
2935       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2936         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2937       fi
2938
2939       if test -n "$rpath"; then
2940         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2941       fi
2942
2943       if test -n "$xrpath"; then
2944         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2945       fi
2946
2947       if test -n "$vinfo"; then
2948         $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
2949       fi
2950
2951       if test -n "$release"; then
2952         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2953       fi
2954
2955       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2956         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2957       fi
2958
2959       # Now set the variables for building old libraries.
2960       build_libtool_libs=no
2961       oldlibs="$output"
2962       objs="$objs$old_deplibs"
2963       ;;
2964
2965     lib)
2966       # Make sure we only generate libraries of the form `libNAME.la'.
2967       case $outputname in
2968       lib*)
2969         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2970         eval shared_ext=\"$shrext_cmds\"
2971         eval libname=\"$libname_spec\"
2972         ;;
2973       *)
2974         if test "$module" = no; then
2975           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2976           $echo "$help" 1>&2
2977           exit $EXIT_FAILURE
2978         fi
2979         if test "$need_lib_prefix" != no; then
2980           # Add the "lib" prefix for modules if required
2981           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2982           eval shared_ext=\"$shrext_cmds\"
2983           eval libname=\"$libname_spec\"
2984         else
2985           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2986         fi
2987         ;;
2988       esac
2989
2990       if test -n "$objs"; then
2991         if test "$deplibs_check_method" != pass_all; then
2992           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2993           exit $EXIT_FAILURE
2994         else
2995           $echo
2996           $echo "*** Warning: Linking the shared library $output against the non-libtool"
2997           $echo "*** objects $objs is not portable!"
2998           libobjs="$libobjs $objs"
2999         fi
3000       fi
3001
3002       if test "$dlself" != no; then
3003         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
3004       fi
3005
3006       set dummy $rpath
3007       if test "$#" -gt 2; then
3008         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
3009       fi
3010       install_libdir="$2"
3011
3012       oldlibs=
3013       if test -z "$rpath"; then
3014         if test "$build_libtool_libs" = yes; then
3015           # Building a libtool convenience library.
3016           # Some compilers have problems with a `.al' extension so
3017           # convenience libraries should have the same extension an
3018           # archive normally would.
3019           oldlibs="$output_objdir/$libname.$libext $oldlibs"
3020           build_libtool_libs=convenience
3021           build_old_libs=yes
3022         fi
3023
3024         if test -n "$vinfo"; then
3025           $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
3026         fi
3027
3028         if test -n "$release"; then
3029           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
3030         fi
3031       else
3032
3033         # Parse the version information argument.
3034         save_ifs="$IFS"; IFS=':'
3035         set dummy $vinfo 0 0 0
3036         IFS="$save_ifs"
3037
3038         if test -n "$8"; then
3039           $echo "$modename: too many parameters to \`-version-info'" 1>&2
3040           $echo "$help" 1>&2
3041           exit $EXIT_FAILURE
3042         fi
3043
3044         # convert absolute version numbers to libtool ages
3045         # this retains compatibility with .la files and attempts
3046         # to make the code below a bit more comprehensible
3047
3048         case $vinfo_number in
3049         yes)
3050           number_major="$2"
3051           number_minor="$3"
3052           number_revision="$4"
3053           #
3054           # There are really only two kinds -- those that
3055           # use the current revision as the major version
3056           # and those that subtract age and use age as
3057           # a minor version.  But, then there is irix
3058           # which has an extra 1 added just for fun
3059           #
3060           case $version_type in
3061           darwin|linux|osf|windows)
3062             current=`expr $number_major + $number_minor`
3063             age="$number_minor"
3064             revision="$number_revision"
3065             ;;
3066           freebsd-aout|freebsd-elf|sunos)
3067             current="$number_major"
3068             revision="$number_minor"
3069             age="0"
3070             ;;
3071           irix|nonstopux)
3072             current=`expr $number_major + $number_minor - 1`
3073             age="$number_minor"
3074             revision="$number_minor"
3075             ;;
3076           esac
3077           ;;
3078         no)
3079           current="$2"
3080           revision="$3"
3081           age="$4"
3082           ;;
3083         esac
3084
3085         # Check that each of the things are valid numbers.
3086         case $current in
3087         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
3088         *)
3089           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
3090           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3091           exit $EXIT_FAILURE
3092           ;;
3093         esac
3094
3095         case $revision in
3096         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
3097         *)
3098           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
3099           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3100           exit $EXIT_FAILURE
3101           ;;
3102         esac
3103
3104         case $age in
3105         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
3106         *)
3107           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
3108           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3109           exit $EXIT_FAILURE
3110           ;;
3111         esac
3112
3113         if test "$age" -gt "$current"; then
3114           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
3115           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3116           exit $EXIT_FAILURE
3117         fi
3118
3119         # Calculate the version variables.
3120         major=
3121         versuffix=
3122         verstring=
3123         case $version_type in
3124         none) ;;
3125
3126         darwin)
3127           # Like Linux, but with the current version available in
3128           # verstring for coding it into the library header
3129           major=.`expr $current - $age`
3130           versuffix="$major.$age.$revision"
3131           # Darwin ld doesn't like 0 for these options...
3132           minor_current=`expr $current + 1`
3133           verstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
3134           ;;
3135
3136         freebsd-aout)
3137           major=".$current"
3138           versuffix=".$current.$revision";
3139           ;;
3140
3141         freebsd-elf)
3142           major=".$current"
3143           versuffix=".$current";
3144           ;;
3145
3146         irix | nonstopux)
3147           major=`expr $current - $age + 1`
3148
3149           case $version_type in
3150             nonstopux) verstring_prefix=nonstopux ;;
3151             *)         verstring_prefix=sgi ;;
3152           esac
3153           verstring="$verstring_prefix$major.$revision"
3154
3155           # Add in all the interfaces that we are compatible with.
3156           loop=$revision
3157           while test "$loop" -ne 0; do
3158             iface=`expr $revision - $loop`
3159             loop=`expr $loop - 1`
3160             verstring="$verstring_prefix$major.$iface:$verstring"
3161           done
3162
3163           # Before this point, $major must not contain `.'.
3164           major=.$major
3165           versuffix="$major.$revision"
3166           ;;
3167
3168         linux)
3169           major=.`expr $current - $age`
3170           versuffix="$major.$age.$revision"
3171           ;;
3172
3173         osf)
3174           major=.`expr $current - $age`
3175           versuffix=".$current.$age.$revision"
3176           verstring="$current.$age.$revision"
3177
3178           # Add in all the interfaces that we are compatible with.
3179           loop=$age
3180           while test "$loop" -ne 0; do
3181             iface=`expr $current - $loop`
3182             loop=`expr $loop - 1`
3183             verstring="$verstring:${iface}.0"
3184           done
3185
3186           # Make executables depend on our current version.
3187           verstring="$verstring:${current}.0"
3188           ;;
3189
3190         sunos)
3191           major=".$current"
3192           versuffix=".$current.$revision"
3193           ;;
3194
3195         windows)
3196           # Use '-' rather than '.', since we only want one
3197           # extension on DOS 8.3 filesystems.
3198           major=`expr $current - $age`
3199           versuffix="-$major"
3200           ;;
3201
3202         *)
3203           $echo "$modename: unknown library version type \`$version_type'" 1>&2
3204           $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3205           exit $EXIT_FAILURE
3206           ;;
3207         esac
3208
3209         # Clear the version info if we defaulted, and they specified a release.
3210         if test -z "$vinfo" && test -n "$release"; then
3211           major=
3212           case $version_type in
3213           darwin)
3214             # we can't check for "0.0" in archive_cmds due to quoting
3215             # problems, so we reset it completely
3216             verstring=
3217             ;;
3218           *)
3219             verstring="0.0"
3220             ;;
3221           esac
3222           if test "$need_version" = no; then
3223             versuffix=
3224           else
3225             versuffix=".0.0"
3226           fi
3227         fi
3228
3229         # Remove version info from name if versioning should be avoided
3230         if test "$avoid_version" = yes && test "$need_version" = no; then
3231           major=
3232           versuffix=
3233           verstring=""
3234         fi
3235
3236         # Check to see if the archive will have undefined symbols.
3237         if test "$allow_undefined" = yes; then
3238           if test "$allow_undefined_flag" = unsupported; then
3239             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3240             build_libtool_libs=no
3241             build_old_libs=yes
3242           fi
3243         else
3244           # Don't allow undefined symbols.
3245           allow_undefined_flag="$no_undefined_flag"
3246         fi
3247       fi
3248
3249       if test "$mode" != relink; then
3250         # Remove our outputs, but don't remove object files since they
3251         # may have been created when compiling PIC objects.
3252         removelist=
3253         tempremovelist=`$echo "$output_objdir/*"`
3254         for p in $tempremovelist; do
3255           case $p in
3256             *.$objext)
3257                ;;
3258             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3259                if test "X$precious_files_regex" != "X"; then
3260                  if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3261                  then
3262                    continue
3263                  fi
3264                fi
3265                removelist="$removelist $p"
3266                ;;
3267             *) ;;
3268           esac
3269         done
3270         if test -n "$removelist"; then
3271           $show "${rm}r $removelist"
3272           $run ${rm}r $removelist
3273         fi
3274       fi
3275
3276       # Now set the variables for building old libraries.
3277       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3278         oldlibs="$oldlibs $output_objdir/$libname.$libext"
3279
3280         # Transform .lo files to .o files.
3281         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3282       fi
3283
3284       # Eliminate all temporary directories.
3285       for path in $notinst_path; do
3286         lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
3287         deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
3288         dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
3289       done
3290
3291       if test -n "$xrpath"; then
3292         # If the user specified any rpath flags, then add them.
3293         temp_xrpath=
3294         for libdir in $xrpath; do
3295           temp_xrpath="$temp_xrpath -R$libdir"
3296           case "$finalize_rpath " in
3297           *" $libdir "*) ;;
3298           *) finalize_rpath="$finalize_rpath $libdir" ;;
3299           esac
3300         done
3301         if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3302           dependency_libs="$temp_xrpath $dependency_libs"
3303         fi
3304       fi
3305
3306       # Make sure dlfiles contains only unique files that won't be dlpreopened
3307       old_dlfiles="$dlfiles"
3308       dlfiles=
3309       for lib in $old_dlfiles; do
3310         case " $dlprefiles $dlfiles " in
3311         *" $lib "*) ;;
3312         *) dlfiles="$dlfiles $lib" ;;
3313         esac
3314       done
3315
3316       # Make sure dlprefiles contains only unique files
3317       old_dlprefiles="$dlprefiles"
3318       dlprefiles=
3319       for lib in $old_dlprefiles; do
3320         case "$dlprefiles " in
3321         *" $lib "*) ;;
3322         *) dlprefiles="$dlprefiles $lib" ;;
3323         esac
3324       done
3325
3326       if test "$build_libtool_libs" = yes; then
3327         if test -n "$rpath"; then
3328           case $host in
3329           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3330             # these systems don't actually have a c library (as such)!
3331             ;;
3332           *-*-rhapsody* | *-*-darwin1.[012])
3333             # Rhapsody C library is in the System framework
3334             deplibs="$deplibs -framework System"
3335             ;;
3336           *-*-netbsd*)
3337             # Don't link with libc until the a.out ld.so is fixed.
3338             ;;
3339           *-*-openbsd* | *-*-freebsd*)
3340             # Do not include libc due to us having libc/libc_r.
3341             test "X$arg" = "X-lc" && continue
3342             ;;
3343           *)
3344             # Add libc to deplibs on all other systems if necessary.
3345             if test "$build_libtool_need_lc" = "yes"; then
3346               deplibs="$deplibs -lc"
3347             fi
3348             ;;
3349           esac
3350         fi
3351
3352         # Transform deplibs into only deplibs that can be linked in shared.
3353         name_save=$name
3354         libname_save=$libname
3355         release_save=$release
3356         versuffix_save=$versuffix
3357         major_save=$major
3358         # I'm not sure if I'm treating the release correctly.  I think
3359         # release should show up in the -l (ie -lgmp5) so we don't want to
3360         # add it in twice.  Is that correct?
3361         release=""
3362         versuffix=""
3363         major=""
3364         newdeplibs=
3365         droppeddeps=no
3366         case $deplibs_check_method in
3367         pass_all)
3368           # Don't check for shared/static.  Everything works.
3369           # This might be a little naive.  We might want to check
3370           # whether the library exists or not.  But this is on
3371           # osf3 & osf4 and I'm not really sure... Just
3372           # implementing what was already the behavior.
3373           newdeplibs=$deplibs
3374           ;;
3375         test_compile)
3376           # This code stresses the "libraries are programs" paradigm to its
3377           # limits. Maybe even breaks it.  We compile a program, linking it
3378           # against the deplibs as a proxy for the library.  Then we can check
3379           # whether they linked in statically or dynamically with ldd.
3380           $rm conftest.c
3381           cat > conftest.c <<EOF
3382           int main() { return 0; }
3383 EOF
3384           $rm conftest
3385           $LTCC -o conftest conftest.c $deplibs
3386           if test "$?" -eq 0 ; then
3387             ldd_output=`ldd conftest`
3388             for i in $deplibs; do
3389               name="`expr $i : '-l\(.*\)'`"
3390               # If $name is empty we are operating on a -L argument.
3391               if test "$name" != "" && test "$name" -ne "0"; then
3392                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3393                   case " $predeps $postdeps " in
3394                   *" $i "*)
3395                     newdeplibs="$newdeplibs $i"
3396                     i=""
3397                     ;;
3398                   esac
3399                 fi
3400                 if test -n "$i" ; then
3401                   libname=`eval \\$echo \"$libname_spec\"`
3402                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
3403                   set dummy $deplib_matches
3404                   deplib_match=$2
3405                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3406                     newdeplibs="$newdeplibs $i"
3407                   else
3408                     droppeddeps=yes
3409                     $echo
3410                     $echo "*** Warning: dynamic linker does not accept needed library $i."
3411                     $echo "*** I have the capability to make that library automatically link in when"
3412                     $echo "*** you link to this library.  But I can only do this if you have a"
3413                     $echo "*** shared version of the library, which I believe you do not have"
3414                     $echo "*** because a test_compile did reveal that the linker did not use it for"
3415                     $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3416                   fi
3417                 fi
3418               else
3419                 newdeplibs="$newdeplibs $i"
3420               fi
3421             done
3422           else
3423             # Error occurred in the first compile.  Let's try to salvage
3424             # the situation: Compile a separate program for each library.
3425             for i in $deplibs; do
3426               name="`expr $i : '-l\(.*\)'`"
3427               # If $name is empty we are operating on a -L argument.
3428               if test "$name" != "" && test "$name" != "0"; then
3429                 $rm conftest
3430                 $LTCC -o conftest conftest.c $i
3431                 # Did it work?
3432                 if test "$?" -eq 0 ; then
3433                   ldd_output=`ldd conftest`
3434                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3435                     case " $predeps $postdeps " in
3436                     *" $i "*)
3437                       newdeplibs="$newdeplibs $i"
3438                       i=""
3439                       ;;
3440                     esac
3441                   fi
3442                   if test -n "$i" ; then
3443                     libname=`eval \\$echo \"$libname_spec\"`
3444                     deplib_matches=`eval \\$echo \"$library_names_spec\"`
3445                     set dummy $deplib_matches
3446                     deplib_match=$2
3447                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3448                       newdeplibs="$newdeplibs $i"
3449                     else
3450                       droppeddeps=yes
3451                       $echo
3452                       $echo "*** Warning: dynamic linker does not accept needed library $i."
3453                       $echo "*** I have the capability to make that library automatically link in when"
3454                       $echo "*** you link to this library.  But I can only do this if you have a"
3455                       $echo "*** shared version of the library, which you do not appear to have"
3456                       $echo "*** because a test_compile did reveal that the linker did not use this one"
3457                       $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3458                     fi
3459                   fi
3460                 else
3461                   droppeddeps=yes
3462                   $echo
3463                   $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3464                   $echo "***  make it link in!  You will probably need to install it or some"
3465                   $echo "*** library that it depends on before this library will be fully"
3466                   $echo "*** functional.  Installing it before continuing would be even better."
3467                 fi
3468               else
3469                 newdeplibs="$newdeplibs $i"
3470               fi
3471             done
3472           fi
3473           ;;
3474         file_magic*)
3475           set dummy $deplibs_check_method
3476           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3477           for a_deplib in $deplibs; do
3478             name="`expr $a_deplib : '-l\(.*\)'`"
3479             # If $name is empty we are operating on a -L argument.
3480             if test "$name" != "" && test  "$name" != "0"; then
3481               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3482                 case " $predeps $postdeps " in
3483                 *" $a_deplib "*)
3484                   newdeplibs="$newdeplibs $a_deplib"