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"
3485                   a_deplib=""
3486                   ;;
3487                 esac
3488               fi
3489               if test -n "$a_deplib" ; then
3490                 libname=`eval \\$echo \"$libname_spec\"`
3491                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3492                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3493                   for potent_lib in $potential_libs; do
3494                       # Follow soft links.
3495                       if ls -lLd "$potent_lib" 2>/dev/null \
3496                          | grep " -> " >/dev/null; then
3497                         continue
3498                       fi
3499                       # The statement above tries to avoid entering an
3500                       # endless loop below, in case of cyclic links.
3501                       # We might still enter an endless loop, since a link
3502                       # loop can be closed while we follow links,
3503                       # but so what?
3504                       potlib="$potent_lib"
3505                       while test -h "$potlib" 2>/dev/null; do
3506                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3507                         case $potliblink in
3508                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3509                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
3510                         esac
3511                       done
3512                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3513                          | ${SED} 10q \
3514                          | $EGREP "$file_magic_regex" > /dev/null; then
3515                         newdeplibs="$newdeplibs $a_deplib"
3516                         a_deplib=""
3517                         break 2
3518                       fi
3519                   done
3520                 done
3521               fi
3522               if test -n "$a_deplib" ; then
3523                 droppeddeps=yes
3524                 $echo
3525                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3526                 $echo "*** I have the capability to make that library automatically link in when"
3527                 $echo "*** you link to this library.  But I can only do this if you have a"
3528                 $echo "*** shared version of the library, which you do not appear to have"
3529                 $echo "*** because I did check the linker path looking for a file starting"
3530                 if test -z "$potlib" ; then
3531                   $echo "*** with $libname but no candidates were found. (...for file magic test)"
3532                 else
3533                   $echo "*** with $libname and none of the candidates passed a file format test"
3534                   $echo "*** using a file magic. Last file checked: $potlib"
3535                 fi
3536               fi
3537             else
3538               # Add a -L argument.
3539               newdeplibs="$newdeplibs $a_deplib"
3540             fi
3541           done # Gone through all deplibs.
3542           ;;
3543         match_pattern*)
3544           set dummy $deplibs_check_method
3545           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3546           for a_deplib in $deplibs; do
3547             name="`expr $a_deplib : '-l\(.*\)'`"
3548             # If $name is empty we are operating on a -L argument.
3549             if test -n "$name" && test "$name" != "0"; then
3550               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3551                 case " $predeps $postdeps " in
3552                 *" $a_deplib "*)
3553                   newdeplibs="$newdeplibs $a_deplib"
3554                   a_deplib=""
3555                   ;;
3556                 esac
3557               fi
3558               if test -n "$a_deplib" ; then
3559                 libname=`eval \\$echo \"$libname_spec\"`
3560                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3561                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3562                   for potent_lib in $potential_libs; do
3563                     potlib="$potent_lib" # see symlink-check above in file_magic test
3564                     if eval $echo \"$potent_lib\" 2>/dev/null \
3565                         | ${SED} 10q \
3566                         | $EGREP "$match_pattern_regex" > /dev/null; then
3567                       newdeplibs="$newdeplibs $a_deplib"
3568                       a_deplib=""
3569                       break 2
3570                     fi
3571                   done
3572                 done
3573               fi
3574               if test -n "$a_deplib" ; then
3575                 droppeddeps=yes
3576                 $echo
3577                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3578                 $echo "*** I have the capability to make that library automatically link in when"
3579                 $echo "*** you link to this library.  But I can only do this if you have a"
3580                 $echo "*** shared version of the library, which you do not appear to have"
3581                 $echo "*** because I did check the linker path looking for a file starting"
3582                 if test -z "$potlib" ; then
3583                   $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
3584                 else
3585                   $echo "*** with $libname and none of the candidates passed a file format test"
3586                   $echo "*** using a regex pattern. Last file checked: $potlib"
3587                 fi
3588               fi
3589             else
3590               # Add a -L argument.
3591               newdeplibs="$newdeplibs $a_deplib"
3592             fi
3593           done # Gone through all deplibs.
3594           ;;
3595         none | unknown | *)
3596           newdeplibs=""
3597           tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3598             -e 's/ -[LR][^ ]*//g'`
3599           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3600             for i in $predeps $postdeps ; do
3601               # can't use Xsed below, because $i might contain '/'
3602               tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
3603             done
3604           fi
3605           if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
3606             | grep . >/dev/null; then
3607             $echo
3608             if test "X$deplibs_check_method" = "Xnone"; then
3609               $echo "*** Warning: inter-library dependencies are not supported in this platform."
3610             else
3611               $echo "*** Warning: inter-library dependencies are not known to be supported."
3612             fi
3613             $echo "*** All declared inter-library dependencies are being dropped."
3614             droppeddeps=yes
3615           fi
3616           ;;
3617         esac
3618         versuffix=$versuffix_save
3619         major=$major_save
3620         release=$release_save
3621         libname=$libname_save
3622         name=$name_save
3623
3624         case $host in
3625         *-*-rhapsody* | *-*-darwin1.[012])
3626           # On Rhapsody replace the C library is the System framework
3627           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3628           ;;
3629         esac
3630
3631         if test "$droppeddeps" = yes; then
3632           if test "$module" = yes; then
3633             $echo
3634             $echo "*** Warning: libtool could not satisfy all declared inter-library"
3635             $echo "*** dependencies of module $libname.  Therefore, libtool will create"
3636             $echo "*** a static module, that should work as long as the dlopening"
3637             $echo "*** application is linked with the -dlopen flag."
3638             if test -z "$global_symbol_pipe"; then
3639               $echo
3640               $echo "*** However, this would only work if libtool was able to extract symbol"
3641               $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3642               $echo "*** not find such a program.  So, this module is probably useless."
3643               $echo "*** \`nm' from GNU binutils and a full rebuild may help."
3644             fi
3645             if test "$build_old_libs" = no; then
3646               oldlibs="$output_objdir/$libname.$libext"
3647               build_libtool_libs=module
3648               build_old_libs=yes
3649             else
3650               build_libtool_libs=no
3651             fi
3652           else
3653             $echo "*** The inter-library dependencies that have been dropped here will be"
3654             $echo "*** automatically added whenever a program is linked with this library"
3655             $echo "*** or is declared to -dlopen it."
3656
3657             if test "$allow_undefined" = no; then
3658               $echo
3659               $echo "*** Since this library must not contain undefined symbols,"
3660               $echo "*** because either the platform does not support them or"
3661               $echo "*** it was explicitly requested with -no-undefined,"
3662               $echo "*** libtool will only create a static version of it."
3663               if test "$build_old_libs" = no; then
3664                 oldlibs="$output_objdir/$libname.$libext"
3665                 build_libtool_libs=module
3666                 build_old_libs=yes
3667               else
3668                 build_libtool_libs=no
3669               fi
3670             fi
3671           fi
3672         fi
3673         # Done checking deplibs!
3674         deplibs=$newdeplibs
3675       fi
3676
3677       # All the library-specific variables (install_libdir is set above).
3678       library_names=
3679       old_library=
3680       dlname=
3681
3682       # Test again, we may have decided not to build it any more
3683       if test "$build_libtool_libs" = yes; then
3684         if test "$hardcode_into_libs" = yes; then
3685           # Hardcode the library paths
3686           hardcode_libdirs=
3687           dep_rpath=
3688           rpath="$finalize_rpath"
3689           test "$mode" != relink && rpath="$compile_rpath$rpath"
3690           for libdir in $rpath; do
3691             if test -n "$hardcode_libdir_flag_spec"; then
3692               if test -n "$hardcode_libdir_separator"; then
3693                 if test -z "$hardcode_libdirs"; then
3694                   hardcode_libdirs="$libdir"
3695                 else
3696                   # Just accumulate the unique libdirs.
3697                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3698                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3699                     ;;
3700                   *)
3701                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3702                     ;;
3703                   esac
3704                 fi
3705               else
3706                 eval flag=\"$hardcode_libdir_flag_spec\"
3707                 dep_rpath="$dep_rpath $flag"
3708               fi
3709             elif test -n "$runpath_var"; then
3710               case "$perm_rpath " in
3711               *" $libdir "*) ;;
3712               *) perm_rpath="$perm_rpath $libdir" ;;
3713               esac
3714             fi
3715           done
3716           # Substitute the hardcoded libdirs into the rpath.
3717           if test -n "$hardcode_libdir_separator" &&
3718              test -n "$hardcode_libdirs"; then
3719             libdir="$hardcode_libdirs"
3720             if test -n "$hardcode_libdir_flag_spec_ld"; then
3721               eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
3722             else
3723               eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3724             fi
3725           fi
3726           if test -n "$runpath_var" && test -n "$perm_rpath"; then
3727             # We should set the runpath_var.
3728             rpath=
3729             for dir in $perm_rpath; do
3730               rpath="$rpath$dir:"
3731             done
3732             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3733           fi
3734           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3735         fi
3736
3737         shlibpath="$finalize_shlibpath"
3738         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3739         if test -n "$shlibpath"; then
3740           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3741         fi
3742
3743         # Get the real and link names of the library.
3744         eval shared_ext=\"$shrext_cmds\"
3745         eval library_names=\"$library_names_spec\"
3746         set dummy $library_names
3747         realname="$2"
3748         shift; shift
3749
3750         if test -n "$soname_spec"; then
3751           eval soname=\"$soname_spec\"
3752         else
3753           soname="$realname"
3754         fi
3755         if test -z "$dlname"; then
3756           dlname=$soname
3757         fi
3758
3759         lib="$output_objdir/$realname"
3760         for link
3761         do
3762           linknames="$linknames $link"
3763         done
3764
3765         # Use standard objects if they are pic
3766         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3767
3768         # Prepare the list of exported symbols
3769         if test -z "$export_symbols"; then
3770           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3771             $show "generating symbol list for \`$libname.la'"
3772             export_symbols="$output_objdir/$libname.exp"
3773             $run $rm $export_symbols
3774             cmds=$export_symbols_cmds
3775             save_ifs="$IFS"; IFS='~'
3776             for cmd in $cmds; do
3777               IFS="$save_ifs"
3778               eval cmd=\"$cmd\"
3779               if len=`expr "X$cmd" : ".*"` &&
3780                test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3781                 $show "$cmd"
3782                 $run eval "$cmd" || exit $?
3783                 skipped_export=false
3784               else
3785                 # The command line is too long to execute in one step.
3786                 $show "using reloadable object file for export list..."
3787                 skipped_export=:
3788               fi
3789             done
3790             IFS="$save_ifs"
3791             if test -n "$export_symbols_regex"; then
3792               $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3793               $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3794               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3795               $run eval '$mv "${export_symbols}T" "$export_symbols"'
3796             fi
3797           fi
3798         fi
3799
3800         if test -n "$export_symbols" && test -n "$include_expsyms"; then
3801           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3802         fi
3803
3804         tmp_deplibs=
3805         for test_deplib in $deplibs; do
3806                 case " $convenience " in
3807                 *" $test_deplib "*) ;;
3808                 *)
3809                         tmp_deplibs="$tmp_deplibs $test_deplib"
3810                         ;;
3811                 esac
3812         done
3813         deplibs="$tmp_deplibs"
3814
3815         if test -n "$convenience"; then
3816           if test -n "$whole_archive_flag_spec"; then
3817             save_libobjs=$libobjs
3818             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3819           else
3820             gentop="$output_objdir/${outputname}x"
3821             generated="$generated $gentop"
3822
3823             func_extract_archives $gentop $convenience
3824             libobjs="$libobjs $func_extract_archives_result"
3825           fi
3826         fi
3827
3828         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3829           eval flag=\"$thread_safe_flag_spec\"
3830           linker_flags="$linker_flags $flag"
3831         fi
3832
3833         # Make a backup of the uninstalled library when relinking
3834         if test "$mode" = relink; then
3835           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3836         fi
3837
3838         # Do each of the archive commands.
3839         if test "$module" = yes && test -n "$module_cmds" ; then
3840           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
3841             eval test_cmds=\"$module_expsym_cmds\"
3842             cmds=$module_expsym_cmds
3843           else
3844             eval test_cmds=\"$module_cmds\"
3845             cmds=$module_cmds
3846           fi
3847         else
3848         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3849           eval test_cmds=\"$archive_expsym_cmds\"
3850           cmds=$archive_expsym_cmds
3851         else
3852           eval test_cmds=\"$archive_cmds\"
3853           cmds=$archive_cmds
3854           fi
3855         fi
3856
3857         if test "X$skipped_export" != "X:" && len=`expr "X$test_cmds" : ".*"` &&
3858            test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3859           :
3860         else
3861           # The command line is too long to link in one step, link piecewise.
3862           $echo "creating reloadable object files..."
3863
3864           # Save the value of $output and $libobjs because we want to
3865           # use them later.  If we have whole_archive_flag_spec, we
3866           # want to use save_libobjs as it was before
3867           # whole_archive_flag_spec was expanded, because we can't
3868           # assume the linker understands whole_archive_flag_spec.
3869           # This may have to be revisited, in case too many
3870           # convenience libraries get linked in and end up exceeding
3871           # the spec.
3872           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3873             save_libobjs=$libobjs
3874           fi
3875           save_output=$output
3876
3877           # Clear the reloadable object creation command queue and
3878           # initialize k to one.
3879           test_cmds=
3880           concat_cmds=
3881           objlist=
3882           delfiles=
3883           last_robj=
3884           k=1
3885           output=$output_objdir/$save_output-${k}.$objext
3886           # Loop over the list of objects to be linked.
3887           for obj in $save_libobjs
3888           do
3889             eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3890             if test "X$objlist" = X ||
3891                { len=`expr "X$test_cmds" : ".*"` &&
3892                  test "$len" -le "$max_cmd_len"; }; then
3893               objlist="$objlist $obj"
3894             else
3895               # The command $test_cmds is almost too long, add a
3896               # command to the queue.
3897               if test "$k" -eq 1 ; then
3898                 # The first file doesn't have a previous command to add.
3899                 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3900               else
3901                 # All subsequent reloadable object files will link in
3902                 # the last one created.
3903                 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3904               fi
3905               last_robj=$output_objdir/$save_output-${k}.$objext
3906               k=`expr $k + 1`
3907               output=$output_objdir/$save_output-${k}.$objext
3908               objlist=$obj
3909               len=1
3910             fi
3911           done
3912           # Handle the remaining objects by creating one last
3913           # reloadable object file.  All subsequent reloadable object
3914           # files will link in the last one created.
3915           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3916           eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3917
3918           if ${skipped_export-false}; then
3919             $show "generating symbol list for \`$libname.la'"
3920             export_symbols="$output_objdir/$libname.exp"
3921             $run $rm $export_symbols
3922             libobjs=$output
3923             # Append the command to create the export file.
3924             eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
3925           fi
3926
3927           # Set up a command to remove the reloadale object files
3928           # after they are used.
3929           i=0
3930           while test "$i" -lt "$k"
3931           do
3932             i=`expr $i + 1`
3933             delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3934           done
3935
3936           $echo "creating a temporary reloadable object file: $output"
3937
3938           # Loop through the commands generated above and execute them.
3939           save_ifs="$IFS"; IFS='~'
3940           for cmd in $concat_cmds; do
3941             IFS="$save_ifs"
3942             $show "$cmd"
3943             $run eval "$cmd" || exit $?
3944           done
3945           IFS="$save_ifs"
3946
3947           libobjs=$output
3948           # Restore the value of output.
3949           output=$save_output
3950
3951           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3952             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3953           fi
3954           # Expand the library linking commands again to reset the
3955           # value of $libobjs for piecewise linking.
3956
3957           # Do each of the archive commands.
3958           if test "$module" = yes && test -n "$module_cmds" ; then
3959             if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
3960               cmds=$module_expsym_cmds
3961             else
3962               cmds=$module_cmds
3963             fi
3964           else
3965           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3966             cmds=$archive_expsym_cmds
3967           else
3968             cmds=$archive_cmds
3969             fi
3970           fi
3971
3972           # Append the command to remove the reloadable object files
3973           # to the just-reset $cmds.
3974           eval cmds=\"\$cmds~\$rm $delfiles\"
3975         fi
3976         save_ifs="$IFS"; IFS='~'
3977         for cmd in $cmds; do
3978           IFS="$save_ifs"
3979           eval cmd=\"$cmd\"
3980           $show "$cmd"
3981           $run eval "$cmd" || exit $?
3982         done
3983         IFS="$save_ifs"
3984
3985         # Restore the uninstalled library and exit
3986         if test "$mode" = relink; then
3987           $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
3988           exit $EXIT_SUCCESS
3989         fi
3990
3991         # Create links to the real library.
3992         for linkname in $linknames; do
3993           if test "$realname" != "$linkname"; then
3994             $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
3995             $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
3996           fi
3997         done
3998
3999         # If -module or -export-dynamic was specified, set the dlname.
4000         if test "$module" = yes || test "$export_dynamic" = yes; then
4001           # On all known operating systems, these are identical.
4002           dlname="$soname"
4003         fi
4004       fi
4005       ;;
4006
4007     obj)
4008       if test -n "$deplibs"; then
4009         $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
4010       fi
4011
4012       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4013         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
4014       fi
4015
4016       if test -n "$rpath"; then
4017         $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
4018       fi
4019
4020       if test -n "$xrpath"; then
4021         $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
4022       fi
4023
4024       if test -n "$vinfo"; then
4025         $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
4026       fi
4027
4028       if test -n "$release"; then
4029         $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
4030       fi
4031
4032       case $output in
4033       *.lo)
4034         if test -n "$objs$old_deplibs"; then
4035           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
4036           exit $EXIT_FAILURE
4037         fi
4038         libobj="$output"
4039         obj=`$echo "X$output" | $Xsed -e "$lo2o"`
4040         ;;
4041       *)
4042         libobj=
4043         obj="$output"
4044         ;;
4045       esac
4046
4047       # Delete the old objects.
4048       $run $rm $obj $libobj
4049
4050       # Objects from convenience libraries.  This assumes
4051       # single-version convenience libraries.  Whenever we create
4052       # different ones for PIC/non-PIC, this we'll have to duplicate
4053       # the extraction.
4054       reload_conv_objs=
4055       gentop=
4056       # reload_cmds runs $LD directly, so let us get rid of
4057       # -Wl from whole_archive_flag_spec
4058       wl=
4059
4060       if test -n "$convenience"; then
4061         if test -n "$whole_archive_flag_spec"; then
4062           eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
4063         else
4064           gentop="$output_objdir/${obj}x"
4065           generated="$generated $gentop"
4066
4067           func_extract_archives $gentop $convenience
4068           reload_conv_objs="$reload_objs $func_extract_archives_result"
4069         fi
4070       fi
4071
4072       # Create the old-style object.
4073       reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
4074
4075       output="$obj"
4076       cmds=$reload_cmds
4077       save_ifs="$IFS"; IFS='~'
4078       for cmd in $cmds; do
4079         IFS="$save_ifs"
4080         eval cmd=\"$cmd\"
4081         $show "$cmd"
4082         $run eval "$cmd" || exit $?
4083       done
4084       IFS="$save_ifs"
4085
4086       # Exit if we aren't doing a library object file.
4087       if test -z "$libobj"; then
4088         if test -n "$gentop"; then
4089           $show "${rm}r $gentop"
4090           $run ${rm}r $gentop
4091         fi
4092
4093         exit $EXIT_SUCCESS
4094       fi
4095
4096       if test "$build_libtool_libs" != yes; then
4097         if test -n "$gentop"; then
4098           $show "${rm}r $gentop"
4099           $run ${rm}r $gentop
4100         fi
4101
4102         # Create an invalid libtool object if no PIC, so that we don't
4103         # accidentally link it into a program.
4104         # $show "echo timestamp > $libobj"
4105         # $run eval "echo timestamp > $libobj" || exit $?
4106         exit $EXIT_SUCCESS
4107       fi
4108
4109       if test -n "$pic_flag" || test "$pic_mode" != default; then
4110         # Only do commands if we really have different PIC objects.
4111         reload_objs="$libobjs $reload_conv_objs"
4112         output="$libobj"
4113         cmds=$reload_cmds
4114         save_ifs="$IFS"; IFS='~'
4115         for cmd in $cmds; do
4116           IFS="$save_ifs"
4117           eval cmd=\"$cmd\"
4118           $show "$cmd"
4119           $run eval "$cmd" || exit $?
4120         done
4121         IFS="$save_ifs"
4122       fi
4123
4124       if test -n "$gentop"; then
4125         $show "${rm}r $gentop"
4126         $run ${rm}r $gentop
4127       fi
4128
4129       exit $EXIT_SUCCESS
4130       ;;
4131
4132     prog)
4133       case $host in
4134         *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
4135       esac
4136       if test -n "$vinfo"; then
4137         $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4138       fi
4139
4140       if test -n "$release"; then
4141         $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4142       fi
4143
4144       if test "$preload" = yes; then
4145         if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
4146            test "$dlopen_self_static" = unknown; then
4147           $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4148         fi
4149       fi
4150
4151       case $host in
4152       *-*-rhapsody* | *-*-darwin1.[012])
4153         # On Rhapsody replace the C library is the System framework
4154         compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4155         finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4156         ;;
4157       esac
4158
4159       case $host in
4160       *darwin*)
4161         # Don't allow lazy linking, it breaks C++ global constructors
4162         if test "$tagname" = CXX ; then
4163         compile_command="$compile_command ${wl}-bind_at_load"
4164         finalize_command="$finalize_command ${wl}-bind_at_load"
4165         fi
4166         ;;
4167       esac
4168
4169       compile_command="$compile_command $compile_deplibs"
4170       finalize_command="$finalize_command $finalize_deplibs"
4171
4172       if test -n "$rpath$xrpath"; then
4173         # If the user specified any rpath flags, then add them.
4174         for libdir in $rpath $xrpath; do
4175           # This is the magic to use -rpath.
4176           case "$finalize_rpath " in
4177           *" $libdir "*) ;;
4178           *) finalize_rpath="$finalize_rpath $libdir" ;;
4179           esac
4180         done
4181       fi
4182
4183       # Now hardcode the library paths
4184       rpath=
4185       hardcode_libdirs=
4186       for libdir in $compile_rpath $finalize_rpath; do
4187         if test -n "$hardcode_libdir_flag_spec"; then
4188           if test -n "$hardcode_libdir_separator"; then
4189             if test -z "$hardcode_libdirs"; then
4190               hardcode_libdirs="$libdir"
4191             else
4192               # Just accumulate the unique libdirs.
4193               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4194               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4195                 ;;
4196               *)
4197                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4198                 ;;
4199               esac
4200             fi
4201           else
4202             eval flag=\"$hardcode_libdir_flag_spec\"
4203             rpath="$rpath $flag"
4204           fi
4205         elif test -n "$runpath_var"; then
4206           case "$perm_rpath " in
4207           *" $libdir "*) ;;
4208           *) perm_rpath="$perm_rpath $libdir" ;;
4209           esac
4210         fi
4211         case $host in
4212         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4213           case :$dllsearchpath: in
4214           *":$libdir:"*) ;;
4215           *) dllsearchpath="$dllsearchpath:$libdir";;
4216           esac
4217           ;;
4218         esac
4219       done
4220       # Substitute the hardcoded libdirs into the rpath.
4221       if test -n "$hardcode_libdir_separator" &&
4222          test -n "$hardcode_libdirs"; then
4223         libdir="$hardcode_libdirs"
4224         eval rpath=\" $hardcode_libdir_flag_spec\"
4225       fi
4226       compile_rpath="$rpath"
4227
4228       rpath=
4229       hardcode_libdirs=
4230       for libdir in $finalize_rpath; do
4231         if test -n "$hardcode_libdir_flag_spec"; then
4232           if test -n "$hardcode_libdir_separator"; then
4233             if test -z "$hardcode_libdirs"; then
4234               hardcode_libdirs="$libdir"
4235             else
4236               # Just accumulate the unique libdirs.
4237               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4238               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4239                 ;;
4240               *)
4241                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4242                 ;;
4243               esac
4244             fi
4245           else
4246             eval flag=\"$hardcode_libdir_flag_spec\"
4247             rpath="$rpath $flag"
4248           fi
4249         elif test -n "$runpath_var"; then
4250           case "$finalize_perm_rpath " in
4251           *" $libdir "*) ;;
4252           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
4253           esac
4254         fi
4255       done
4256       # Substitute the hardcoded libdirs into the rpath.
4257       if test -n "$hardcode_libdir_separator" &&
4258          test -n "$hardcode_libdirs"; then
4259         libdir="$hardcode_libdirs"
4260         eval rpath=\" $hardcode_libdir_flag_spec\"
4261       fi
4262       finalize_rpath="$rpath"
4263
4264       if test -n "$libobjs" && test "$build_old_libs" = yes; then
4265         # Transform all the library objects into standard objects.
4266         compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4267         finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4268       fi
4269
4270       dlsyms=
4271       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4272         if test -n "$NM" && test -n "$global_symbol_pipe"; then
4273           dlsyms="${outputname}S.c"
4274         else
4275           $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4276         fi
4277       fi
4278
4279       if test -n "$dlsyms"; then
4280         case $dlsyms in
4281         "") ;;
4282         *.c)
4283           # Discover the nlist of each of the dlfiles.
4284           nlist="$output_objdir/${outputname}.nm"
4285
4286           $show "$rm $nlist ${nlist}S ${nlist}T"
4287           $run $rm "$nlist" "${nlist}S" "${nlist}T"
4288
4289           # Parse the name list into a source file.
4290           $show "creating $output_objdir/$dlsyms"
4291
4292           test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4293 /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4294 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
4295
4296 #ifdef __cplusplus
4297 extern \"C\" {
4298 #endif
4299
4300 /* Prevent the only kind of declaration conflicts we can make. */
4301 #define lt_preloaded_symbols some_other_symbol
4302
4303 /* External symbol declarations for the compiler. */\
4304 "
4305
4306           if test "$dlself" = yes; then
4307             $show "generating symbol list for \`$output'"
4308
4309             test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4310
4311             # Add our own program objects to the symbol list.
4312             progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4313             for arg in $progfiles; do
4314               $show "extracting global C symbols from \`$arg'"
4315               $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4316             done
4317
4318             if test -n "$exclude_expsyms"; then
4319               $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4320               $run eval '$mv "$nlist"T "$nlist"'
4321             fi
4322
4323             if test -n "$export_symbols_regex"; then
4324               $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4325               $run eval '$mv "$nlist"T "$nlist"'
4326             fi
4327
4328             # Prepare the list of exported symbols
4329             if test -z "$export_symbols"; then
4330               export_symbols="$output_objdir/$output.exp"
4331               $run $rm $export_symbols
4332               $run eval "${SED} -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4333             else
4334               $run eval "${SED} -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
4335               $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
4336               $run eval 'mv "$nlist"T "$nlist"'
4337             fi
4338           fi
4339
4340           for arg in $dlprefiles; do
4341             $show "extracting global C symbols from \`$arg'"
4342             name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4343             $run eval '$echo ": $name " >> "$nlist"'
4344             $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4345           done
4346
4347           if test -z "$run"; then
4348             # Make sure we have at least an empty file.
4349             test -f "$nlist" || : > "$nlist"
4350
4351             if test -n "$exclude_expsyms"; then
4352               $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4353               $mv "$nlist"T "$nlist"
4354             fi
4355
4356             # Try sorting and uniquifying the output.
4357             if grep -v "^: " < "$nlist" |
4358                 if sort -k 3 </dev/null >/dev/null 2>&1; then
4359                   sort -k 3
4360                 else
4361                   sort +2
4362                 fi |
4363                 uniq > "$nlist"S; then
4364               :
4365             else
4366               grep -v "^: " < "$nlist" > "$nlist"S
4367             fi
4368
4369             if test -f "$nlist"S; then
4370               eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4371             else
4372               $echo '/* NONE */' >> "$output_objdir/$dlsyms"
4373             fi
4374
4375             $echo >> "$output_objdir/$dlsyms" "\
4376
4377 #undef lt_preloaded_symbols
4378
4379 #if defined (__STDC__) && __STDC__
4380 # define lt_ptr void *
4381 #else
4382 # define lt_ptr char *
4383 # define const
4384 #endif
4385
4386 /* The mapping between symbol names and symbols. */
4387 const struct {
4388   const char *name;
4389   lt_ptr address;
4390 }
4391 lt_preloaded_symbols[] =
4392 {\
4393 "
4394
4395             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4396
4397             $echo >> "$output_objdir/$dlsyms" "\
4398   {0, (lt_ptr) 0}
4399 };
4400
4401 /* This works around a problem in FreeBSD linker */
4402 #ifdef FREEBSD_WORKAROUND
4403 static const void *lt_preloaded_setup() {
4404   return lt_preloaded_symbols;
4405 }
4406 #endif
4407
4408 #ifdef __cplusplus
4409 }
4410 #endif\
4411 "
4412           fi
4413
4414           pic_flag_for_symtable=
4415           case $host in
4416           # compiling the symbol table file with pic_flag works around
4417           # a FreeBSD bug that causes programs to crash when -lm is
4418           # linked before any other PIC object.  But we must not use
4419           # pic_flag when linking with -static.  The problem exists in
4420           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4421           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4422             case "$compile_command " in
4423             *" -static "*) ;;
4424             *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4425             esac;;
4426           *-*-hpux*)
4427             case "$compile_command " in
4428             *" -static "*) ;;
4429             *) pic_flag_for_symtable=" $pic_flag";;
4430             esac
4431           esac
4432
4433           # Now compile the dynamic symbol file.
4434           $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4435           $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4436
4437           # Clean up the generated files.
4438           $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4439           $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4440
4441           # Transform the symbol file into the correct name.
4442           compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4443           finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4444           ;;
4445         *)
4446           $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4447           exit $EXIT_FAILURE
4448           ;;
4449         esac
4450       else
4451         # We keep going just in case the user didn't refer to
4452         # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
4453         # really was required.
4454
4455         # Nullify the symbol file.
4456         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
4457         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
4458       fi
4459
4460       if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
4461         # Replace the output file specification.
4462         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4463         link_command="$compile_command$compile_rpath"
4464
4465         # We have no uninstalled library dependencies, so finalize right now.
4466         $show "$link_command"
4467         $run eval "$link_command"
4468         status=$?
4469
4470         # Delete the generated files.
4471         if test -n "$dlsyms"; then
4472           $show "$rm $output_objdir/${outputname}S.${objext}"
4473           $run $rm "$output_objdir/${outputname}S.${objext}"
4474         fi
4475
4476         exit $status
4477       fi
4478
4479       if test -n "$shlibpath_var"; then
4480         # We should set the shlibpath_var
4481         rpath=
4482         for dir in $temp_rpath; do
4483           case $dir in
4484           [\\/]* | [A-Za-z]:[\\/]*)
4485             # Absolute path.
4486             rpath="$rpath$dir:"
4487             ;;
4488           *)
4489             # Relative path: add a thisdir entry.
4490             rpath="$rpath\$thisdir/$dir:"
4491             ;;
4492           esac
4493         done
4494         temp_rpath="$rpath"
4495       fi
4496
4497       if test -n "$compile_shlibpath$finalize_shlibpath"; then
4498         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
4499       fi
4500       if test -n "$finalize_shlibpath"; then
4501         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
4502       fi
4503
4504       compile_var=
4505       finalize_var=
4506       if test -n "$runpath_var"; then
4507         if test -n "$perm_rpath"; then
4508           # We should set the runpath_var.
4509           rpath=
4510           for dir in $perm_rpath; do
4511             rpath="$rpath$dir:"
4512           done
4513           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
4514         fi
4515         if test -n "$finalize_perm_rpath"; then
4516           # We should set the runpath_var.
4517           rpath=
4518           for dir in $finalize_perm_rpath; do
4519             rpath="$rpath$dir:"
4520           done
4521           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
4522         fi
4523       fi
4524
4525       if test "$no_install" = yes; then
4526         # We don't need to create a wrapper script.
4527         link_command="$compile_var$compile_command$compile_rpath"
4528         # Replace the output file specification.
4529         link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4530         # Delete the old output file.
4531         $run $rm $output
4532         # Link the executable and exit
4533         $show "$link_command"
4534         $run eval "$link_command" || exit $?
4535         exit $EXIT_SUCCESS
4536       fi
4537
4538       if test "$hardcode_action" = relink; then
4539         # Fast installation is not supported
4540         link_command="$compile_var$compile_command$compile_rpath"
4541         relink_command="$finalize_var$finalize_command$finalize_rpath"
4542
4543         $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
4544         $echo "$modename: \`$output' will be relinked during installation" 1>&2
4545       else
4546         if test "$fast_install" != no; then
4547           link_command="$finalize_var$compile_command$finalize_rpath"
4548           if test "$fast_install" = yes; then
4549             relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
4550           else
4551             # fast_install is set to needless
4552             relink_command=
4553           fi
4554         else
4555           link_command="$compile_var$compile_command$compile_rpath"
4556           relink_command="$finalize_var$finalize_command$finalize_rpath"
4557         fi
4558       fi
4559
4560       # Replace the output file specification.
4561       link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4562
4563       # Delete the old output files.
4564       $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
4565
4566       $show "$link_command"
4567       $run eval "$link_command" || exit $?
4568
4569       # Now create the wrapper script.
4570       $show "creating $output"
4571
4572       # Quote the relink command for shipping.
4573       if test -n "$relink_command"; then
4574         # Preserve any variables that may affect compiler behavior
4575         for var in $variables_saved_for_relink; do
4576           if eval test -z \"\${$var+set}\"; then
4577             relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
4578           elif eval var_value=\$$var; test -z "$var_value"; then
4579             relink_command="$var=; export $var; $relink_command"
4580           else
4581             var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4582             relink_command="$var=\"$var_value\"; export $var; $relink_command"
4583           fi
4584         done
4585         relink_command="(cd `pwd`; $relink_command)"
4586         relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4587       fi
4588
4589       # Quote $echo for shipping.
4590       if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
4591         case $progpath in
4592         [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4593         *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4594         esac
4595         qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
4596       else
4597         qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
4598       fi
4599
4600       # Only actually do things if our run command is non-null.
4601       if test -z "$run"; then
4602         # win32 will think the script is a binary if it has
4603         # a .exe suffix, so we strip it off here.
4604         case $output in
4605           *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
4606         esac
4607         # test for cygwin because mv fails w/o .exe extensions
4608         case $host in
4609           *cygwin*)
4610             exeext=.exe
4611             outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
4612           *) exeext= ;;
4613         esac
4614         case $host in
4615           *cygwin* | *mingw* )
4616             cwrappersource=`$echo ${objdir}/lt-${output}.c`
4617             cwrapper=`$echo ${output}.exe`
4618             $rm $cwrappersource $cwrapper
4619             trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4620
4621             cat > $cwrappersource <<EOF
4622
4623 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4624    Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4625
4626    The $output program cannot be directly executed until all the libtool
4627    libraries that it depends on are installed.
4628
4629    This wrapper executable should never be moved out of the build directory.
4630    If it is, it will not operate correctly.
4631
4632    Currently, it simply execs the wrapper *script* "/bin/sh $output",
4633    but could eventually absorb all of the scripts functionality and
4634    exec $objdir/$outputname directly.
4635 */
4636 EOF
4637             cat >> $cwrappersource<<"EOF"
4638 #include <stdio.h>
4639 #include <stdlib.h>
4640 #include <unistd.h>
4641 #include <malloc.h>
4642 #include <stdarg.h>
4643 #include <assert.h>
4644
4645 #if defined(PATH_MAX)
4646 # define LT_PATHMAX PATH_MAX
4647 #elif defined(MAXPATHLEN)
4648 # define LT_PATHMAX MAXPATHLEN
4649 #else
4650 # define LT_PATHMAX 1024
4651 #endif
4652
4653 #ifndef DIR_SEPARATOR
4654 #define DIR_SEPARATOR '/'
4655 #endif
4656
4657 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4658   defined (__OS2__)
4659 #define HAVE_DOS_BASED_FILE_SYSTEM
4660 #ifndef DIR_SEPARATOR_2
4661 #define DIR_SEPARATOR_2 '\\'
4662 #endif
4663 #endif
4664
4665 #ifndef DIR_SEPARATOR_2
4666 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4667 #else /* DIR_SEPARATOR_2 */
4668 # define IS_DIR_SEPARATOR(ch) \
4669         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4670 #endif /* DIR_SEPARATOR_2 */
4671
4672 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
4673 #define XFREE(stale) do { \
4674   if (stale) { free ((void *) stale); stale = 0; } \
4675 } while (0)
4676
4677 const char *program_name = NULL;
4678
4679 void * xmalloc (size_t num);
4680 char * xstrdup (const char *string);
4681 char * basename (const char *name);
4682 char * fnqualify(const char *path);
4683 char * strendzap(char *str, const char *pat);
4684 void lt_fatal (const char *message, ...);
4685
4686 int
4687 main (int argc, char *argv[])
4688 {
4689   char **newargz;
4690   int i;
4691
4692   program_name = (char *) xstrdup ((char *) basename (argv[0]));
4693   newargz = XMALLOC(char *, argc+2);
4694 EOF
4695
4696             cat >> $cwrappersource <<EOF
4697   newargz[0] = "$SHELL";
4698 EOF
4699
4700             cat >> $cwrappersource <<"EOF"
4701   newargz[1] = fnqualify(argv[0]);
4702   /* we know the script has the same name, without the .exe */
4703   /* so make sure newargz[1] doesn't end in .exe */
4704   strendzap(newargz[1],".exe");
4705   for (i = 1; i < argc; i++)
4706     newargz[i+1] = xstrdup(argv[i]);
4707   newargz[argc+1] = NULL;
4708 EOF
4709
4710             cat >> $cwrappersource <<EOF
4711   execv("$SHELL",newargz);
4712 EOF
4713
4714             cat >> $cwrappersource <<"EOF"
4715 }
4716
4717 void *
4718 xmalloc (size_t num)
4719 {
4720   void * p = (void *) malloc (num);
4721   if (!p)
4722     lt_fatal ("Memory exhausted");
4723
4724   return p;
4725 }
4726
4727 char *
4728 xstrdup (const char *string)
4729 {
4730   return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
4731 ;
4732 }
4733
4734 char *
4735 basename (const char *name)
4736 {
4737   const char *base;
4738
4739 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4740   /* Skip over the disk name in MSDOS pathnames. */
4741   if (isalpha (name[0]) && name[1] == ':')
4742     name += 2;
4743 #endif
4744
4745   for (base = name; *name; name++)
4746     if (IS_DIR_SEPARATOR (*name))
4747       base = name + 1;
4748   return (char *) base;
4749 }
4750
4751 char *
4752 fnqualify(const char *path)
4753 {
4754   size_t size;
4755   char *p;
4756   char tmp[LT_PATHMAX + 1];
4757
4758   assert(path != NULL);
4759
4760   /* Is it qualified already? */
4761 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4762   if (isalpha (path[0]) && path[1] == ':')
4763     return xstrdup (path);
4764 #endif
4765   if (IS_DIR_SEPARATOR (path[0]))
4766     return xstrdup (path);
4767
4768   /* prepend the current directory */
4769   /* doesn't handle '~' */
4770   if (getcwd (tmp, LT_PATHMAX) == NULL)
4771     lt_fatal ("getcwd failed");
4772   size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '\0' */
4773   p = XMALLOC(char, size);
4774   sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path);
4775   return p;
4776 }
4777
4778 char *
4779 strendzap(char *str, const char *pat)
4780 {
4781   size_t len, patlen;
4782
4783   assert(str != NULL);
4784   assert(pat != NULL);
4785
4786   len = strlen(str);
4787   patlen = strlen(pat);
4788
4789   if (patlen <= len)
4790   {
4791     str += len - patlen;
4792     if (strcmp(str, pat) == 0)
4793       *str = '\0';
4794   }
4795   return str;
4796 }
4797
4798 static void
4799 lt_error_core (int exit_status, const char * mode,
4800           const char * message, va_list ap)
4801 {
4802   fprintf (stderr, "%s: %s: ", program_name, mode);
4803   vfprintf (stderr, message, ap);
4804   fprintf (stderr, ".\n");
4805
4806   if (exit_status >= 0)
4807     exit (exit_status);
4808 }
4809
4810 void
4811 lt_fatal (const char *message, ...)
4812 {
4813   va_list ap;
4814   va_start (ap, message);
4815   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4816   va_end (ap);
4817 }
4818 EOF
4819           # we should really use a build-platform specific compiler
4820           # here, but OTOH, the wrappers (shell script and this C one)
4821           # are only useful if you want to execute the "real" binary.
4822           # Since the "real" binary is built for $host, then this
4823           # wrapper might as well be built for $host, too.
4824           $run $LTCC -s -o $cwrapper $cwrappersource
4825           ;;
4826         esac
4827         $rm $output
4828         trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
4829
4830         $echo > $output "\
4831 #! $SHELL
4832
4833 # $output - temporary wrapper script for $objdir/$outputname
4834 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4835 #
4836 # The $output program cannot be directly executed until all the libtool
4837 # libraries that it depends on are installed.
4838 #
4839 # This wrapper script should never be moved out of the build directory.
4840 # If it is, it will not operate correctly.
4841
4842 # Sed substitution that helps us do robust quoting.  It backslashifies
4843 # metacharacters that are still active within double-quoted strings.
4844 Xsed='${SED} -e 1s/^X//'
4845 sed_quote_subst='$sed_quote_subst'
4846
4847 # The HP-UX ksh and POSIX shell print the target directory to stdout
4848 # if CDPATH is set.
4849 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
4850
4851 relink_command=\"$relink_command\"
4852
4853 # This environment variable determines our operation mode.
4854 if test \"\$libtool_install_magic\" = \"$magic\"; then
4855   # install mode needs the following variable:
4856   notinst_deplibs='$notinst_deplibs'
4857 else
4858   # When we are sourced in execute mode, \$file and \$echo are already set.
4859   if test \"\$libtool_execute_magic\" != \"$magic\"; then
4860     echo=\"$qecho\"
4861     file=\"\$0\"
4862     # Make sure echo works.
4863     if test \"X\$1\" = X--no-reexec; then
4864       # Discard the --no-reexec flag, and continue.
4865       shift
4866     elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
4867       # Yippee, \$echo works!
4868       :
4869     else
4870       # Restart under the correct shell, and then maybe \$echo will work.
4871       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
4872     fi
4873   fi\
4874 "
4875         $echo >> $output "\
4876
4877   # Find the directory that this script lives in.
4878   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
4879   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4880
4881   # Follow symbolic links until we get to the real thisdir.
4882   file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
4883   while test -n \"\$file\"; do
4884     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
4885
4886     # If there was a directory component, then change thisdir.
4887     if test \"x\$destdir\" != \"x\$file\"; then
4888       case \"\$destdir\" in
4889       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4890       *) thisdir=\"\$thisdir/\$destdir\" ;;
4891       esac
4892     fi
4893
4894     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
4895     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
4896   done
4897
4898   # Try to get the absolute directory name.
4899   absdir=\`cd \"\$thisdir\" && pwd\`
4900   test -n \"\$absdir\" && thisdir=\"\$absdir\"
4901 "
4902
4903         if test "$fast_install" = yes; then
4904           $echo >> $output "\
4905   program=lt-'$outputname'$exeext
4906   progdir=\"\$thisdir/$objdir\"
4907
4908   if test ! -f \"\$progdir/\$program\" || \\
4909      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4910        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4911
4912     file=\"\$\$-\$program\"
4913
4914     if test ! -d \"\$progdir\"; then
4915       $mkdir \"\$progdir\"
4916     else
4917       $rm \"\$progdir/\$file\"
4918     fi"
4919
4920           $echo >> $output "\
4921
4922     # relink executable if necessary
4923     if test -n \"\$relink_command\"; then
4924       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4925       else
4926         $echo \"\$relink_command_output\" >&2
4927         $rm \"\$progdir/\$file\"
4928         exit $EXIT_FAILURE
4929       fi
4930     fi
4931
4932     $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4933     { $rm \"\$progdir/\$program\";
4934       $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4935     $rm \"\$progdir/\$file\"
4936   fi"
4937         else
4938           $echo >> $output "\
4939   program='$outputname'
4940   progdir=\"\$thisdir/$objdir\"
4941 "
4942         fi
4943
4944         $echo >> $output "\
4945
4946   if test -f \"\$progdir/\$program\"; then"
4947
4948         # Export our shlibpath_var if we have one.
4949         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4950           $echo >> $output "\
4951     # Add our own library path to $shlibpath_var
4952     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4953
4954     # Some systems cannot cope with colon-terminated $shlibpath_var
4955     # The second colon is a workaround for a bug in BeOS R4 sed
4956     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
4957
4958     export $shlibpath_var
4959 "
4960         fi
4961
4962         # fixup the dll searchpath if we need to.
4963         if test -n "$dllsearchpath"; then
4964           $echo >> $output "\
4965     # Add the dll search path components to the executable PATH
4966     PATH=$dllsearchpath:\$PATH
4967 "
4968         fi
4969
4970         $echo >> $output "\
4971     if test \"\$libtool_execute_magic\" != \"$magic\"; then
4972       # Run the actual program with our arguments.
4973 "
4974         case $host in
4975         # Backslashes separate directories on plain windows
4976         *-*-mingw | *-*-os2*)
4977           $echo >> $output "\
4978       exec \$progdir\\\\\$program \${1+\"\$@\"}
4979 "
4980           ;;
4981
4982         *)
4983           $echo >> $output "\
4984       exec \$progdir/\$program \${1+\"\$@\"}
4985 "
4986           ;;
4987         esac
4988         $echo >> $output "\
4989       \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
4990       exit $EXIT_FAILURE
4991     fi
4992   else
4993     # The program doesn't exist.
4994     \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
4995     \$echo \"This script is just a wrapper for \$program.\" 1>&2
4996     $echo \"See the $PACKAGE documentation for more information.\" 1>&2
4997     exit $EXIT_FAILURE
4998   fi
4999 fi\
5000 "
5001         chmod +x $output
5002       fi
5003       exit $EXIT_SUCCESS
5004       ;;
5005     esac
5006
5007     # See if we need to build an old-fashioned archive.
5008     for oldlib in $oldlibs; do
5009
5010       if test "$build_libtool_libs" = convenience; then
5011         oldobjs="$libobjs_save"
5012         addlibs="$convenience"
5013         build_libtool_libs=no
5014       else
5015         if test "$build_libtool_libs" = module; then
5016           oldobjs="$libobjs_save"
5017           build_libtool_libs=no
5018         else
5019           oldobjs="$old_deplibs $non_pic_objects"
5020         fi
5021         addlibs="$old_convenience"
5022       fi
5023
5024       if test -n "$addlibs"; then
5025         gentop="$output_objdir/${outputname}x"
5026         generated="$generated $gentop"
5027
5028         func_extract_archives $gentop $addlibs
5029         oldobjs="$oldobjs $func_extract_archives_result"
5030       fi
5031
5032       # Do each command in the archive commands.
5033       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
5034        cmds=$old_archive_from_new_cmds
5035       else
5036         eval cmds=\"$old_archive_cmds\"
5037
5038         if len=`expr "X$cmds" : ".*"` &&
5039              test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
5040           cmds=$old_archive_cmds
5041         else
5042           # the command line is too long to link in one step, link in parts
5043           $echo "using piecewise archive linking..."
5044           save_RANLIB=$RANLIB
5045           RANLIB=:
5046           objlist=
5047           concat_cmds=
5048           save_oldobjs=$oldobjs
5049           # GNU ar 2.10+ was changed to match POSIX; thus no paths are
5050           # encoded into archives.  This makes 'ar r' malfunction in
5051           # this piecewise linking case whenever conflicting object
5052           # names appear in distinct ar calls; check, warn and compensate.
5053             if (for obj in $save_oldobjs
5054             do
5055               $echo "X$obj" | $Xsed -e 's%^.*/%%'
5056             done | sort | sort -uc >/dev/null 2>&1); then
5057             :
5058           else
5059             $echo "$modename: warning: object name conflicts; overriding AR_FLAGS to 'cq'" 1>&2
5060             $echo "$modename: warning: to ensure that POSIX-compatible ar will work" 1>&2
5061             AR_FLAGS=cq
5062           fi
5063           # Is there a better way of finding the last object in the list?
5064           for obj in $save_oldobjs
5065           do
5066             last_oldobj=$obj
5067           done
5068           for obj in $save_oldobjs
5069           do
5070             oldobjs="$objlist $obj"
5071             objlist="$objlist $obj"
5072             eval test_cmds=\"$old_archive_cmds\"
5073             if len=`expr "X$test_cmds" : ".*"` &&
5074                test "$len" -le "$max_cmd_len"; then
5075               :
5076             else
5077               # the above command should be used before it gets too long
5078               oldobjs=$objlist
5079               if test "$obj" = "$last_oldobj" ; then
5080                 RANLIB=$save_RANLIB
5081               fi
5082               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
5083               eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
5084               objlist=
5085             fi
5086           done
5087           RANLIB=$save_RANLIB
5088           oldobjs=$objlist
5089           if test "X$oldobjs" = "X" ; then
5090             eval cmds=\"\$concat_cmds\"
5091           else
5092             eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
5093           fi
5094         fi
5095       fi
5096       save_ifs="$IFS"; IFS='~'
5097       for cmd in $cmds; do
5098         eval cmd=\"$cmd\"
5099         IFS="$save_ifs"
5100         $show "$cmd"
5101         $run eval "$cmd" || exit $?
5102       done
5103       IFS="$save_ifs"
5104     done
5105
5106     if test -n "$generated"; then
5107       $show "${rm}r$generated"
5108       $run ${rm}r$generated
5109     fi
5110
5111     # Now create the libtool archive.
5112     case $output in
5113     *.la)
5114       old_library=
5115       test "$build_old_libs" = yes && old_library="$libname.$libext"
5116       $show "creating $output"
5117
5118       # Preserve any variables that may affect compiler behavior
5119       for var in $variables_saved_for_relink; do
5120         if eval test -z \"\${$var+set}\"; then
5121           relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
5122         elif eval var_value=\$$var; test -z "$var_value"; then
5123           relink_command="$var=; export $var; $relink_command"
5124         else
5125           var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
5126           relink_command="$var=\"$var_value\"; export $var; $relink_command"
5127         fi
5128       done
5129       # Quote the link command for shipping.
5130       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
5131       relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
5132       if test "$hardcode_automatic" = yes ; then
5133         relink_command=
5134       fi
5135
5136
5137       # Only create the output if not a dry run.
5138       if test -z "$run"; then
5139         for installed in no yes; do
5140           if test "$installed" = yes; then
5141             if test -z "$install_libdir"; then
5142               break
5143             fi
5144             output="$output_objdir/$outputname"i
5145             # Replace all uninstalled libtool libraries with the installed ones
5146             newdependency_libs=
5147             for deplib in $dependency_libs; do
5148               case $deplib in
5149               *.la)
5150                 name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
5151                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5152                 if test -z "$libdir"; then
5153                   $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
5154                   exit $EXIT_FAILURE
5155                 fi
5156                 newdependency_libs="$newdependency_libs $libdir/$name"
5157                 ;;
5158               *) newdependency_libs="$newdependency_libs $deplib" ;;
5159               esac
5160             done
5161             dependency_libs="$newdependency_libs"
5162             newdlfiles=
5163             for lib in $dlfiles; do
5164               name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5165               eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5166               if test -z "$libdir"; then
5167                 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5168                 exit $EXIT_FAILURE
5169               fi
5170               newdlfiles="$newdlfiles $libdir/$name"
5171             done
5172             dlfiles="$newdlfiles"
5173             newdlprefiles=
5174             for lib in $dlprefiles; do
5175               name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5176               eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5177               if test -z "$libdir"; then
5178                 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5179                 exit $EXIT_FAILURE
5180               fi
5181               newdlprefiles="$newdlprefiles $libdir/$name"
5182             done
5183             dlprefiles="$newdlprefiles"
5184           else
5185             newdlfiles=
5186             for lib in $dlfiles; do
5187               case $lib in
5188                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5189                 *) abs=`pwd`"/$lib" ;;
5190               esac
5191               newdlfiles="$newdlfiles $abs"
5192             done
5193             dlfiles="$newdlfiles"
5194             newdlprefiles=
5195             for lib in $dlprefiles; do
5196               case $lib in
5197                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5198                 *) abs=`pwd`"/$lib" ;;
5199               esac
5200               newdlprefiles="$newdlprefiles $abs"
5201             done
5202             dlprefiles="$newdlprefiles"
5203           fi
5204           $rm $output
5205           # place dlname in correct position for cygwin
5206           tdlname=$dlname
5207           case $host,$output,$installed,$module,$dlname in
5208             *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
5209           esac
5210           $echo > $output "\
5211 # $outputname - a libtool library file
5212 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5213 #
5214 # Please DO NOT delete this file!
5215 # It is necessary for linking the library.
5216
5217 # The name that we can dlopen(3).
5218 dlname='$tdlname'
5219
5220 # Names of this library.
5221 library_names='$library_names'
5222
5223 # The name of the static archive.
5224 old_library='$old_library'
5225
5226 # Libraries that this one depends upon.
5227 dependency_libs='$dependency_libs'
5228
5229 # Version information for $libname.
5230 current=$current
5231 age=$age
5232 revision=$revision
5233
5234 # Is this an already installed library?
5235 installed=$installed
5236
5237 # Should we warn about portability when linking against -modules?
5238 shouldnotlink=$module
5239
5240 # Files to dlopen/dlpreopen
5241 dlopen='$dlfiles'
5242 dlpreopen='$dlprefiles'
5243
5244 # Directory that this library needs to be installed in:
5245 libdir='$install_libdir'"
5246           if test "$installed" = no && test "$need_relink" = yes; then
5247             $echo >> $output "\
5248 relink_command=\"$relink_command\""
5249           fi
5250         done
5251       fi
5252
5253       # Do a symbolic link so that the libtool archive can be found in
5254       # LD_LIBRARY_PATH before the program is installed.
5255       $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5256       $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5257       ;;
5258     esac
5259     exit $EXIT_SUCCESS
5260     ;;
5261
5262   # libtool install mode
5263   install)
5264     modename="$modename: install"
5265
5266     # There may be an optional sh(1) argument at the beginning of
5267     # install_prog (especially on Windows NT).
5268     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5269        # Allow the use of GNU shtool's install command.
5270        $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
5271       # Aesthetically quote it.
5272       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5273       case $arg in
5274       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
5275         arg="\"$arg\""
5276         ;;
5277       esac
5278       install_prog="$arg "
5279       arg="$1"
5280       shift
5281     else
5282       install_prog=
5283       arg="$nonopt"
5284     fi
5285
5286     # The real first argument should be the name of the installation program.
5287     # Aesthetically quote it.
5288     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5289     case $arg in
5290     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
5291       arg="\"$arg\""
5292       ;;
5293     esac
5294     install_prog="$install_prog$arg"
5295
5296     # We need to accept at least all the BSD install flags.
5297     dest=
5298     files=
5299     opts=
5300     prev=
5301     install_type=
5302     isdir=no
5303     stripme=
5304     for arg
5305     do
5306       if test -n "$dest"; then
5307         files="$files $dest"
5308         dest="$arg"
5309         continue
5310       fi
5311
5312       case $arg in
5313       -d) isdir=yes ;;
5314       -f) prev="-f" ;;
5315       -g) prev="-g" ;;
5316       -m) prev="-m" ;;
5317       -o) prev="-o" ;;
5318       -s)
5319         stripme=" -s"
5320         continue
5321         ;;
5322       -*) ;;
5323
5324       *)
5325         # If the previous option needed an argument, then skip it.
5326         if test -n "$prev"; then
5327           prev=
5328         else
5329           dest="$arg"
5330           continue
5331         fi
5332         ;;
5333       esac
5334
5335       # Aesthetically quote the argument.
5336       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5337       case $arg in
5338       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
5339         arg="\"$arg\""
5340         ;;
5341       esac
5342       install_prog="$install_prog $arg"
5343     done
5344
5345     if test -z "$install_prog"; then
5346       $echo "$modename: you must specify an install program" 1>&2
5347       $echo "$help" 1>&2
5348       exit $EXIT_FAILURE
5349     fi
5350
5351     if test -n "$prev"; then
5352       $echo "$modename: the \`$prev' option requires an argument" 1>&2
5353       $echo "$help" 1>&2
5354       exit $EXIT_FAILURE
5355     fi
5356
5357     if test -z "$files"; then
5358       if test -z "$dest"; then
5359         $echo "$modename: no file or destination specified" 1>&2
5360       else
5361         $echo "$modename: you must specify a destination" 1>&2
5362       fi
5363       $echo "$help" 1>&2
5364       exit $EXIT_FAILURE
5365     fi
5366
5367     # Strip any trailing slash from the destination.
5368     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5369
5370     # Check to see that the destination is a directory.
5371     test -d "$dest" && isdir=yes
5372     if test "$isdir" = yes; then
5373       destdir="$dest"
5374       destname=
5375     else
5376       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5377       test "X$destdir" = "X$dest" && destdir=.
5378       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5379
5380       # Not a directory, so check to see that there is only one file specified.
5381       set dummy $files
5382       if test "$#" -gt 2; then
5383         $echo "$modename: \`$dest' is not a directory" 1>&2
5384         $echo "$help" 1>&2
5385         exit $EXIT_FAILURE
5386       fi
5387     fi
5388     case $destdir in
5389     [\\/]* | [A-Za-z]:[\\/]*) ;;
5390     *)
5391       for file in $files; do
5392         case $file in
5393         *.lo) ;;
5394         *)
5395           $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5396           $echo "$help" 1>&2
5397           exit $EXIT_FAILURE
5398           ;;
5399         esac
5400       done
5401       ;;
5402     esac
5403
5404     # This variable tells wrapper scripts just to set variables rather
5405     # than running their programs.
5406     libtool_install_magic="$magic"
5407
5408     staticlibs=
5409     future_libdirs=
5410     current_libdirs=
5411     for file in $files; do
5412
5413       # Do each installation.
5414       case $file in
5415       *.$libext)
5416         # Do the static libraries later.
5417         staticlibs="$staticlibs $file"
5418         ;;
5419
5420       *.la)
5421         # Check to see that this really is a libtool archive.
5422         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5423         else
5424           $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5425           $echo "$help" 1>&2
5426           exit $EXIT_FAILURE
5427         fi
5428
5429         library_names=
5430         old_library=
5431         relink_command=
5432         # If there is no directory component, then add one.
5433         case $file in
5434         */* | *\\*) . $file ;;
5435         *) . ./$file ;;
5436         esac
5437
5438         # Add the libdir to current_libdirs if it is the destination.
5439         if test "X$destdir" = "X$libdir"; then
5440           case "$current_libdirs " in
5441           *" $libdir "*) ;;
5442           *) current_libdirs="$current_libdirs $libdir" ;;
5443           esac
5444         else
5445           # Note the libdir as a future libdir.
5446           case "$future_libdirs " in
5447           *" $libdir "*) ;;
5448           *) future_libdirs="$future_libdirs $libdir" ;;
5449           esac
5450         fi
5451
5452         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5453         test "X$dir" = "X$file/" && dir=
5454         dir="$dir$objdir"
5455
5456         if test -n "$relink_command"; then
5457           # Determine the prefix the user has applied to our future dir.
5458           inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5459
5460           # Don't allow the user to place us outside of our expected
5461           # location b/c this prevents finding dependent libraries that
5462           # are installed to the same prefix.
5463           # At present, this check doesn't affect windows .dll's that
5464           # are installed into $libdir/../bin (currently, that works fine)
5465           # but it's something to keep an eye on.
5466           if test "$inst_prefix_dir" = "$destdir"; then
5467             $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5468             exit $EXIT_FAILURE
5469           fi
5470
5471           if test -n "$inst_prefix_dir"; then
5472             # Stick the inst_prefix_dir data into the link command.
5473             relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
5474           else
5475             relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
5476           fi
5477
5478           $echo "$modename: warning: relinking \`$file'" 1>&2
5479           $show "$relink_command"
5480           if $run eval "$relink_command"; then :
5481           else
5482             $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5483             exit $EXIT_FAILURE
5484           fi
5485         fi
5486
5487         # See the names of the shared library.
5488         set dummy $library_names
5489         if test -n "$2"; then
5490           realname="$2"
5491           shift
5492           shift
5493
5494           srcname="$realname"
5495           test -n "$relink_command" && srcname="$realname"T
5496
5497           # Install the shared library and build the symlinks.
5498           $show "$install_prog $dir/$srcname $destdir/$realname"
5499           $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
5500           if test -n "$stripme" && test -n "$striplib"; then
5501             $show "$striplib $destdir/$realname"
5502             $run eval "$striplib $destdir/$realname" || exit $?
5503           fi
5504
5505           if test "$#" -gt 0; then
5506             # Delete the old symlinks, and create new ones.
5507             for linkname
5508             do
5509               if test "$linkname" != "$realname"; then
5510                 $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
5511                 $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
5512               fi
5513             done
5514           fi
5515
5516           # Do each command in the postinstall commands.
5517           lib="$destdir/$realname"
5518           cmds=$postinstall_cmds
5519           save_ifs="$IFS"; IFS='~'
5520           for cmd in $cmds; do
5521             IFS="$save_ifs"
5522             eval cmd=\"$cmd\"
5523             $show "$cmd"
5524             $run eval "$cmd" || exit $?
5525           done
5526           IFS="$save_ifs"
5527         fi
5528
5529         # Install the pseudo-library for information purposes.
5530         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5531         instname="$dir/$name"i
5532         $show "$install_prog $instname $destdir/$name"
5533         $run eval "$install_prog $instname $destdir/$name" || exit $?
5534
5535         # Maybe install the static library, too.
5536         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
5537         ;;
5538
5539       *.lo)
5540         # Install (i.e. copy) a libtool object.
5541
5542         # Figure out destination file name, if it wasn't already specified.
5543         if test -n "$destname"; then
5544           destfile="$destdir/$destname"
5545         else
5546           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5547           destfile="$destdir/$destfile"
5548         fi
5549
5550         # Deduce the name of the destination old-style object file.
5551         case $destfile in
5552         *.lo)
5553           staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
5554           ;;
5555         *.$objext)
5556           staticdest="$destfile"
5557           destfile=
5558           ;;
5559         *)
5560           $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
5561           $echo "$help" 1>&2
5562           exit $EXIT_FAILURE
5563           ;;
5564         esac
5565
5566         # Install the libtool object if requested.
5567         if test -n "$destfile"; then
5568           $show "$install_prog $file $destfile"
5569           $run eval "$install_prog $file $destfile" || exit $?
5570         fi
5571
5572         # Install the old object if enabled.
5573         if test "$build_old_libs" = yes; then
5574           # Deduce the name of the old-style object file.
5575           staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
5576
5577           $show "$install_prog $staticobj $staticdest"
5578           $run eval "$install_prog \$staticobj \$staticdest" || exit $?
5579         fi
5580         exit $EXIT_SUCCESS
5581         ;;
5582
5583       *)
5584         # Figure out destination file name, if it wasn't already specified.
5585         if test -n "$destname"; then
5586           destfile="$destdir/$destname"
5587         else
5588           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5589           destfile="$destdir/$destfile"
5590         fi
5591
5592         # If the file is missing, and there is a .exe on the end, strip it
5593         # because it is most likely a libtool script we actually want to
5594         # install
5595         stripped_ext=""
5596         case $file in
5597           *.exe)
5598             if test ! -f "$file"; then
5599               file=`$echo $file|${SED} 's,.exe$,,'`
5600               stripped_ext=".exe"
5601             fi
5602             ;;
5603         esac
5604
5605         # Do a test to see if this is really a libtool program.
5606         case $host in
5607         *cygwin*|*mingw*)
5608             wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
5609             ;;
5610         *)
5611             wrapper=$file
5612             ;;
5613         esac
5614         if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
5615           notinst_deplibs=
5616           relink_command=
5617
5618           # To insure that "foo" is sourced, and not "foo.exe",
5619           # finese the cygwin/MSYS system by explicitly sourcing "foo."
5620           # which disallows the automatic-append-.exe behavior.
5621           case $build in
5622           *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
5623           *) wrapperdot=${wrapper} ;;
5624           esac
5625           # If there is no directory component, then add one.
5626           case $file in
5627           */* | *\\*) . ${wrapperdot} ;;
5628           *) . ./${wrapperdot} ;;
5629           esac
5630
5631           # Check the variables that should have been set.
5632           if test -z "$notinst_deplibs"; then
5633             $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
5634             exit $EXIT_FAILURE
5635           fi
5636
5637           finalize=yes
5638           for lib in $notinst_deplibs; do
5639             # Check to see that each library is installed.
5640             libdir=
5641             if test -f "$lib"; then
5642               # If there is no directory component, then add one.
5643               case $lib in
5644               */* | *\\*) . $lib ;;
5645               *) . ./$lib ;;
5646               esac
5647             fi
5648             libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
5649             if test -n "$libdir" && test ! -f "$libfile"; then
5650               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
5651               finalize=no
5652             fi
5653           done
5654
5655           relink_command=
5656           # To insure that "foo" is sourced, and not "foo.exe",
5657           # finese the cygwin/MSYS system by explicitly sourcing "foo."
5658           # which disallows the automatic-append-.exe behavior.
5659           case $build in
5660           *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
5661           *) wrapperdot=${wrapper} ;;
5662           esac
5663           # If there is no directory component, then add one.
5664           case $file in
5665           */* | *\\*) . ${wrapperdot} ;;
5666           *) . ./${wrapperdot} ;;
5667           esac
5668
5669           outputname=
5670           if test "$fast_install" = no && test -n "$relink_command"; then
5671             if test "$finalize" = yes && test -z "$run"; then
5672               tmpdir="/tmp"
5673               test -n "$TMPDIR" && tmpdir="$TMPDIR"
5674               tmpdir="$tmpdir/libtool-$$"
5675               save_umask=`umask`
5676               umask 0077
5677               if $mkdir "$tmpdir"; then
5678                 umask $save_umask
5679               else
5680                 umask $save_umask
5681                 $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
5682                 continue
5683               fi
5684               file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
5685               outputname="$tmpdir/$file"
5686               # Replace the output file specification.
5687               relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
5688
5689               $show "$relink_command"
5690               if $run eval "$relink_command"; then :
5691               else
5692                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5693                 ${rm}r "$tmpdir"
5694                 continue
5695               fi
5696               file="$outputname"
5697             else
5698               $echo "$modename: warning: cannot relink \`$file'" 1>&2
5699             fi
5700           else
5701             # Install the binary that we compiled earlier.
5702             file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
5703           fi
5704         fi
5705
5706         # remove .exe since cygwin /usr/bin/install will append another
5707         # one anyways
5708         case $install_prog,$host in
5709         */usr/bin/install*,*cygwin*)
5710           case $file:$destfile in
5711           *.exe:*.exe)
5712             # this is ok
5713             ;;
5714           *.exe:*)
5715             destfile=$destfile.exe
5716             ;;
5717           *:*.exe)
5718             destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
5719             ;;
5720           esac
5721           ;;
5722         esac
5723         $show "$install_prog$stripme $file $destfile"
5724         $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
5725         test -n "$outputname" && ${rm}r "$tmpdir"
5726         ;;
5727       esac
5728     done
5729
5730     for file in $staticlibs; do
5731       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5732
5733       # Set up the ranlib parameters.
5734       oldlib="$destdir/$name"
5735
5736       $show "$install_prog $file $oldlib"
5737       $run eval "$install_prog \$file \$oldlib" || exit $?
5738
5739       if test -n "$stripme" && test -n "$old_striplib"; then
5740         $show "$old_striplib $oldlib"
5741         $run eval "$old_striplib $oldlib" || exit $?
5742       fi
5743
5744       # Do each command in the postinstall commands.
5745       cmds=$old_postinstall_cmds
5746       save_ifs="$IFS"; IFS='~'
5747       for cmd in $cmds; do
5748         IFS="$save_ifs"
5749         eval cmd=\"$cmd\"
5750         $show "$cmd"
5751         $run eval "$cmd" || exit $?
5752       done
5753       IFS="$save_ifs"
5754     done
5755
5756     if test -n "$future_libdirs"; then
5757       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
5758     fi
5759
5760     if test -n "$current_libdirs"; then
5761       # Maybe just do a dry run.
5762       test -n "$run" && current_libdirs=" -n$current_libdirs"
5763       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
5764     else
5765       exit $EXIT_SUCCESS
5766     fi
5767     ;;
5768
5769   # libtool finish mode
5770   finish)
5771     modename="$modename: finish"
5772     libdirs="$nonopt"
5773     admincmds=
5774
5775     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
5776       for dir
5777       do
5778         libdirs="$libdirs $dir"
5779       done
5780
5781       for libdir in $libdirs; do
5782         if test -n "$finish_cmds"; then
5783           # Do each command in the finish commands.
5784           cmds=$finish_cmds
5785           save_ifs="$IFS"; IFS='~'
5786           for cmd in $cmds; do
5787             IFS="$save_ifs"
5788             eval cmd=\"$cmd\"
5789             $show "$cmd"
5790             $run eval "$cmd" || admincmds="$admincmds
5791        $cmd"
5792           done
5793           IFS="$save_ifs"
5794         fi
5795         if test -n "$finish_eval"; then
5796           # Do the single finish_eval.
5797           eval cmds=\"$finish_eval\"
5798           $run eval "$cmds" || admincmds="$admincmds
5799        $cmds"
5800         fi
5801       done
5802     fi
5803
5804     # Exit here if they wanted silent mode.
5805     test "$show" = : && exit $EXIT_SUCCESS
5806
5807     $echo "----------------------------------------------------------------------"
5808     $echo "Libraries have been installed in:"
5809     for libdir in $libdirs; do
5810       $echo "   $libdir"
5811     done
5812     $echo
5813     $echo "If you ever happen to want to link against installed libraries"
5814     $echo "in a given directory, LIBDIR, you must either use libtool, and"
5815     $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
5816     $echo "flag during linking and do at least one of the following:"
5817     if test -n "$shlibpath_var"; then
5818       $echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
5819       $echo "     during execution"
5820     fi
5821     if test -n "$runpath_var"; then
5822       $echo "   - add LIBDIR to the \`$runpath_var' environment variable"
5823       $echo "     during linking"
5824     fi
5825     if test -n "$hardcode_libdir_flag_spec"; then
5826       libdir=LIBDIR
5827       eval flag=\"$hardcode_libdir_flag_spec\"
5828
5829       $echo "   - use the \`$flag' linker flag"
5830     fi
5831     if test -n "$admincmds"; then
5832       $echo "   - have your system administrator run these commands:$admincmds"
5833     fi
5834     if test -f /etc/ld.so.conf; then
5835       $echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
5836     fi
5837     $echo
5838     $echo "See any operating system documentation about shared libraries for"
5839     $echo "more information, such as the ld(1) and ld.so(8) manual pages."
5840     $echo "----------------------------------------------------------------------"
5841     exit $EXIT_SUCCESS
5842     ;;
5843
5844   # libtool execute mode
5845   execute)
5846     modename="$modename: execute"
5847
5848     # The first argument is the command name.
5849     cmd="$nonopt"
5850     if test -z "$cmd"; then
5851       $echo "$modename: you must specify a COMMAND" 1>&2
5852       $echo "$help"
5853       exit $EXIT_FAILURE
5854     fi
5855
5856     # Handle -dlopen flags immediately.
5857     for file in $execute_dlfiles; do
5858       if test ! -f "$file"; then
5859         $echo "$modename: \`$file' is not a file" 1>&2
5860         $echo "$help" 1>&2
5861         exit $EXIT_FAILURE
5862       fi
5863
5864       dir=
5865       case $file in
5866       *.la)
5867         # Check to see that this really is a libtool archive.
5868         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5869         else
5870           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5871           $echo "$help" 1>&2
5872           exit $EXIT_FAILURE
5873         fi
5874
5875         # Read the libtool library.
5876         dlname=
5877         library_names=
5878
5879         # If there is no directory component, then add one.
5880         case $file in
5881         */* | *\\*) . $file ;;
5882         *) . ./$file ;;
5883         esac
5884
5885         # Skip this library if it cannot be dlopened.
5886         if test -z "$dlname"; then
5887           # Warn if it was a shared library.
5888           test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
5889           continue
5890         fi
5891
5892         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5893         test "X$dir" = "X$file" && dir=.
5894
5895         if test -f "$dir/$objdir/$dlname"; then
5896           dir="$dir/$objdir"
5897         else
5898           $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
5899           exit $EXIT_FAILURE
5900         fi
5901         ;;
5902
5903       *.lo)
5904         # Just add the directory containing the .lo file.
5905         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5906         test "X$dir" = "X$file" && dir=.
5907         ;;
5908
5909       *)
5910         $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
5911         continue
5912         ;;
5913       esac
5914
5915       # Get the absolute pathname.
5916       absdir=`cd "$dir" && pwd`
5917       test -n "$absdir" && dir="$absdir"
5918
5919       # Now add the directory to shlibpath_var.
5920       if eval "test -z \"\$$shlibpath_var\""; then
5921         eval "$shlibpath_var=\"\$dir\""
5922       else
5923         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
5924       fi
5925     done
5926
5927     # This variable tells wrapper scripts just to set shlibpath_var
5928     # rather than running their programs.
5929     libtool_execute_magic="$magic"
5930
5931     # Check if any of the arguments is a wrapper script.
5932     args=
5933     for file
5934     do
5935       case $file in
5936       -*) ;;
5937       *)
5938         # Do a test to see if this is really a libtool program.
5939         if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5940           # If there is no directory component, then add one.
5941           case $file in
5942           */* | *\\*) . $file ;;
5943           *) . ./$file ;;
5944           esac
5945
5946           # Transform arg to wrapped name.
5947           file="$progdir/$program"
5948         fi
5949         ;;
5950       esac
5951       # Quote arguments (to preserve shell metacharacters).
5952       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
5953       args="$args \"$file\""
5954     done
5955
5956     if test -z "$run"; then
5957       if test -n "$shlibpath_var"; then
5958         # Export the shlibpath_var.
5959         eval "export $shlibpath_var"
5960       fi
5961
5962       # Restore saved environment variables
5963       if test "${save_LC_ALL+set}" = set; then
5964         LC_ALL="$save_LC_ALL"; export LC_ALL
5965       fi
5966       if test "${save_LANG+set}" = set; then
5967         LANG="$save_LANG"; export LANG
5968       fi
5969
5970       # Now prepare to actually exec the command.
5971       exec_cmd="\"\$cmd\"$args"
5972     else
5973       # Display what would be done.
5974       if test -n "$shlibpath_var"; then
5975         eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
5976         $echo "export $shlibpath_var"
5977       fi
5978       eval \$echo \"\$cmd\"$args
5979       exit $EXIT_SUCCESS
5980     fi
5981     ;;
5982
5983   # libtool clean and uninstall mode
5984   clean | uninstall)
5985     modename="$modename: $mode"
5986     rm="$nonopt"
5987     files=
5988     rmforce=
5989     exit_status=0
5990
5991     # This variable tells wrapper scripts just to set variables rather
5992     # than running their programs.
5993     libtool_install_magic="$magic"
5994
5995     for arg
5996     do
5997       case $arg in
5998       -f) rm="$rm $arg"; rmforce=yes ;;
5999       -*) rm="$rm $arg" ;;
6000       *) files="$files $arg" ;;
6001       esac
6002     done
6003
6004     if test -z "$rm"; then
6005       $echo "$modename: you must specify an RM program" 1>&2
6006       $echo "$help" 1>&2
6007       exit $EXIT_FAILURE
6008     fi
6009
6010     rmdirs=
6011
6012     origobjdir="$objdir"
6013     for file in $files; do
6014       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6015       if test "X$dir" = "X$file"; then
6016         dir=.
6017         objdir="$origobjdir"
6018       else
6019         objdir="$dir/$origobjdir"
6020       fi
6021       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6022       test "$mode" = uninstall && objdir="$dir"
6023
6024       # Remember objdir for removal later, being careful to avoid duplicates
6025       if test "$mode" = clean; then
6026         case " $rmdirs " in
6027           *" $objdir "*) ;;
6028           *) rmdirs="$rmdirs $objdir" ;;
6029         esac
6030       fi
6031
6032       # Don't error if the file doesn't exist and rm -f was used.
6033       if (test -L "$file") >/dev/null 2>&1 \
6034         || (test -h "$file") >/dev/null 2>&1 \
6035         || test -f "$file"; then
6036         :
6037       elif test -d "$file"; then
6038         exit_status=1
6039         continue
6040       elif test "$rmforce" = yes; then
6041         continue
6042       fi
6043
6044       rmfiles="$file"
6045
6046       case $name in
6047       *.la)
6048         # Possibly a libtool archive, so verify it.
6049         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6050           . $dir/$name
6051
6052           # Delete the libtool libraries and symlinks.
6053           for n in $library_names; do
6054             rmfiles="$rmfiles $objdir/$n"
6055           done
6056           test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
6057           test "$mode" = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
6058
6059           if test "$mode" = uninstall; then
6060             if test -n "$library_names"; then
6061               # Do each command in the postuninstall commands.
6062               cmds=$postuninstall_cmds
6063               save_ifs="$IFS"; IFS='~'
6064               for cmd in $cmds; do
6065                 IFS="$save_ifs"
6066                 eval cmd=\"$cmd\"
6067                 $show "$cmd"
6068                 $run eval "$cmd"
6069                 if test "$?" -ne 0 && test "$rmforce" != yes; then
6070                   exit_status=1
6071                 fi
6072               done
6073               IFS="$save_ifs"
6074             fi
6075
6076             if test -n "$old_library"; then
6077               # Do each command in the old_postuninstall commands.
6078               cmds=$old_postuninstall_cmds
6079               save_ifs="$IFS"; IFS='~'
6080               for cmd in $cmds; do
6081                 IFS="$save_ifs"
6082                 eval cmd=\"$cmd\"
6083                 $show "$cmd"
6084                 $run eval "$cmd"
6085                 if test "$?" -ne 0 && test "$rmforce" != yes; then
6086                   exit_status=1
6087                 fi
6088               done
6089               IFS="$save_ifs"
6090             fi
6091             # FIXME: should reinstall the best remaining shared library.
6092           fi
6093         fi
6094         ;;
6095
6096       *.lo)
6097         # Possibly a libtool object, so verify it.
6098         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6099
6100           # Read the .lo file
6101           . $dir/$name
6102
6103           # Add PIC object to the list of files to remove.
6104           if test -n "$pic_object" \
6105              && test "$pic_object" != none; then
6106             rmfiles="$rmfiles $dir/$pic_object"
6107           fi
6108
6109           # Add non-PIC object to the list of files to remove.
6110           if test -n "$non_pic_object" \
6111              && test "$non_pic_object" != none; then
6112             rmfiles="$rmfiles $dir/$non_pic_object"
6113           fi
6114         fi
6115         ;;
6116
6117       *)
6118         if test "$mode" = clean ; then
6119           noexename=$name
6120           case $file in
6121           *.exe)
6122             file=`$echo $file|${SED} 's,.exe$,,'`
6123             noexename=`$echo $name|${SED} 's,.exe$,,'`
6124             # $file with .exe has already been added to rmfiles,
6125             # add $file without .exe
6126             rmfiles="$rmfiles $file"
6127             ;;
6128           esac
6129           # Do a test to see if this is a libtool program.
6130           if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6131             relink_command=
6132             . $dir/$noexename
6133
6134             # note $name still contains .exe if it was in $file originally
6135             # as does the version of $file that was added into $rmfiles
6136             rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
6137             if test "$fast_install" = yes && test -n "$relink_command"; then
6138               rmfiles="$rmfiles $objdir/lt-$name"
6139             fi
6140             if test "X$noexename" != "X$name" ; then
6141               rmfiles="$rmfiles $objdir/lt-${noexename}.c"
6142             fi
6143           fi
6144         fi
6145         ;;
6146       esac
6147       $show "$rm $rmfiles"
6148       $run $rm $rmfiles || exit_status=1
6149     done
6150     objdir="$origobjdir"
6151
6152     # Try to remove the ${objdir}s in the directories where we deleted files
6153     for dir in $rmdirs; do
6154       if test -d "$dir"; then
6155         $show "rmdir $dir"
6156         $run rmdir $dir >/dev/null 2>&1
6157       fi
6158     done
6159
6160     exit $exit_status
6161     ;;
6162
6163   "")
6164     $echo "$modename: you must specify a MODE" 1>&2
6165     $echo "$generic_help" 1>&2
6166     exit $EXIT_FAILURE
6167     ;;
6168   esac
6169
6170   if test -z "$exec_cmd"; then
6171     $echo "$modename: invalid operation mode \`$mode'" 1>&2
6172     $echo "$generic_help" 1>&2
6173     exit $EXIT_FAILURE
6174   fi
6175 fi # test -z "$show_help"
6176
6177 if test -n "$exec_cmd"; then
6178   eval exec $exec_cmd
6179   exit $EXIT_FAILURE
6180 fi
6181
6182 # We need to display help for each of the modes.
6183 case $mode in
6184 "") $echo \
6185 "Usage: $modename [OPTION]... [MODE-ARG]...
6186
6187 Provide generalized library-building support services.
6188
6189     --config          show all configuration variables
6190     --debug           enable verbose shell tracing
6191 -n, --dry-run         display commands without modifying any files
6192     --features        display basic configuration information and exit
6193     --finish          same as \`--mode=finish'
6194     --help            display this help message and exit
6195     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
6196     --quiet           same as \`--silent'
6197     --silent          don't print informational messages
6198     --tag=TAG         use configuration variables from tag TAG
6199     --version         print version information
6200
6201 MODE must be one of the following:
6202
6203       clean           remove files from the build directory
6204       compile         compile a source file into a libtool object
6205       execute         automatically set library path, then run a program
6206       finish          complete the installation of libtool libraries
6207       install         install libraries or executables
6208       link            create a library or an executable
6209       uninstall       remove libraries from an installed directory
6210
6211 MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
6212 a more detailed description of MODE.
6213
6214 Report bugs to <bug-libtool@gnu.org>."
6215   exit $EXIT_SUCCESS
6216   ;;
6217
6218 clean)
6219   $echo \
6220 "Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
6221
6222 Remove files from the build directory.
6223
6224 RM is the name of the program to use to delete files associated with each FILE
6225 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6226 to RM.
6227
6228 If FILE is a libtool library, object or program, all the files associated
6229 with it are deleted. Otherwise, only FILE itself is deleted using RM."
6230   ;;
6231
6232 compile)
6233   $echo \
6234 "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
6235
6236 Compile a source file into a libtool library object.
6237
6238 This mode accepts the following additional options:
6239
6240   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
6241   -prefer-pic       try to building PIC objects only
6242   -prefer-non-pic   try to building non-PIC objects only
6243   -static           always build a \`.o' file suitable for static linking
6244
6245 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
6246 from the given SOURCEFILE.
6247
6248 The output file name is determined by removing the directory component from
6249 SOURCEFILE, then substituting the C source code suffix \`.c' with the
6250 library object suffix, \`.lo'."
6251   ;;
6252
6253 execute)
6254   $echo \
6255 "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
6256
6257 Automatically set library path, then run a program.
6258
6259 This mode accepts the following additional options:
6260
6261   -dlopen FILE      add the directory containing FILE to the library path
6262
6263 This mode sets the library path environment variable according to \`-dlopen'
6264 flags.
6265
6266 If any of the ARGS are libtool executable wrappers, then they are translated
6267 into their corresponding uninstalled binary, and any of their required library
6268 directories are added to the library path.
6269
6270 Then, COMMAND is executed, with ARGS as arguments."
6271   ;;
6272
6273 finish)
6274   $echo \
6275 "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
6276
6277 Complete the installation of libtool libraries.
6278
6279 Each LIBDIR is a directory that contains libtool libraries.
6280
6281 The commands that this mode executes may require superuser privileges.  Use
6282 the \`--dry-run' option if you just want to see what would be executed."
6283   ;;
6284
6285 install)
6286   $echo \
6287 "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
6288
6289 Install executables or libraries.
6290
6291 INSTALL-COMMAND is the installation command.  The first component should be
6292 either the \`install' or \`cp' program.
6293
6294 The rest of the components are interpreted as arguments to that command (only
6295 BSD-compatible install options are recognized)."
6296   ;;
6297
6298 link)
6299   $echo \
6300 "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
6301
6302 Link object files or libraries together to form another library, or to
6303 create an executable program.
6304
6305 LINK-COMMAND is a command using the C compiler that you would use to create
6306 a program from several object files.
6307
6308 The following components of LINK-COMMAND are treated specially:
6309
6310   -all-static       do not do any dynamic linking at all
6311   -avoid-version    do not add a version suffix if possible
6312   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
6313   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
6314   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
6315   -export-symbols SYMFILE
6316                     try to export only the symbols listed in SYMFILE
6317   -export-symbols-regex REGEX
6318                     try to export only the symbols matching REGEX
6319   -LLIBDIR          search LIBDIR for required installed libraries
6320   -lNAME            OUTPUT-FILE requires the installed library libNAME
6321   -module           build a library that can dlopened
6322   -no-fast-install  disable the fast-install mode
6323   -no-install       link a not-installable executable
6324   -no-undefined     declare that a library does not refer to external symbols
6325   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
6326   -objectlist FILE  Use a list of object files found in FILE to specify objects
6327   -precious-files-regex REGEX
6328                     don't remove output files matching REGEX
6329   -release RELEASE  specify package release information
6330   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
6331   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
6332   -static           do not do any dynamic linking of libtool libraries
6333   -version-info CURRENT[:REVISION[:AGE]]
6334                     specify library version info [each variable defaults to 0]
6335
6336 All other options (arguments beginning with \`-') are ignored.
6337
6338 Every other argument is treated as a filename.  Files ending in \`.la' are
6339 treated as uninstalled libtool libraries, other files are standard or library
6340 object files.
6341
6342 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
6343 only library objects (\`.lo' files) may be specified, and \`-rpath' is
6344 required, except when creating a convenience library.
6345
6346 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
6347 using \`ar' and \`ranlib', or on Windows using \`lib'.
6348
6349 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
6350 is created, otherwise an executable program is created."
6351   ;;
6352
6353 uninstall)
6354   $echo \
6355 "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
6356
6357 Remove libraries from an installation directory.
6358
6359 RM is the name of the program to use to delete files associated with each FILE
6360 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6361 to RM.
6362
6363 If FILE is a libtool library, all the files associated with it are deleted.
6364 Otherwise, only FILE itself is deleted using RM."
6365   ;;
6366
6367 *)
6368   $echo "$modename: invalid operation mode \`$mode'" 1>&2
6369   $echo "$help" 1>&2
6370   exit $EXIT_FAILURE
6371   ;;
6372 esac
6373
6374 $echo
6375 $echo "Try \`$modename --help' for more information about other modes."
6376
6377 exit $EXIT_SUCCESS
6378
6379 # The TAGs below are defined such that we never get into a situation
6380 # in which we disable both kinds of libraries.  Given conflicting
6381 # choices, we go for a static library, that is the most portable,
6382 # since we can't tell whether shared libraries were disabled because
6383 # the user asked for that or because the platform doesn't support
6384 # them.  This is particularly important on AIX, because we don't
6385 # support having both static and shared libraries enabled at the same
6386 # time on that platform, so we default to a shared-only configuration.
6387 # If a disable-shared tag is given, we'll fallback to a static-only
6388 # configuration.  But we'll never go from static-only to shared-only.
6389
6390 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
6391 build_libtool_libs=no
6392 build_old_libs=yes
6393 # ### END LIBTOOL TAG CONFIG: disable-shared
6394
6395 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
6396 build_old_libs=`case $build_libtool_libs in yes) $echo no;; *) $echo yes;; esac`
6397 # ### END LIBTOOL TAG CONFIG: disable-static
6398
6399 # Local Variables:
6400 # mode:shell-script
6401 # sh-indentation:2
6402 # End: