ltmain.sh

   1 # ltmain.sh - Provide generalized library-building support services.
   2 # NOTE: Changing this file will not affect anything until you rerun ltconfig.
   3 #
   4 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
   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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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 # Check that we have a working $echo.
  28 if test "X$1" = X--no-reexec; then
  29   # Discard the --no-reexec flag, and continue.
  30   shift
  31 elif test "X$1" = X--fallback-echo; then
  32   # Avoid inline document here, it may be left over
  33   :
  34 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
  35   # Yippee, $echo works!
  36   :
  37 else
  38   # Restart under the correct shell, and then maybe $echo will work.
  39   exec $SHELL "$0" --no-reexec ${1+"$@"}
  40 fi
  41
  42 if test "X$1" = X--fallback-echo; then
  43   # used as fallback echo
  44   shift
  45   cat <<EOF
  46 $*
  47 EOF
  48   exit 0
  49 fi
  50
  51 # The name of this program.
  52 progname=`$echo "$0" | sed 's%^.*/%%'`
  53 modename="$progname"
  54
  55 # Constants.
  56 PROGRAM=ltmain.sh
  57 PACKAGE=libtool
  58 VERSION=1.4a-GCC3.0
  59 TIMESTAMP=" (1.641.2.256 2001/05/28 20:09:07 with GCC-local changes)"
  60
  61 default_mode=
  62 help="Try \`$progname --help' for more information."
  63 magic="%%%MAGIC variable%%%"
  64 mkdir="mkdir"
  65 mv="mv -f"
  66 rm="rm -f"
  67
  68 # Sed substitution that helps us do robust quoting.  It backslashifies
  69 # metacharacters that are still active within double-quoted strings.
  70 Xsed='sed -e 1s/^X//'
  71 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
  72 SP2NL='tr \040 \012'
  73 NL2SP='tr \015\012 \040\040'
  74
  75 # NLS nuisances.
  76 # Only set LANG and LC_ALL to C if already set.
  77 # These must not be set unconditionally because not all systems understand
  78 # e.g. LANG=C (notably SCO).
  79 # We save the old values to restore during execute mode.
  80 if test "${LC_ALL+set}" = set; then
  81   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
  82 fi
  83 if test "${LANG+set}" = set; then
  84   save_LANG="$LANG"; LANG=C; export LANG
  85 fi
  86
  87 if test "$LTCONFIG_VERSION" != "$VERSION"; then
  88   echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2
  89   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  90   exit 1
  91 fi
  92
  93 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
  94   echo "$modename: not configured to build any kind of library" 1>&2
  95   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  96   exit 1
  97 fi
  98
  99 # Global variables.
 100 mode=$default_mode
 101 nonopt=
 102 prev=
 103 prevopt=
 104 run=
 105 show="$echo"
 106 show_help=
 107 execute_dlfiles=
 108 lo2o="s/\\.lo\$/.${objext}/"
 109 o2lo="s/\\.${objext}\$/.lo/"
 110 taglist=
 111
 112 # Parse our command line options once, thoroughly.
 113 while test $# -gt 0
 114 do
 115   arg="$1"
 116   shift
 117
 118   case $arg in
 119   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
 120   *) optarg= ;;
 121   esac
 122
 123   # If the previous option needs an argument, assign it.
 124   if test -n "$prev"; then
 125     case $prev in
 126     execute_dlfiles)
 127       execute_dlfiles="$execute_dlfiles $arg"
 128       ;;
 129     tag)
 130       tagname="$arg"
 131
 132       # Check whether tagname contains only valid characters
 133       case $tagname in
 134       *[!-_A-Za-z0-9,/]*)
 135         echo "$progname: invalid tag name: $tagname" 1>&2
 136         exit 1
 137         ;;
 138       esac
 139
 140       case $tagname in
 141       CC)
 142         # Don't test for the "default" C tag, as we know, it's there, but
 143         # not specially marked.
 144         taglist="$taglist $tagname"
 145         ;;
 146       *)
 147         if grep "^### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$0" > /dev/null; then
 148           taglist="$taglist $tagname"
 149           # Evaluate the configuration.
 150           eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $0`"
 151         else
 152           echo "$progname: ignoring unknown tag $tagname" 1>&2
 153         fi
 154         ;;
 155       esac
 156       ;;
 157     *)
 158       eval "$prev=\$arg"
 159       ;;
 160     esac
 161
 162     prev=
 163     prevopt=
 164     continue
 165   fi
 166
 167   # Have we seen a non-optional argument yet?
 168   case $arg in
 169   --help)
 170     show_help=yes
 171     ;;
 172
 173   --version)
 174     echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
 175     exit 0
 176     ;;
 177
 178   --config)
 179     sed -n -e '/^### BEGIN LIBTOOL CONFIG/,/^### END LIBTOOL CONFIG/p' < "$0"
 180     # Now print the configurations for the tags.
 181     for tagname in $taglist; do
 182       sed -n -e "/^### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^### END LIBTOOL TAG CONFIG: $tagname$/p" < "$0"
 183     done
 184     exit 0
 185     ;;
 186
 187   --debug)
 188     echo "$progname: enabling shell trace mode"
 189     set -x
 190     ;;
 191
 192   --dry-run | -n)
 193     run=:
 194     ;;
 195
 196   --features)
 197     echo "host: $host"
 198     if test "$build_libtool_libs" = yes; then
 199       echo "enable shared libraries"
 200     else
 201       echo "disable shared libraries"
 202     fi
 203     if test "$build_old_libs" = yes; then
 204       echo "enable static libraries"
 205     else
 206       echo "disable static libraries"
 207     fi
 208     exit 0
 209     ;;
 210
 211   --finish) mode="finish" ;;
 212
 213   --mode) prevopt="--mode" prev=mode ;;
 214   --mode=*) mode="$optarg" ;;
 215
 216   --quiet | --silent)
 217     show=:
 218     ;;
 219
 220   --tag) prevopt="--tag" prev=tag ;;
 221   --tag=*)
 222     set tag "$optarg" ${1+"$@"}
 223     shift
 224     prev=tag
 225     ;;
 226
 227   -dlopen)
 228     prevopt="-dlopen"
 229     prev=execute_dlfiles
 230     ;;
 231
 232   -*)
 233     $echo "$modename: unrecognized option \`$arg'" 1>&2
 234     $echo "$help" 1>&2
 235     exit 1
 236     ;;
 237
 238   *)
 239     nonopt="$arg"
 240     break
 241     ;;
 242   esac
 243 done
 244
 245 if test -n "$prevopt"; then
 246   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
 247   $echo "$help" 1>&2
 248   exit 1
 249 fi
 250
 251 # If this variable is set in any of the actions, the command in it
 252 # will be execed at the end.  This prevents here-documents from being
 253 # left over by shells.
 254 exec_cmd=
 255
 256 if test -z "$show_help"; then
 257
 258   # Infer the operation mode.
 259   if test -z "$mode"; then
 260     case $nonopt in
 261     *cc | *++ | gcc* | *-gcc*)
 262       mode=link
 263       for arg
 264       do
 265         case $arg in
 266         -c)
 267            mode=compile
 268            break
 269            ;;
 270         esac
 271       done
 272       ;;
 273     *db | *dbx | *strace | *truss)
 274       mode=execute
 275       ;;
 276     *install*|cp|mv)
 277       mode=install
 278       ;;
 279     *rm)
 280       mode=uninstall
 281       ;;
 282     *)
 283       # If we have no mode, but dlfiles were specified, then do execute mode.
 284       test -n "$execute_dlfiles" && mode=execute
 285
 286       # Just use the default operation mode.
 287       if test -z "$mode"; then
 288         if test -n "$nonopt"; then
 289           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
 290         else
 291           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
 292         fi
 293       fi
 294       ;;
 295     esac
 296   fi
 297
 298   # Only execute mode is allowed to have -dlopen flags.
 299   if test -n "$execute_dlfiles" && test "$mode" != execute; then
 300     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
 301     $echo "$help" 1>&2
 302     exit 1
 303   fi
 304
 305   # Change the help message to a mode-specific one.
 306   generic_help="$help"
 307   help="Try \`$modename --help --mode=$mode' for more information."
 308
 309   # These modes are in order of execution frequency so that they run quickly.
 310   case $mode in
 311   # libtool compile mode
 312   compile)
 313     modename="$modename: compile"
 314     # Get the compilation command and the source file.
 315     base_compile=
 316     prev=
 317     lastarg=
 318     srcfile="$nonopt"
 319     suppress_output=
 320
 321     user_target=no
 322     for arg
 323     do
 324       case $prev in
 325       "") ;;
 326       xcompiler)
 327         # Aesthetically quote the previous argument.
 328         prev=
 329         lastarg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
 330
 331         case $arg in
 332         # Double-quote args containing other shell metacharacters.
 333         # Many Bourne shells cannot handle close brackets correctly
 334         # in scan sets, so we specify it separately.
 335         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
 336           arg="\"$arg\""
 337           ;;
 338         esac
 339
 340         # Add the previous argument to base_compile.
 341         if test -z "$base_compile"; then
 342           base_compile="$lastarg"
 343         else
 344           base_compile="$base_compile $lastarg"
 345         fi
 346         continue
 347         ;;
 348       esac
 349
 350       # Accept any command-line options.
 351       case $arg in
 352       -o)
 353         if test "$user_target" != "no"; then
 354           $echo "$modename: you cannot specify \`-o' more than once" 1>&2
 355           exit 1
 356         fi
 357         user_target=next
 358         ;;
 359
 360       -static)
 361         build_old_libs=yes
 362         continue
 363         ;;
 364
 365       -prefer-pic)
 366         pic_mode=yes
 367         continue
 368         ;;
 369
 370       -prefer-non-pic)
 371         pic_mode=no
 372         continue
 373         ;;
 374
 375       -Xcompiler)
 376         prev=xcompiler
 377         continue
 378         ;;
 379
 380       -Wc,*)
 381         args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
 382         lastarg=
 383         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
 384         for arg in $args; do
 385           IFS="$save_ifs"
 386
 387           # Double-quote args containing other shell metacharacters.
 388           # Many Bourne shells cannot handle close brackets correctly
 389           # in scan sets, so we specify it separately.
 390           case $arg in
 391             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
 392             arg="\"$arg\""
 393             ;;
 394           esac
 395           lastarg="$lastarg $arg"
 396         done
 397         IFS="$save_ifs"
 398         lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
 399
 400         # Add the arguments to base_compile.
 401         if test -z "$base_compile"; then
 402           base_compile="$lastarg"
 403         else
 404           base_compile="$base_compile $lastarg"
 405         fi
 406         continue
 407         ;;
 408       esac
 409
 410       case $user_target in
 411       next)
 412         # The next one is the -o target name
 413         user_target=yes
 414         continue
 415         ;;
 416       yes)
 417         # We got the output file
 418         user_target=set
 419         libobj="$arg"
 420         continue
 421         ;;
 422       esac
 423
 424       # Accept the current argument as the source file.
 425       lastarg="$srcfile"
 426       srcfile="$arg"
 427
 428       # Aesthetically quote the previous argument.
 429
 430       # Backslashify any backslashes, double quotes, and dollar signs.
 431       # These are the only characters that are still specially
 432       # interpreted inside of double-quoted scrings.
 433       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
 434
 435       # Double-quote args containing other shell metacharacters.
 436       # Many Bourne shells cannot handle close brackets correctly
 437       # in scan sets, so we specify it separately.
 438       case $lastarg in
 439       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 440         lastarg="\"$lastarg\""
 441         ;;
 442       esac
 443
 444       # Add the previous argument to base_compile.
 445       if test -z "$base_compile"; then
 446         base_compile="$lastarg"
 447       else
 448         base_compile="$base_compile $lastarg"
 449       fi
 450     done
 451
 452     case $user_target in
 453     set)
 454       ;;
 455     no)
 456       # Get the name of the library object.
 457       libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
 458       ;;
 459     *)
 460       $echo "$modename: you must specify a target with \`-o'" 1>&2
 461       exit 1
 462       ;;
 463     esac
 464
 465     # Recognize several different file suffixes.
 466     # If the user specifies -o file.o, it is replaced with file.lo
 467     xform='[cCFSfmso]'
 468     case $libobj in
 469     *.ada) xform=ada ;;
 470     *.adb) xform=adb ;;
 471     *.ads) xform=ads ;;
 472     *.asm) xform=asm ;;
 473     *.c++) xform=c++ ;;
 474     *.cc) xform=cc ;;
 475     *.class) xform=class ;;
 476     *.cpp) xform=cpp ;;
 477     *.cxx) xform=cxx ;;
 478     *.f90) xform=f90 ;;
 479     *.for) xform=for ;;
 480     *.java) xform=java ;;
 481     esac
 482
 483     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
 484
 485     case $libobj in
 486     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
 487     *)
 488       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
 489       exit 1
 490       ;;
 491     esac
 492
 493     # Infer tagged configuration to use if any are available and
 494     # if one wasn't chosen via the "--tag" command line option.
 495     # Only attempt this if the compiler in the base compile
 496     # command doesn't match the default compiler.
 497     if test -n "$available_tags" && test -z "$tagname"; then
 498       case $base_compile in
 499       "$CC "*) ;;
 500       # Blanks in the command may have been stripped by the calling shell,
 501       # but not from the CC environment variable when ltconfig was run.
 502       "`$echo $CC` "*) ;;
 503       *)
 504         for z in $available_tags; do
 505           if grep "^### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
 506             # Evaluate the configuration.
 507             eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
 508             case $base_compile in
 509             "$CC "*)
 510               # The compiler in the base compile command matches
 511               # the one in the tagged configuration.
 512               # Assume this is the tagged configuration we want.
 513               tagname=$z
 514               break
 515               ;;
 516             "`$echo $CC` "*)
 517               tagname=$z
 518               break
 519               ;;
 520             esac
 521           fi
 522         done
 523         # If $tagname still isn't set, then no tagged configuration
 524         # was found and let the user know that the "--tag" command
 525         # line option must be used.
 526         if test -z "$tagname"; then
 527           echo "$modename: unable to infer tagged configuration"
 528           echo "$modename: specify a tag with \`--tag'" 1>&2
 529           exit 1
 530 #        else
 531 #          echo "$modename: using $tagname tagged configuration"
 532         fi
 533         ;;
 534       esac
 535     fi
 536
 537     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
 538     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
 539     if test "X$xdir" = "X$obj"; then
 540       xdir=
 541     else
 542       xdir=$xdir/
 543     fi
 544     lobj=${xdir}$objdir/$objname
 545
 546     if test -z "$base_compile"; then
 547       $echo "$modename: you must specify a compilation command" 1>&2
 548       $echo "$help" 1>&2
 549       exit 1
 550     fi
 551
 552     # Delete any leftover library objects.
 553     if test "$build_old_libs" = yes; then
 554       removelist="$obj $lobj $libobj ${libobj}T"
 555     else
 556       removelist="$lobj $libobj ${libobj}T"
 557     fi
 558
 559     $run $rm $removelist
 560     trap "$run $rm $removelist; exit 1" 1 2 15
 561
 562     # On Cygwin there's no "real" PIC flag so we must build both object types
 563     case $host_os in
 564     cygwin* | mingw* | pw32* | os2*)
 565       pic_mode=default
 566       ;;
 567     esac
 568     if test $pic_mode = no && test "$deplibs_check_method" != pass_all; then
 569       # non-PIC code in shared libraries is not supported
 570       pic_mode=default
 571     fi
 572
 573     # Calculate the filename of the output object if compiler does
 574     # not support -o with -c
 575     if test "$compiler_c_o" = no; then
 576       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
 577       lockfile="$output_obj.lock"
 578       removelist="$removelist $output_obj $lockfile"
 579       trap "$run $rm $removelist; exit 1" 1 2 15
 580     else
 581       output_obj=
 582       need_locks=no
 583       lockfile=
 584     fi
 585
 586     # Lock this critical section if it is needed
 587     # We use this script file to make the link, it avoids creating a new file
 588     if test "$need_locks" = yes; then
 589       until $run ln "$0" "$lockfile" 2>/dev/null; do
 590         $show "Waiting for $lockfile to be removed"
 591         sleep 2
 592       done
 593     elif test "$need_locks" = warn; then
 594       if test -f "$lockfile"; then
 595         echo "\
 596 *** ERROR, $lockfile exists and contains:
 597 `cat $lockfile 2>/dev/null`
 598
 599 This indicates that another process is trying to use the same
 600 temporary object file, and libtool could not work around it because
 601 your compiler does not support \`-c' and \`-o' together.  If you
 602 repeat this compilation, it may succeed, by chance, but you had better
 603 avoid parallel builds (make -j) in this platform, or get a better
 604 compiler."
 605
 606         $run $rm $removelist
 607         exit 1
 608       fi
 609       echo $srcfile > "$lockfile"
 610     fi
 611
 612     if test -n "$fix_srcfile_path"; then
 613       eval srcfile=\"$fix_srcfile_path\"
 614     fi
 615
 616     $run $rm "$libobj" "${libobj}T"
 617
 618     # Create a libtool object file (analogous to a ".la" file),
 619     # but don't create it if we're doing a dry run.
 620     test -z "$run" && cat > ${libobj}T <<EOF
 621 # $libobj - a libtool object file
 622 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 623 #
 624 # Please DO NOT delete this file!
 625 # It is necessary for linking the library.
 626
 627 # Name of the PIC object.
 628 EOF
 629
 630     # Only build a PIC object if we are building libtool libraries.
 631     if test "$build_libtool_libs" = yes; then
 632       # Without this assignment, base_compile gets emptied.
 633       fbsd_hideous_sh_bug=$base_compile
 634
 635       if test "$pic_mode" != no; then
 636         command="$base_compile $srcfile $pic_flag"
 637       else
 638         # Don't build PIC code
 639         command="$base_compile $srcfile"
 640       fi
 641
 642       if test ! -d ${xdir}$objdir; then
 643         $show "$mkdir ${xdir}$objdir"
 644         $run $mkdir ${xdir}$objdir
 645         status=$?
 646         if test $status -ne 0 && test ! -d ${xdir}$objdir; then
 647           exit $status
 648         fi
 649       fi
 650
 651       if test -z "$output_obj"; then
 652         # Place PIC objects in $objdir
 653         command="$command -o $lobj"
 654       fi
 655
 656       $run $rm "$lobj" "$output_obj"
 657
 658       $show "$command"
 659       if $run eval "$command"; then :
 660       else
 661         test -n "$output_obj" && $run $rm $removelist
 662         exit 1
 663       fi
 664
 665       if test "$need_locks" = warn &&
 666          test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
 667         echo "\
 668 *** ERROR, $lockfile contains:
 669 `cat $lockfile 2>/dev/null`
 670
 671 but it should contain:
 672 $srcfile
 673
 674 This indicates that another process is trying to use the same
 675 temporary object file, and libtool could not work around it because
 676 your compiler does not support \`-c' and \`-o' together.  If you
 677 repeat this compilation, it may succeed, by chance, but you had better
 678 avoid parallel builds (make -j) in this platform, or get a better
 679 compiler."
 680
 681         $run $rm $removelist
 682         exit 1
 683       fi
 684
 685       # Just move the object if needed, then go on to compile the next one
 686       if test -n "$output_obj" && test "x$output_obj" != "x$lobj"; then
 687         $show "$mv $output_obj $lobj"
 688         if $run $mv $output_obj $lobj; then :
 689         else
 690           error=$?
 691           $run $rm $removelist
 692           exit $error
 693         fi
 694       fi
 695
 696       # Append the name of the PIC object to the libtool object file.
 697       test -z "$run" && cat >> ${libobj}T <<EOF
 698 pic_object='$objdir/$objname'
 699
 700 EOF
 701
 702       # Allow error messages only from the first compilation.
 703       suppress_output=' >/dev/null 2>&1'
 704     else
 705       # No PIC object so indicate it doesn't exist in the libtool
 706       # object file.
 707       test -z "$run" && cat >> ${libobj}T <<EOF
 708 pic_object=none
 709
 710 EOF
 711     fi
 712
 713     # Only build a position-dependent object if we build old libraries.
 714     if test "$build_old_libs" = yes; then
 715       if test "$pic_mode" != yes; then
 716         # Don't build PIC code
 717         command="$base_compile $srcfile"
 718       else
 719         command="$base_compile $srcfile $pic_flag"
 720       fi
 721       if test "$compiler_c_o" = yes; then
 722         command="$command -o $obj"
 723       fi
 724
 725       # Suppress compiler output if we already did a PIC compilation.
 726       command="$command$suppress_output"
 727       $run $rm "$obj" "$output_obj"
 728       $show "$command"
 729       if $run eval "$command"; then :
 730       else
 731         $run $rm $removelist
 732         exit 1
 733       fi
 734
 735       if test "$need_locks" = warn &&
 736          test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
 737         echo "\
 738 *** ERROR, $lockfile contains:
 739 `cat $lockfile 2>/dev/null`
 740
 741 but it should contain:
 742 $srcfile
 743
 744 This indicates that another process is trying to use the same
 745 temporary object file, and libtool could not work around it because
 746 your compiler does not support \`-c' and \`-o' together.  If you
 747 repeat this compilation, it may succeed, by chance, but you had better
 748 avoid parallel builds (make -j) in this platform, or get a better
 749 compiler."
 750
 751         $run $rm $removelist
 752         exit 1
 753       fi
 754
 755       # Just move the object if needed
 756       if test -n "$output_obj" && test "x$output_obj" != "x$obj"; then
 757         $show "$mv $output_obj $obj"
 758         if $run $mv $output_obj $obj; then :
 759         else
 760           error=$?
 761           $run $rm $removelist
 762           exit $error
 763         fi
 764       fi
 765
 766       # Append the name of the non-PIC object the libtool object file.
 767       # Only append if the libtool object file exists.
 768       test -z "$run" && cat >> ${libobj}T <<EOF
 769 # Name of the non-PIC object.
 770 non_pic_object='$objname'
 771
 772 EOF
 773     else
 774       # Append the name of the non-PIC object the libtool object file.
 775       # Only append if the libtool object file exists.
 776       test -z "$run" && cat >> ${libobj}T <<EOF
 777 # Name of the non-PIC object.
 778 non_pic_object=none
 779
 780 EOF
 781     fi
 782
 783     $run $mv "${libobj}T" "${libobj}"
 784
 785     # Unlock the critical section if it was locked
 786     if test "$need_locks" != no; then
 787       $run $rm "$lockfile"
 788     fi
 789
 790     exit 0
 791     ;;
 792
 793   # libtool link mode
 794   link | relink)
 795     modename="$modename: link"
 796     case $host in
 797     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 798       # It is impossible to link a dll without this setting, and
 799       # we shouldn't force the makefile maintainer to figure out
 800       # which system we are compiling for in order to pass an extra
 801       # flag for every libtool invokation.
 802       # allow_undefined=no
 803
 804       # FIXME: Unfortunately, there are problems with the above when trying
 805       # to make a dll which has undefined symbols, in which case not
 806       # even a static library is built.  For now, we need to specify
 807       # -no-undefined on the libtool link line when we can be certain
 808       # that all symbols are satisfied, otherwise we get a static library.
 809       allow_undefined=yes
 810       ;;
 811     *)
 812       allow_undefined=yes
 813       ;;
 814     esac
 815     libtool_args="$nonopt"
 816     base_compile="$nonopt"
 817     compile_command="$nonopt"
 818     finalize_command="$nonopt"
 819
 820     compile_rpath=
 821     finalize_rpath=
 822     compile_shlibpath=
 823     finalize_shlibpath=
 824     convenience=
 825     old_convenience=
 826     deplibs=
 827     old_deplibs=
 828     compiler_flags=
 829     linker_flags=
 830     dllsearchpath=
 831     lib_search_path=`pwd`
 832
 833     avoid_version=no
 834     dlfiles=
 835     dlprefiles=
 836     dlself=no
 837     export_dynamic=no
 838     export_symbols=
 839     export_symbols_regex=
 840     generated=
 841     libobjs=
 842     ltlibs=
 843     module=no
 844     no_install=no
 845     objs=
 846     non_pic_objects=
 847     prefer_static_libs=no
 848     preload=no
 849     prev=
 850     prevarg=
 851     release=
 852     rpath=
 853     xrpath=
 854     perm_rpath=
 855     temp_rpath=
 856     thread_safe=no
 857     vinfo=
 858
 859     # We need to know -static, to get the right output filenames.
 860     for arg
 861     do
 862       case $arg in
 863       -all-static | -static)
 864         if test "X$arg" = "X-all-static"; then
 865           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
 866             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
 867           fi
 868           if test -n "$link_static_flag"; then
 869             dlopen_self=$dlopen_self_static
 870           fi
 871         else
 872           if test -z "$pic_flag" && test -n "$link_static_flag"; then
 873             dlopen_self=$dlopen_self_static
 874           fi
 875         fi
 876         build_libtool_libs=no
 877         build_old_libs=yes
 878         prefer_static_libs=yes
 879         break
 880         ;;
 881       esac
 882     done
 883
 884     # See if our shared archives depend on static archives.
 885     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
 886
 887     # Go through the arguments, transforming them on the way.
 888     while test $# -gt 0; do
 889       arg="$1"
 890       base_compile="$base_compile $arg"
 891       shift
 892       case $arg in
 893       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 894         qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
 895         ;;
 896       *) qarg=$arg ;;
 897       esac
 898       libtool_args="$libtool_args $qarg"
 899
 900       # If the previous option needs an argument, assign it.
 901       if test -n "$prev"; then
 902         case $prev in
 903         output)
 904           compile_command="$compile_command @OUTPUT@"
 905           finalize_command="$finalize_command @OUTPUT@"
 906           ;;
 907         esac
 908
 909         case $prev in
 910         dlfiles|dlprefiles)
 911           if test "$preload" = no; then
 912             # Add the symbol object into the linking commands.
 913             compile_command="$compile_command @SYMFILE@"
 914             finalize_command="$finalize_command @SYMFILE@"
 915             preload=yes
 916           fi
 917           case $arg in
 918           *.la | *.lo) ;;  # We handle these cases below.
 919           force)
 920             if test "$dlself" = no; then
 921               dlself=needless
 922               export_dynamic=yes
 923             fi
 924             prev=
 925             continue
 926             ;;
 927           self)
 928             if test "$prev" = dlprefiles; then
 929               dlself=yes
 930             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
 931               dlself=yes
 932             else
 933               dlself=needless
 934               export_dynamic=yes
 935             fi
 936             prev=
 937             continue
 938             ;;
 939           *)
 940             if test "$prev" = dlfiles; then
 941               dlfiles="$dlfiles $arg"
 942             else
 943               dlprefiles="$dlprefiles $arg"
 944             fi
 945             prev=
 946             continue
 947             ;;
 948           esac
 949           ;;
 950         expsyms)
 951           export_symbols="$arg"
 952           if test ! -f "$arg"; then
 953             $echo "$modename: symbol file \`$arg' does not exist"
 954             exit 1
 955           fi
 956           prev=
 957           continue
 958           ;;
 959         expsyms_regex)
 960           export_symbols_regex="$arg"
 961           prev=
 962           continue
 963           ;;
 964         release)
 965           release="-$arg"
 966           prev=
 967           continue
 968           ;;
 969         objectlist)
 970           if test -f "$arg"; then
 971             save_arg=$arg
 972             moreargs=
 973             for fil in `cat $save_arg`
 974             do
 975 #             moreargs="$moreargs $fil"
 976               arg=$fil
 977               # A libtool-controlled object.
 978
 979               # Check to see that this really is a libtool object.
 980               if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 981                 pic_object=
 982                 non_pic_object=
 983
 984                 # Read the .lo file
 985                 # If there is no directory component, then add one.
 986                 case $arg in
 987                 */* | *\\*) . $arg ;;
 988                 *) . ./$arg ;;
 989                 esac
 990
 991                 if test -z "$pic_object" || \
 992                    test -z "$non_pic_object" ||
 993                    test "$pic_object" = none && \
 994                    test "$non_pic_object" = none; then
 995                   $echo "$modename: cannot find name of object for \`$arg'" 1>&2
 996                   exit 1
 997                 fi
 998
 999                 # Extract subdirectory from the argument.
1000                 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1001                 if test "X$xdir" = "X$arg"; then
1002                   xdir=
1003                 else
1004                   xdir="$xdir/"
1005                 fi
1006
1007                 if test "$pic_object" != none; then
1008                   # Prepend the subdirectory the object is found in.
1009                   pic_object="$xdir$pic_object"
1010
1011                   if test "$prev" = dlfiles; then
1012                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1013                       dlfiles="$dlfiles $pic_object"
1014                       prev=
1015                       continue
1016                     else
1017                       # If libtool objects are unsupported, then we need to preload.
1018                       prev=dlprefiles
1019                     fi
1020                   fi
1021
1022                   # CHECK ME:  I think I busted this.  -Ossama
1023                   if test "$prev" = dlprefiles; then
1024                     # Preload the old-style object.
1025                     dlprefiles="$dlprefiles $pic_object"
1026                     prev=
1027                   fi
1028
1029                   # A PIC object.
1030                   libobjs="$libobjs $pic_object"
1031                   arg="$pic_object"
1032                 fi
1033
1034                 # Non-PIC object.
1035                 if test "$non_pic_object" != none; then
1036                   # Prepend the subdirectory the object is found in.
1037                   non_pic_object="$xdir$non_pic_object"
1038
1039                   # A standard non-PIC object
1040                   non_pic_objects="$non_pic_objects $non_pic_object"
1041                   if test -z "$pic_object" || test "$pic_object" = none ; then
1042                     arg="$non_pic_object"
1043                   fi
1044                 fi
1045               else
1046                 # Only an error if not doing a dry-run.
1047                 if test -z "$run"; then
1048                   $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1049                   exit 1
1050                 else
1051                   # Dry-run case.
1052
1053                   # Extract subdirectory from the argument.
1054                   xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1055                   if test "X$xdir" = "X$arg"; then
1056                     xdir=
1057                   else
1058                     xdir="$xdir/"
1059                   fi
1060
1061                   pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1062                   non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1063                   libobjs="$libobjs $pic_object"
1064                   non_pic_objects="$non_pic_objects $non_pic_object"
1065                 fi
1066               fi
1067             done
1068           else
1069             $echo "$modename: link input file \`$save_arg' does not exist"
1070             exit 1
1071           fi
1072           arg=$save_arg
1073           prev=
1074           continue
1075           ;;
1076         rpath | xrpath)
1077           # We need an absolute path.
1078           case $arg in
1079           [\\/]* | [A-Za-z]:[\\/]*) ;;
1080           *)
1081             $echo "$modename: only absolute run-paths are allowed" 1>&2
1082             exit 1
1083             ;;
1084           esac
1085           if test "$prev" = rpath; then
1086             case "$rpath " in
1087             *" $arg "*) ;;
1088             *) rpath="$rpath $arg" ;;
1089             esac
1090           else
1091             case "$xrpath " in
1092             *" $arg "*) ;;
1093             *) xrpath="$xrpath $arg" ;;
1094             esac
1095           fi
1096           prev=
1097           continue
1098           ;;
1099         xcompiler)
1100           compiler_flags="$compiler_flags $qarg"
1101           prev=
1102           compile_command="$compile_command $qarg"
1103           finalize_command="$finalize_command $qarg"
1104           continue
1105           ;;
1106         xlinker)
1107           linker_flags="$linker_flags $qarg"
1108           compiler_flags="$compiler_flags $wl$qarg"
1109           prev=
1110           compile_command="$compile_command $wl$qarg"
1111           finalize_command="$finalize_command $wl$qarg"
1112           continue
1113           ;;
1114         *)
1115           eval "$prev=\"\$arg\""
1116           prev=
1117           continue
1118           ;;
1119         esac
1120       fi # test -n $prev
1121
1122       prevarg="$arg"
1123
1124       case $arg in
1125       -all-static)
1126         if test -n "$link_static_flag"; then
1127           compile_command="$compile_command $link_static_flag"
1128           finalize_command="$finalize_command $link_static_flag"
1129         fi
1130         continue
1131         ;;
1132
1133       -allow-undefined)
1134         # FIXME: remove this flag sometime in the future.
1135         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1136         continue
1137         ;;
1138
1139       -avoid-version)
1140         avoid_version=yes
1141         continue
1142         ;;
1143
1144       -dlopen)
1145         prev=dlfiles
1146         continue
1147         ;;
1148
1149       -dlpreopen)
1150         prev=dlprefiles
1151         continue
1152         ;;
1153
1154       -export-dynamic)
1155         export_dynamic=yes
1156         continue
1157         ;;
1158
1159       -export-symbols | -export-symbols-regex)
1160         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1161           $echo "$modename: more than one -exported-symbols argument is not allowed"
1162           exit 1
1163         fi
1164         if test "X$arg" = "X-export-symbols"; then
1165           prev=expsyms
1166         else
1167           prev=expsyms_regex
1168         fi
1169         continue
1170         ;;
1171
1172       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1173       # so, if we see these flags be careful not to treat them like -L
1174       -L[A-Z][A-Z]*:*)
1175         case $with_gcc/$host in
1176         no/*-*-irix*)
1177           compile_command="$compile_command $arg"
1178           finalize_command="$finalize_command $arg"
1179           ;;
1180         esac
1181         continue
1182         ;;
1183
1184       -L*)
1185         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1186         # We need an absolute path.
1187         case $dir in
1188         [\\/]* | [A-Za-z]:[\\/]*) ;;
1189         *)
1190           absdir=`cd "$dir" && pwd`
1191           if test -z "$absdir"; then
1192             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1193             exit 1
1194           fi
1195           dir="$absdir"
1196           ;;
1197         esac
1198         case "$deplibs " in
1199         *" -L$dir "*) ;;
1200         *)
1201           deplibs="$deplibs -L$dir"
1202           lib_search_path="$lib_search_path $dir"
1203           ;;
1204         esac
1205         case $host in
1206         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1207           case :$dllsearchpath: in
1208           *":$dir:"*) ;;
1209           *) dllsearchpath="$dllsearchpath:$dir";;
1210           esac
1211           ;;
1212         esac
1213         continue
1214         ;;
1215
1216       -l*)
1217         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1218           case $host in
1219           *-*-cygwin* | *-*-pw32* | *-*-beos*)
1220             # These systems don't actually have a C or math library (as such)
1221             continue
1222             ;;
1223           *-*-mingw* | *-*-os2*)
1224             # These systems don't actually have a C library (as such)
1225             test "X$arg" = "X-lc" && continue
1226             ;;
1227           esac
1228         fi
1229         deplibs="$deplibs $arg"
1230         continue
1231         ;;
1232
1233       -module)
1234         module=yes
1235         continue
1236         ;;
1237
1238       -no-fast-install)
1239         fast_install=no
1240         continue
1241         ;;
1242
1243       -no-install)
1244         case $host in
1245         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1246           # The PATH hackery in wrapper scripts is required on Windows
1247           # in order for the loader to find any dlls it needs.
1248           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1249           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1250           fast_install=no
1251           ;;
1252         *) no_install=yes ;;
1253         esac
1254         continue
1255         ;;
1256
1257       -no-undefined)
1258         allow_undefined=no
1259         continue
1260         ;;
1261
1262       -objectlist)
1263         prev=objectlist
1264         continue
1265         ;;
1266
1267       -o) prev=output ;;
1268
1269       -release)
1270         prev=release
1271         continue
1272         ;;
1273
1274       -rpath)
1275         prev=rpath
1276         continue
1277         ;;
1278
1279       -R)
1280         prev=xrpath
1281         continue
1282         ;;
1283
1284       -R*)
1285         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1286         # We need an absolute path.
1287         case $dir in
1288         [\\/]* | [A-Za-z]:[\\/]*) ;;
1289         *)
1290           $echo "$modename: only absolute run-paths are allowed" 1>&2
1291           exit 1
1292           ;;
1293         esac
1294         case "$xrpath " in
1295         *" $dir "*) ;;
1296         *) xrpath="$xrpath $dir" ;;
1297         esac
1298         continue
1299         ;;
1300
1301       -static)
1302         # The effects of -static are defined in a previous loop.
1303         # We used to do the same as -all-static on platforms that
1304         # didn't have a PIC flag, but the assumption that the effects
1305         # would be equivalent was wrong.  It would break on at least
1306         # Digital Unix and AIX.
1307         continue
1308         ;;
1309
1310       -thread-safe)
1311         thread_safe=yes
1312         continue
1313         ;;
1314
1315       -version-info)
1316         prev=vinfo
1317         continue
1318         ;;
1319
1320       -Wc,*)
1321         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1322         arg=
1323         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
1324         for flag in $args; do
1325           IFS="$save_ifs"
1326           case $flag in
1327             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1328             flag="\"$flag\""
1329             ;;
1330           esac
1331           arg="$arg $wl$flag"
1332           compiler_flags="$compiler_flags $flag"
1333         done
1334         IFS="$save_ifs"
1335         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1336         ;;
1337
1338       -Wl,*)
1339         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1340         arg=
1341         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
1342         for flag in $args; do
1343           IFS="$save_ifs"
1344           case $flag in
1345             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1346             flag="\"$flag\""
1347             ;;
1348           esac
1349           arg="$arg $wl$flag"
1350           compiler_flags="$compiler_flags $wl$flag"
1351           linker_flags="$linker_flags $flag"
1352         done
1353         IFS="$save_ifs"
1354         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1355         ;;
1356
1357       -Xcompiler)
1358         prev=xcompiler
1359         continue
1360         ;;
1361
1362       -Xlinker)
1363         prev=xlinker
1364         continue
1365         ;;
1366
1367       # Some other compiler flag.
1368       -* | +*)
1369         # Unknown arguments in both finalize_command and compile_command need
1370         # to be aesthetically quoted because they are evaled later.
1371         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1372         case $arg in
1373         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1374           arg="\"$arg\""
1375           ;;
1376         esac
1377         ;;
1378
1379       *.$objext)
1380         # A standard object.
1381         objs="$objs $arg"
1382         ;;
1383
1384       *.lo)
1385         # A libtool-controlled object.
1386
1387         # Check to see that this really is a libtool object.
1388         if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1389           pic_object=
1390           non_pic_object=
1391
1392           # Read the .lo file
1393           # If there is no directory component, then add one.
1394           case $arg in
1395           */* | *\\*) . $arg ;;
1396           *) . ./$arg ;;
1397           esac
1398
1399           if test -z "$pic_object" || \
1400              test -z "$non_pic_object" ||
1401              test "$pic_object" = none && \
1402              test "$non_pic_object" = none; then
1403             $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1404             exit 1
1405           fi
1406
1407           # Extract subdirectory from the argument.
1408           xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1409           if test "X$xdir" = "X$arg"; then
1410             xdir=
1411           else
1412             xdir="$xdir/"
1413           fi
1414
1415           if test "$pic_object" != none; then
1416             # Prepend the subdirectory the object is found in.
1417             pic_object="$xdir$pic_object"
1418
1419             if test "$prev" = dlfiles; then
1420               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1421                 dlfiles="$dlfiles $pic_object"
1422                 prev=
1423                 continue
1424               else
1425                 # If libtool objects are unsupported, then we need to preload.
1426                 prev=dlprefiles
1427               fi
1428             fi
1429
1430             # CHECK ME:  I think I busted this.  -Ossama
1431             if test "$prev" = dlprefiles; then
1432               # Preload the old-style object.
1433               dlprefiles="$dlprefiles $pic_object"
1434               prev=
1435             fi
1436
1437             # A PIC object.
1438             libobjs="$libobjs $pic_object"
1439             arg="$pic_object"
1440           fi
1441
1442           # Non-PIC object.
1443           if test "$non_pic_object" != none; then
1444             # Prepend the subdirectory the object is found in.
1445             non_pic_object="$xdir$non_pic_object"
1446
1447             # A standard non-PIC object
1448             non_pic_objects="$non_pic_objects $non_pic_object"
1449             if test -z "$pic_object" || test "$pic_object" = none ; then
1450               arg="$non_pic_object"
1451             fi
1452           fi
1453         else
1454           # Only an error if not doing a dry-run.
1455           if test -z "$run"; then
1456             $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1457             exit 1
1458           else
1459             # Dry-run case.
1460
1461             # Extract subdirectory from the argument.
1462             xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1463             if test "X$xdir" = "X$arg"; then
1464               xdir=
1465             else
1466               xdir="$xdir/"
1467             fi
1468
1469             pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1470             non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1471             libobjs="$libobjs $pic_object"
1472             non_pic_objects="$non_pic_objects $non_pic_object"
1473           fi
1474         fi
1475         ;;
1476
1477       *.$libext)
1478         # An archive.
1479         deplibs="$deplibs $arg"
1480         old_deplibs="$old_deplibs $arg"
1481         continue
1482         ;;
1483
1484       *.la)
1485         # A libtool-controlled library.
1486
1487         if test "$prev" = dlfiles; then
1488           # This library was specified with -dlopen.
1489           dlfiles="$dlfiles $arg"
1490           prev=
1491         elif test "$prev" = dlprefiles; then
1492           # The library was specified with -dlpreopen.
1493           dlprefiles="$dlprefiles $arg"
1494           prev=
1495         else
1496           deplibs="$deplibs $arg"
1497         fi
1498         continue
1499         ;;
1500
1501       # Some other compiler argument.
1502       *)
1503         # Unknown arguments in both finalize_command and compile_command need
1504         # to be aesthetically quoted because they are evaled later.
1505         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1506         case $arg in
1507         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1508           arg="\"$arg\""
1509           ;;
1510         esac
1511         ;;
1512       esac # arg
1513
1514       # Now actually substitute the argument into the commands.
1515       if test -n "$arg"; then
1516         compile_command="$compile_command $arg"
1517         finalize_command="$finalize_command $arg"
1518       fi
1519     done # argument parsing loop
1520
1521     if test -n "$prev"; then
1522       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1523       $echo "$help" 1>&2
1524       exit 1
1525     fi
1526
1527     # Infer tagged configuration to use if any are available and
1528     # if one wasn't chosen via the "--tag" command line option.
1529     # Only attempt this if the compiler in the base link
1530     # command doesn't match the default compiler.
1531     if test -n "$available_tags" && test -z "$tagname"; then
1532       case $base_compile in
1533       "$CC "*) ;;
1534       # Blanks in the command may have been stripped by the calling shell,
1535       # but not from the CC environment variable when ltconfig was run.
1536       "`$echo $CC` "*) ;;
1537       *)
1538         for z in $available_tags; do
1539           if grep "^### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
1540             # Evaluate the configuration.
1541             eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
1542             case $base_compile in
1543             "$CC "*)
1544               # The compiler in $compile_command matches
1545               # the one in the tagged configuration.
1546               # Assume this is the tagged configuration we want.
1547               tagname=$z
1548               break
1549               ;;
1550             "`$echo $CC` "*)
1551               tagname=$z
1552               break
1553               ;;
1554             esac
1555           fi
1556         done
1557         # If $tagname still isn't set, then no tagged configuration
1558         # was found and let the user know that the "--tag" command
1559         # line option must be used.
1560         if test -z "$tagname"; then
1561           echo "$modename: unable to infer tagged configuration"
1562           echo "$modename: specify a tag with \`--tag'" 1>&2
1563           exit 1
1564 #       else
1565 #         echo "$modename: using $tagname tagged configuration"
1566         fi
1567         ;;
1568       esac
1569     fi
1570
1571     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1572       eval arg=\"$export_dynamic_flag_spec\"
1573       compile_command="$compile_command $arg"
1574       finalize_command="$finalize_command $arg"
1575     fi
1576
1577     # calculate the name of the file, without its directory
1578     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1579     libobjs_save="$libobjs"
1580
1581     if test -n "$shlibpath_var"; then
1582       # get the directories listed in $shlibpath_var
1583       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1584     else
1585       shlib_search_path=
1586     fi
1587     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1588     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1589
1590     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1591     if test "X$output_objdir" = "X$output"; then
1592       output_objdir="$objdir"
1593     else
1594       output_objdir="$output_objdir/$objdir"
1595     fi
1596     # Create the object directory.
1597     if test ! -d $output_objdir; then
1598       $show "$mkdir $output_objdir"
1599       $run $mkdir $output_objdir
1600       status=$?
1601       if test $status -ne 0 && test ! -d $output_objdir; then
1602         exit $status
1603       fi
1604     fi
1605
1606     # Determine the type of output
1607     case $output in
1608     "")
1609       $echo "$modename: you must specify an output file" 1>&2
1610       $echo "$help" 1>&2
1611       exit 1
1612       ;;
1613     *.$libext) linkmode=oldlib ;;
1614     *.lo | *.$objext) linkmode=obj ;;
1615     *.la) linkmode=lib ;;
1616     *) linkmode=prog ;; # Anything else should be a program.
1617     esac
1618
1619     specialdeplibs=
1620     libs=
1621     # Find all interdependent deplibs by searching for libraries
1622     # that are linked more than once (e.g. -la -lb -la)
1623     for deplib in $deplibs; do
1624       case "$libs " in
1625       *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1626       esac
1627       libs="$libs $deplib"
1628     done
1629
1630     if test $linkmode = lib; then
1631       libs="$predeps $libs $compiler_lib_search_path $postdeps"
1632
1633       # Compute libraries that are listed more than once in $predeps
1634       # $postdeps and mark them as special (i.e., whose duplicates are
1635       # not to be eliminated).
1636       pre_post_deps=
1637       for pre_post_dep in $predeps $postdeps; do
1638         case "$pre_post_deps " in
1639         *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1640         esac
1641         pre_post_deps="$pre_post_deps $pre_post_dep"
1642       done
1643       pre_post_deps=
1644     fi
1645
1646     deplibs=
1647     newdependency_libs=
1648     newlib_search_path=
1649     need_relink=no # whether we're linking any uninstalled libtool libraries
1650     notinst_deplibs= # not-installed libtool libraries
1651     notinst_path= # paths that contain not-installed libtool libraries
1652     case $linkmode in
1653     lib)
1654         passes="conv link"
1655         for file in $dlfiles $dlprefiles; do
1656           case $file in
1657           *.la) ;;
1658           *)
1659             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1660             exit 1
1661             ;;
1662           esac
1663         done
1664         ;;
1665     prog)
1666         compile_deplibs=
1667         finalize_deplibs=
1668         alldeplibs=no
1669         newdlfiles=
1670         newdlprefiles=
1671         passes="conv scan dlopen dlpreopen link"
1672         ;;
1673     *)  passes="conv"
1674         ;;
1675     esac
1676     for pass in $passes; do
1677       if test $linkmode = prog; then
1678         # Determine which files to process
1679         case $pass in
1680         dlopen)
1681           libs="$dlfiles"
1682           save_deplibs="$deplibs" # Collect dlpreopened libraries
1683           deplibs=
1684           ;;
1685         dlpreopen) libs="$dlprefiles" ;;
1686         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1687         esac
1688       fi
1689       for deplib in $libs; do
1690         lib=
1691         found=no
1692         case $deplib in
1693         -l*)
1694           if test $linkmode = oldlib && test $linkmode = obj; then
1695             $echo "$modename: warning: \`-l' is ignored for archives/objects: $deplib" 1>&2
1696             continue
1697           fi
1698           if test $pass = conv; then
1699             deplibs="$deplib $deplibs"
1700             continue
1701           fi
1702           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1703           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1704             # Search the libtool library
1705             lib="$searchdir/lib${name}.la"
1706             if test -f "$lib"; then
1707               found=yes
1708               break
1709             fi
1710           done
1711           if test "$found" != yes; then
1712             # deplib doesn't seem to be a libtool library
1713             if test "$linkmode,$pass" = "prog,link"; then
1714               compile_deplibs="$deplib $compile_deplibs"
1715               finalize_deplibs="$deplib $finalize_deplibs"
1716             else
1717               deplibs="$deplib $deplibs"
1718               test $linkmode = lib && newdependency_libs="$deplib $newdependency_libs"
1719             fi
1720             continue
1721           fi
1722           ;; # -l
1723         -L*)
1724           case $linkmode in
1725           lib)
1726             deplibs="$deplib $deplibs"
1727             test $pass = conv && continue
1728             newdependency_libs="$deplib $newdependency_libs"
1729             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1730             ;;
1731           prog)
1732             if test $pass = conv; then
1733               deplibs="$deplib $deplibs"
1734               continue
1735             fi
1736             if test $pass = scan; then
1737               deplibs="$deplib $deplibs"
1738               newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1739             else
1740               compile_deplibs="$deplib $compile_deplibs"
1741               finalize_deplibs="$deplib $finalize_deplibs"
1742             fi
1743             ;;
1744           *)
1745             $echo "$modename: warning: \`-L' is ignored for archives/objects: $deplib" 1>&2
1746             ;;
1747           esac # linkmode
1748           continue
1749           ;; # -L
1750         -R*)
1751           if test $pass = link; then
1752             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1753             # Make sure the xrpath contains only unique directories.
1754             case "$xrpath " in
1755             *" $dir "*) ;;
1756             *) xrpath="$xrpath $dir" ;;
1757             esac
1758           fi
1759           deplibs="$deplib $deplibs"
1760           continue
1761           ;;
1762         *.la) lib="$deplib" ;;
1763         *.$libext)
1764           if test $pass = conv; then
1765             deplibs="$deplib $deplibs"
1766             continue
1767           fi
1768           case $linkmode in
1769           lib)
1770             if test "$deplibs_check_method" != pass_all; then
1771               echo
1772               echo "*** Warning: This library needs some functionality provided by $deplib."
1773               echo "*** I have the capability to make that library automatically link in when"
1774               echo "*** you link to this library.  But I can only do this if you have a"
1775               echo "*** shared version of the library, which you do not appear to have."
1776             else
1777               echo
1778               echo "*** Warning: Linking the shared library $output against the"
1779               echo "*** static library $deplib is not portable!"
1780               deplibs="$deplib $deplibs"
1781             fi
1782             continue
1783             ;;
1784           prog)
1785             if test $pass != link; then
1786               deplibs="$deplib $deplibs"
1787             else
1788               compile_deplibs="$deplib $compile_deplibs"
1789               finalize_deplibs="$deplib $finalize_deplibs"
1790             fi
1791             continue
1792             ;;
1793           esac # linkmode
1794           ;; # *.$libext
1795         *.lo | *.$objext)
1796           if test $pass = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1797             # If there is no dlopen support or we're linking statically,
1798             # we need to preload.
1799             newdlprefiles="$newdlprefiles $deplib"
1800             compile_deplibs="$deplib $compile_deplibs"
1801             finalize_deplibs="$deplib $finalize_deplibs"
1802           else
1803             newdlfiles="$newdlfiles $deplib"
1804           fi
1805           continue
1806           ;;
1807         %DEPLIBS%)
1808           alldeplibs=yes
1809           continue
1810           ;;
1811         esac # case $deplib
1812         if test $found = yes || test -f "$lib"; then :
1813         else
1814           $echo "$modename: cannot find the library \`$lib'" 1>&2
1815           exit 1
1816         fi
1817
1818         # Check to see that this really is a libtool archive.
1819         if (sed -e '2q' $lib | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
1820         else
1821           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
1822           exit 1
1823         fi
1824
1825         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1826         test "X$ladir" = "X$lib" && ladir="."
1827
1828         dlname=
1829         dlopen=
1830         dlpreopen=
1831         libdir=
1832         library_names=
1833         old_library=
1834         # If the library was installed with an old release of libtool,
1835         # it will not redefine variable installed.
1836         installed=yes
1837
1838         # Read the .la file
1839         case $lib in
1840         */* | *\\*) . $lib ;;
1841         *) . ./$lib ;;
1842         esac
1843
1844         if test "$linkmode,$pass" = "lib,link" ||
1845            test "$linkmode,$pass" = "prog,scan" ||
1846            { test $linkmode = oldlib && test $linkmode = obj; }; then
1847            # Add dl[pre]opened files of deplib
1848           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
1849           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
1850         fi
1851
1852         if test $pass = conv; then
1853           # Only check for convenience libraries
1854           deplibs="$lib $deplibs"
1855           if test -z "$libdir"; then
1856             if test -z "$old_library"; then
1857               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1858               exit 1
1859             fi
1860             # It is a libtool convenience library, so add in its objects.
1861             convenience="$convenience $ladir/$objdir/$old_library"
1862             old_convenience="$old_convenience $ladir/$objdir/$old_library"
1863             tmp_libs=
1864             for deplib in $dependency_libs; do
1865               deplibs="$deplib $deplibs"
1866               case "$tmp_libs " in
1867               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1868               esac
1869               tmp_libs="$tmp_libs $deplib"
1870             done
1871           elif test $linkmode != prog && test $linkmode != lib; then
1872             $echo "$modename: \`$lib' is not a convenience library" 1>&2
1873             exit 1
1874           fi
1875           continue
1876         fi # $pass = conv
1877
1878         # Get the name of the library we link against.
1879         linklib=
1880         for l in $old_library $library_names; do
1881           linklib="$l"
1882         done
1883         if test -z "$linklib"; then
1884           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1885           exit 1
1886         fi
1887
1888         # This library was specified with -dlopen.
1889         if test $pass = dlopen; then
1890           if test -z "$libdir"; then
1891             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
1892             exit 1
1893           fi
1894           if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1895             # If there is no dlname, no dlopen support or we're linking
1896             # statically, we need to preload.
1897             dlprefiles="$dlprefiles $lib"
1898           else
1899             newdlfiles="$newdlfiles $lib"
1900           fi
1901           continue
1902         fi # $pass = dlopen
1903
1904         # We need an absolute path.
1905         case $ladir in
1906         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
1907         *)
1908           abs_ladir=`cd "$ladir" && pwd`
1909           if test -z "$abs_ladir"; then
1910             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
1911             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
1912             abs_ladir="$ladir"
1913           fi
1914           ;;
1915         esac
1916         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
1917
1918         # Find the relevant object directory and library name.
1919         if test "X$installed" = Xyes; then
1920           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
1921             $echo "$modename: warning: library \`$lib' was moved." 1>&2
1922             dir="$ladir"
1923             absdir="$abs_ladir"
1924             libdir="$abs_ladir"
1925           else
1926             dir="$libdir"
1927             absdir="$libdir"
1928           fi
1929         else
1930           dir="$ladir/$objdir"
1931           absdir="$abs_ladir/$objdir"
1932           # Remove this search path later
1933           notinst_path="$notinst_path $abs_ladir"
1934         fi # $installed = yes
1935         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
1936
1937         # This library was specified with -dlpreopen.
1938         if test $pass = dlpreopen; then
1939           if test -z "$libdir"; then
1940             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
1941             exit 1
1942           fi
1943           # Prefer using a static library (so that no silly _DYNAMIC symbols
1944           # are required to link).
1945           if test -n "$old_library"; then
1946             newdlprefiles="$newdlprefiles $dir/$old_library"
1947           # Otherwise, use the dlname, so that lt_dlopen finds it.
1948           elif test -n "$dlname"; then
1949             newdlprefiles="$newdlprefiles $dir/$dlname"
1950           else
1951             newdlprefiles="$newdlprefiles $dir/$linklib"
1952           fi
1953         fi # $pass = dlpreopen
1954
1955         if test -z "$libdir"; then
1956           # Link the convenience library
1957           if test $linkmode = lib; then
1958             deplibs="$dir/$old_library $deplibs"
1959           elif test "$linkmode,$pass" = "prog,link"; then
1960             compile_deplibs="$dir/$old_library $compile_deplibs"
1961             finalize_deplibs="$dir/$old_library $finalize_deplibs"
1962           else
1963             deplibs="$lib $deplibs"
1964           fi
1965           continue
1966         fi
1967
1968         if test $linkmode = prog && test $pass != link; then
1969           newlib_search_path="$newlib_search_path $ladir"
1970           deplibs="$lib $deplibs"
1971
1972           linkalldeplibs=no
1973           if test "$link_all_deplibs" != no || test -z "$library_names" ||
1974              test "$build_libtool_libs" = no; then
1975             linkalldeplibs=yes
1976           fi
1977
1978           tmp_libs=
1979           for deplib in $dependency_libs; do
1980             case $deplib in
1981             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
1982             esac
1983             # Need to link against all dependency_libs?
1984             if test $linkalldeplibs = yes; then
1985               deplibs="$deplib $deplibs"
1986             else
1987               # Need to hardcode shared library paths
1988               # or/and link against static libraries
1989               newdependency_libs="$deplib $newdependency_libs"
1990             fi
1991             case "$tmp_libs " in
1992             *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1993             esac
1994             tmp_libs="$tmp_libs $deplib"
1995           done # for deplib
1996           continue
1997         fi # $linkmode = prog...
1998
1999         link_static=no # Whether the deplib will be linked statically
2000         if test -n "$library_names" &&
2001            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2002           # Link against this shared library
2003
2004           if test "$linkmode,$pass" = "prog,link" ||
2005            { test $linkmode = lib && test $hardcode_into_libs = yes; }; then
2006             # Hardcode the library path.
2007             # Skip directories that are in the system default run-time
2008             # search path.
2009             case " $sys_lib_dlsearch_path " in
2010             *" $absdir "*) ;;
2011             *)
2012               case "$compile_rpath " in
2013               *" $absdir "*) ;;
2014               *) compile_rpath="$compile_rpath $absdir"
2015               esac
2016               ;;
2017             esac
2018             case " $sys_lib_dlsearch_path " in
2019             *" $libdir "*) ;;
2020             *)
2021               case "$finalize_rpath " in
2022               *" $libdir "*) ;;
2023               *) finalize_rpath="$finalize_rpath $libdir"
2024               esac
2025               ;;
2026             esac
2027             if test $linkmode = prog; then
2028               # We need to hardcode the library path
2029               if test -n "$shlibpath_var"; then
2030                 # Make sure the rpath contains only unique directories.
2031                 case "$temp_rpath " in
2032                 *" $dir "*) ;;
2033                 *" $absdir "*) ;;
2034                 *) temp_rpath="$temp_rpath $dir" ;;
2035                 esac
2036               fi
2037             fi
2038           fi # $linkmode,$pass = prog,link...
2039
2040           if test "$alldeplibs" = yes &&
2041              { test "$deplibs_check_method" = pass_all ||
2042                { test "$build_libtool_libs" = yes &&
2043                  test -n "$library_names"; }; }; then
2044             # We only need to search for static libraries
2045             continue
2046           fi
2047
2048           if test "$installed" = no; then
2049             notinst_deplibs="$notinst_deplibs $lib"
2050             need_relink=yes
2051           fi
2052
2053           if test -n "$old_archive_from_expsyms_cmds"; then
2054             # figure out the soname
2055             set dummy $library_names
2056             realname="$2"
2057             shift; shift
2058             libname=`eval \\$echo \"$libname_spec\"`
2059             # use dlname if we got it. it's perfectly good, no?
2060             if test -n "$dlname"; then
2061               soname="$dlname"
2062             elif test -n "$soname_spec"; then
2063               # bleh windows
2064               case $host in
2065               *cygwin*)
2066                 major=`expr $current - $age`
2067                 versuffix="-$major"
2068                 ;;
2069               esac
2070               eval soname=\"$soname_spec\"
2071             else
2072               soname="$realname"
2073             fi
2074
2075             # Make a new name for the extract_expsyms_cmds to use
2076             soroot="$soname"
2077             soname=`echo $soroot | sed -e 's/^.*\///'`
2078             newlib="libimp-`echo $soname | sed 's/^lib//;s/\.dll$//'`.a"
2079
2080             # If the library has no export list, then create one now
2081             if test -f "$output_objdir/$soname-def"; then :
2082             else
2083               $show "extracting exported symbol list from \`$soname'"
2084               IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2085               eval cmds=\"$extract_expsyms_cmds\"
2086               for cmd in $cmds; do
2087                 IFS="$save_ifs"
2088                 $show "$cmd"
2089                 $run eval "$cmd" || exit $?
2090               done
2091               IFS="$save_ifs"
2092             fi
2093
2094             # Create $newlib
2095             if test -f "$output_objdir/$newlib"; then :; else
2096               $show "generating import library for \`$soname'"
2097               IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2098               eval cmds=\"$old_archive_from_expsyms_cmds\"
2099               for cmd in $cmds; do
2100                 IFS="$save_ifs"
2101                 $show "$cmd"
2102                 $run eval "$cmd" || exit $?
2103               done
2104               IFS="$save_ifs"
2105             fi
2106             # make sure the library variables are pointing to the new library
2107             dir=$output_objdir
2108             linklib=$newlib
2109           fi # test -n $old_archive_from_expsyms_cmds
2110
2111           if test $linkmode = prog || test "$mode" != relink; then
2112             add_shlibpath=
2113             add_dir=
2114             add=
2115             lib_linked=yes
2116             case $hardcode_action in
2117             immediate | unsupported)
2118               if test "$hardcode_direct" = no; then
2119                 add="$dir/$linklib"
2120               elif test "$hardcode_minus_L" = no; then
2121                 case $host in
2122                 *-*-sunos*) add_shlibpath="$dir" ;;
2123                 esac
2124                 add_dir="-L$dir"
2125                 add="-l$name"
2126               elif test "$hardcode_shlibpath_var" = no; then
2127                 add_shlibpath="$dir"
2128                 add="-l$name"
2129               else
2130                 lib_linked=no
2131               fi
2132               ;;
2133             relink)
2134               if test "$hardcode_direct" = yes; then
2135                 add="$dir/$linklib"
2136               elif test "$hardcode_minus_L" = yes; then
2137                 add_dir="-L$dir"
2138                 add="-l$name"
2139               elif test "$hardcode_shlibpath_var" = yes; then
2140                 add_shlibpath="$dir"
2141                 add="-l$name"
2142               else
2143                 lib_linked=no
2144               fi
2145               ;;
2146             *) lib_linked=no ;;
2147             esac
2148
2149             if test "$lib_linked" != yes; then
2150               $echo "$modename: configuration error: unsupported hardcode properties"
2151               exit 1
2152             fi
2153
2154             if test -n "$add_shlibpath"; then
2155               case :$compile_shlibpath: in
2156               *":$add_shlibpath:"*) ;;
2157               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2158               esac
2159             fi
2160             if test $linkmode = prog; then
2161               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2162               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2163             else
2164               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2165               test -n "$add" && deplibs="$add $deplibs"
2166               if test "$hardcode_direct" != yes && \
2167                  test "$hardcode_minus_L" != yes && \
2168                  test "$hardcode_shlibpath_var" = yes; then
2169                 case :$finalize_shlibpath: in
2170                 *":$libdir:"*) ;;
2171                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2172                 esac
2173               fi
2174             fi
2175           fi
2176
2177           if test $linkmode = prog || test "$mode" = relink; then
2178             add_shlibpath=
2179             add_dir=
2180             add=
2181             # Finalize command for both is simple: just hardcode it.
2182             if test "$hardcode_direct" = yes; then
2183               add="$libdir/$linklib"
2184             elif test "$hardcode_minus_L" = yes; then
2185               add_dir="-L$libdir"
2186               add="-l$name"
2187             elif test "$hardcode_shlibpath_var" = yes; then
2188               case :$finalize_shlibpath: in
2189               *":$libdir:"*) ;;
2190               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2191               esac
2192               add="-l$name"
2193             else
2194               # We cannot seem to hardcode it, guess we'll fake it.
2195               add_dir="-L$libdir"
2196               add="-l$name"
2197             fi
2198
2199             if test $linkmode = prog; then
2200               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2201               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2202             else
2203               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2204               test -n "$add" && deplibs="$add $deplibs"
2205             fi
2206           fi
2207         elif test $linkmode = prog; then
2208           if test "$alldeplibs" = yes &&
2209              { test "$deplibs_check_method" = pass_all ||
2210                { test "$build_libtool_libs" = yes &&
2211                  test -n "$library_names"; }; }; then
2212             # We only need to search for static libraries
2213             continue
2214           fi
2215
2216           # Try to link the static library
2217           # Here we assume that one of hardcode_direct or hardcode_minus_L
2218           # is not unsupported.  This is valid on all known static and
2219           # shared platforms.
2220           if test "$hardcode_direct" != unsupported; then
2221             test -n "$old_library" && linklib="$old_library"
2222             compile_deplibs="$dir/$linklib $compile_deplibs"
2223             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2224           else
2225             compile_deplibs="-l$name -L$dir $compile_deplibs"
2226             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2227           fi
2228         elif test "$build_libtool_libs" = yes; then
2229           # Not a shared library
2230           if test "$deplibs_check_method" != pass_all; then
2231             # We're trying link a shared library against a static one
2232             # but the system doesn't support it.
2233
2234             # Just print a warning and add the library to dependency_libs so
2235             # that the program can be linked against the static library.
2236             echo
2237             echo "*** Warning: This library needs some functionality provided by $lib."
2238             echo "*** I have the capability to make that library automatically link in when"
2239             echo "*** you link to this library.  But I can only do this if you have a"
2240             echo "*** shared version of the library, which you do not appear to have."
2241             if test "$module" = yes; then
2242               echo "*** Therefore, libtool will create a static module, that should work "
2243               echo "*** as long as the dlopening application is linked with the -dlopen flag."
2244               if test -z "$global_symbol_pipe"; then
2245                 echo
2246                 echo "*** However, this would only work if libtool was able to extract symbol"
2247                 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2248                 echo "*** not find such a program.  So, this module is probably useless."
2249                 echo "*** \`nm' from GNU binutils and a full rebuild may help."
2250               fi
2251               if test "$build_old_libs" = no; then
2252                 build_libtool_libs=module
2253                 build_old_libs=yes
2254               else
2255                 build_libtool_libs=no
2256               fi
2257             fi
2258           else
2259             convenience="$convenience $dir/$old_library"
2260             old_convenience="$old_convenience $dir/$old_library"
2261             deplibs="$dir/$old_library $deplibs"
2262             link_static=yes
2263           fi
2264         fi # link shared/static library?
2265
2266         if test $linkmode = lib; then
2267           if test -n "$dependency_libs" &&
2268              { test $hardcode_into_libs != yes || test $build_old_libs = yes ||
2269                test $link_static = yes; }; then
2270             # Extract -R from dependency_libs
2271             temp_deplibs=
2272             for libdir in $dependency_libs; do
2273               case $libdir in
2274               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2275                    case " $xrpath " in
2276                    *" $temp_xrpath "*) ;;
2277                    *) xrpath="$xrpath $temp_xrpath";;
2278                    esac;;
2279               *) temp_deplibs="$temp_deplibs $libdir";;
2280               esac
2281             done
2282             dependency_libs="$temp_deplibs"
2283           fi
2284
2285           newlib_search_path="$newlib_search_path $absdir"
2286           # Link against this library
2287           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2288           # ... and its dependency_libs
2289           tmp_libs=
2290           for deplib in $dependency_libs; do
2291             newdependency_libs="$deplib $newdependency_libs"
2292             case "$tmp_libs " in
2293             *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2294             esac
2295             tmp_libs="$tmp_libs $deplib"
2296           done
2297
2298           if test $link_all_deplibs != no; then
2299             # Add the search paths of all dependency libraries
2300             for deplib in $dependency_libs; do
2301               case $deplib in
2302               -L*) path="$deplib" ;;
2303               *.la)
2304                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2305                 test "X$dir" = "X$deplib" && dir="."
2306                 # We need an absolute path.
2307                 case $dir in
2308                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2309                 *)
2310                   absdir=`cd "$dir" && pwd`
2311                   if test -z "$absdir"; then
2312                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2313                     absdir="$dir"
2314                   fi
2315                   ;;
2316                 esac
2317                 if grep "^installed=no" $deplib > /dev/null; then
2318                   path="-L$absdir/$objdir"
2319                 else
2320                   eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2321                   if test -z "$libdir"; then
2322                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2323                     exit 1
2324                   fi
2325                   if test "$absdir" != "$libdir"; then
2326                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2327                   fi
2328                   path="-L$absdir"
2329                 fi
2330                 ;;
2331               *) continue ;;
2332               esac
2333               case " $deplibs " in
2334               *" $path "*) ;;
2335               *) deplibs="$path $deplibs" ;;
2336               esac
2337             done
2338           fi # link_all_deplibs != no
2339         fi # linkmode = lib
2340       done # for deplib in $libs
2341       if test $pass = dlpreopen; then
2342         # Link the dlpreopened libraries before other libraries
2343         for deplib in $save_deplibs; do
2344           deplibs="$deplib $deplibs"
2345         done
2346       fi
2347       if test $pass != dlopen; then
2348         test $pass != scan && dependency_libs="$newdependency_libs"
2349         if test $pass != conv; then
2350           # Make sure lib_search_path contains only unique directories.
2351           lib_search_path=
2352           for dir in $newlib_search_path; do
2353             case "$lib_search_path " in
2354             *" $dir "*) ;;
2355             *) lib_search_path="$lib_search_path $dir" ;;
2356             esac
2357           done
2358           newlib_search_path=
2359         fi
2360
2361         if test "$linkmode,$pass" != "prog,link"; then
2362           vars="deplibs"
2363         else
2364           vars="compile_deplibs finalize_deplibs"
2365         fi
2366         for var in $vars dependency_libs; do
2367           # Add libraries to $var in reverse order
2368           eval tmp_libs=\"\$$var\"
2369           new_libs=
2370           for deplib in $tmp_libs; do
2371             case $deplib in
2372             -L*) new_libs="$deplib $new_libs" ;;
2373             *)
2374               case " $specialdeplibs " in
2375               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2376               *)
2377                 case " $new_libs " in
2378                 *" $deplib "*) ;;
2379                 *) new_libs="$deplib $new_libs" ;;
2380                 esac
2381                 ;;
2382               esac
2383               ;;
2384             esac
2385           done
2386           tmp_libs=
2387           for deplib in $new_libs; do
2388             case $deplib in
2389             -L*)
2390               case " $tmp_libs " in
2391               *" $deplib "*) ;;
2392               *) tmp_libs="$tmp_libs $deplib" ;;
2393               esac
2394               ;;
2395             *) tmp_libs="$tmp_libs $deplib" ;;
2396             esac
2397           done
2398           eval $var=\"$tmp_libs\"
2399         done # for var
2400       fi
2401       if test "$pass" = "conv" &&
2402        { test "$linkmode" = "lib" || test "$linkmode" = "prog"; }; then
2403         libs="$deplibs" # reset libs
2404         deplibs=
2405       fi
2406     done # for pass
2407     if test $linkmode = prog; then
2408       dlfiles="$newdlfiles"
2409       dlprefiles="$newdlprefiles"
2410     fi
2411
2412     case $linkmode in
2413     oldlib)
2414       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2415         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2416       fi
2417
2418       if test -n "$rpath"; then
2419         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2420       fi
2421
2422       if test -n "$xrpath"; then
2423         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2424       fi
2425
2426       if test -n "$vinfo"; then
2427         $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
2428       fi
2429
2430       if test -n "$release"; then
2431         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2432       fi
2433
2434       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2435         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2436       fi
2437
2438       # Now set the variables for building old libraries.
2439       build_libtool_libs=no
2440       oldlibs="$output"
2441       objs="$objs$old_deplibs"
2442       ;;
2443
2444     lib)
2445       # Make sure we only generate libraries of the form `libNAME.la'.
2446       case $outputname in
2447       lib*)
2448         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2449         eval libname=\"$libname_spec\"
2450         ;;
2451       *)
2452         if test "$module" = no; then
2453           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2454           $echo "$help" 1>&2
2455           exit 1
2456         fi
2457         if test "$need_lib_prefix" != no; then
2458           # Add the "lib" prefix for modules if required
2459           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2460           eval libname=\"$libname_spec\"
2461         else
2462           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2463         fi
2464         ;;
2465       esac
2466
2467       if test -n "$objs"; then
2468         if test "$deplibs_check_method" != pass_all; then
2469           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2470           exit 1
2471         else
2472           echo
2473           echo "*** Warning: Linking the shared library $output against the non-libtool"
2474           echo "*** objects $objs is not portable!"
2475           libobjs="$libobjs $objs"
2476         fi
2477       fi
2478
2479       if test "$dlself" != no; then
2480         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2481       fi
2482
2483       set dummy $rpath
2484       if test $# -gt 2; then
2485         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2486       fi
2487       install_libdir="$2"
2488
2489       oldlibs=
2490       if test -z "$rpath"; then
2491         if test "$build_libtool_libs" = yes; then
2492           # Building a libtool convenience library.
2493           # Some compilers have problems with a `.al' extension so
2494           # convenience libraries should have the same extension an
2495           # archive normally would.
2496           oldlibs="$output_objdir/$libname.$libext $oldlibs"
2497           build_libtool_libs=convenience
2498           build_old_libs=yes
2499         fi
2500
2501         if test -n "$vinfo"; then
2502           $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
2503         fi
2504
2505         if test -n "$release"; then
2506           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2507         fi
2508       else
2509
2510         # Parse the version information argument.
2511         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
2512         set dummy $vinfo 0 0 0
2513         IFS="$save_ifs"
2514
2515         if test -n "$8"; then
2516           $echo "$modename: too many parameters to \`-version-info'" 1>&2
2517           $echo "$help" 1>&2
2518           exit 1
2519         fi
2520
2521         current="$2"
2522         revision="$3"
2523         age="$4"
2524
2525         # Check that each of the things are valid numbers.
2526         case $current in
2527         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2528         *)
2529           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2530           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2531           exit 1
2532           ;;
2533         esac
2534
2535         case $revision in
2536         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2537         *)
2538           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2539           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2540           exit 1
2541           ;;
2542         esac
2543
2544         case $age in
2545         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2546         *)
2547           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2548           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2549           exit 1
2550           ;;
2551         esac
2552
2553         if test $age -gt $current; then
2554           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2555           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2556           exit 1
2557         fi
2558
2559         # Calculate the version variables.
2560         major=
2561         versuffix=
2562         verstring=
2563         case $version_type in
2564         none) ;;
2565
2566         darwin)
2567           # Like Linux, but with the current version available in
2568           # verstring for coding it into the library header
2569           major=.`expr $current - $age`
2570           versuffix="$major.$age.$revision"
2571           # Darwin ld doesn't like 0 for these options...
2572           minor_current=`expr $current + 1`
2573           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2574           ;;
2575
2576         freebsd-aout)
2577           major=".$current"
2578           versuffix=".$current.$revision";
2579           ;;
2580
2581         freebsd-elf)
2582           major=".$current"
2583           versuffix=".$current";
2584           ;;
2585
2586         irix)
2587           major=`expr $current - $age + 1`
2588           verstring="sgi$major.$revision"
2589
2590           # Add in all the interfaces that we are compatible with.
2591           loop=$revision
2592           while test $loop != 0; do
2593             iface=`expr $revision - $loop`
2594             loop=`expr $loop - 1`
2595             verstring="sgi$major.$iface:$verstring"
2596           done
2597
2598           # Before this point, $major must not contain `.'.
2599           major=.$major
2600           versuffix="$major.$revision"
2601           ;;
2602
2603         linux)
2604           major=.`expr $current - $age`
2605           versuffix="$major.$age.$revision"
2606           ;;
2607
2608         osf)
2609           major=`expr $current - $age`
2610           versuffix=".$current.$age.$revision"
2611           verstring="$current.$age.$revision"
2612
2613           # Add in all the interfaces that we are compatible with.
2614           loop=$age
2615           while test $loop != 0; do
2616             iface=`expr $current - $loop`
2617             loop=`expr $loop - 1`
2618             verstring="$verstring:${iface}.0"
2619           done
2620
2621           # Make executables depend on our current version.
2622           verstring="$verstring:${current}.0"
2623           ;;
2624
2625         sunos)
2626           major=".$current"
2627           versuffix=".$current.$revision"
2628           ;;
2629
2630         windows)
2631           # Use '-' rather than '.', since we only want one
2632           # extension on DOS 8.3 filesystems.
2633           major=`expr $current - $age`
2634           versuffix="-$major"
2635           ;;
2636
2637         *)
2638           $echo "$modename: unknown library version type \`$version_type'" 1>&2
2639           echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
2640           exit 1
2641           ;;
2642         esac
2643
2644         # Clear the version info if we defaulted, and they specified a release.
2645         if test -z "$vinfo" && test -n "$release"; then
2646           major=
2647           verstring="0.0"
2648           if test "$need_version" = no; then
2649             versuffix=
2650           else
2651             versuffix=".0.0"
2652           fi
2653         fi
2654
2655         # Remove version info from name if versioning should be avoided
2656         if test "$avoid_version" = yes && test "$need_version" = no; then
2657           major=
2658           versuffix=
2659           verstring=""
2660         fi
2661
2662         # Check to see if the archive will have undefined symbols.
2663         if test "$allow_undefined" = yes; then
2664           if test "$allow_undefined_flag" = unsupported; then
2665             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
2666             build_libtool_libs=no
2667             build_old_libs=yes
2668           fi
2669         else
2670           # Don't allow undefined symbols.
2671           allow_undefined_flag="$no_undefined_flag"
2672         fi
2673       fi
2674
2675       if test "$mode" != relink; then
2676         # Remove our outputs, but don't remove object files since they
2677         # may have been created when compiling PIC objects.
2678         removelist=
2679         tempremovelist=`echo "$output_objdir/*"`
2680         for p in $tempremovelist; do
2681           case $p in
2682             *.$objext)
2683                ;;
2684             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
2685                removelist="$removelist $p"
2686                ;;
2687             *) ;;
2688           esac
2689         done
2690         if test -n "$removelist"; then
2691           $show "${rm}r $removelist"
2692           $run ${rm}r $removelist
2693         fi
2694       fi
2695
2696       # Now set the variables for building old libraries.
2697       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
2698         oldlibs="$oldlibs $output_objdir/$libname.$libext"
2699
2700         # Transform .lo files to .o files.
2701         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
2702       fi
2703
2704       # Eliminate all temporary directories.
2705       for path in $notinst_path; do
2706         lib_search_path=`echo "$lib_search_path " | sed -e 's% $path % %g'`
2707         deplibs=`echo "$deplibs " | sed -e 's% -L$path % %g'`
2708         dependency_libs=`echo "$dependency_libs " | sed -e 's% -L$path % %g'`
2709       done
2710
2711       if test -n "$xrpath"; then
2712         # If the user specified any rpath flags, then add them.
2713         temp_xrpath=
2714         for libdir in $xrpath; do
2715           temp_xrpath="$temp_xrpath -R$libdir"
2716           case "$finalize_rpath " in
2717           *" $libdir "*) ;;
2718           *) finalize_rpath="$finalize_rpath $libdir" ;;
2719           esac
2720         done
2721         if test $hardcode_into_libs != yes || test $build_old_libs = yes; then
2722           dependency_libs="$temp_xrpath $dependency_libs"
2723         fi
2724       fi
2725
2726       # Make sure dlfiles contains only unique files that won't be dlpreopened
2727       old_dlfiles="$dlfiles"
2728       dlfiles=
2729       for lib in $old_dlfiles; do
2730         case " $dlprefiles $dlfiles " in
2731         *" $lib "*) ;;
2732         *) dlfiles="$dlfiles $lib" ;;
2733         esac
2734       done
2735
2736       # Make sure dlprefiles contains only unique files
2737       old_dlprefiles="$dlprefiles"
2738       dlprefiles=
2739       for lib in $old_dlprefiles; do
2740         case "$dlprefiles " in
2741         *" $lib "*) ;;
2742         *) dlprefiles="$dlprefiles $lib" ;;
2743         esac
2744       done
2745
2746       if test "$build_libtool_libs" = yes; then
2747         if test -n "$rpath"; then
2748           case $host in
2749           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
2750             # these systems don't actually have a c library (as such)!
2751             ;;
2752           *-*-rhapsody* | *-*-darwin1.[012])
2753             # Rhapsody C library is in the System framework
2754             deplibs="$deplibs -framework System"
2755             ;;
2756           *-*-netbsd*)
2757             # Don't link with libc until the a.out ld.so is fixed.
2758             ;;
2759           *)
2760             # Add libc to deplibs on all other systems if necessary.
2761             if test $build_libtool_need_lc = "yes"; then
2762               deplibs="$deplibs -lc"
2763             fi
2764             ;;
2765           esac
2766         fi
2767
2768         # Transform deplibs into only deplibs that can be linked in shared.
2769         name_save=$name
2770         libname_save=$libname
2771         release_save=$release
2772         versuffix_save=$versuffix
2773         major_save=$major
2774         # I'm not sure if I'm treating the release correctly.  I think
2775         # release should show up in the -l (ie -lgmp5) so we don't want to
2776         # add it in twice.  Is that correct?
2777         release=""
2778         versuffix=""
2779         major=""
2780         newdeplibs=
2781         droppeddeps=no
2782         case $deplibs_check_method in
2783         pass_all)
2784           # Don't check for shared/static.  Everything works.
2785           # This might be a little naive.  We might want to check
2786           # whether the library exists or not.  But this is on
2787           # osf3 & osf4 and I'm not really sure... Just
2788           # implementing what was already the behaviour.
2789           newdeplibs=$deplibs
2790           ;;
2791         test_compile)
2792           # This code stresses the "libraries are programs" paradigm to its
2793           # limits. Maybe even breaks it.  We compile a program, linking it
2794           # against the deplibs as a proxy for the library.  Then we can check
2795           # whether they linked in statically or dynamically with ldd.
2796           $rm conftest.c
2797           cat > conftest.c <<EOF
2798           int main() { return 0; }
2799 EOF
2800           $rm conftest
2801           $LTCC -o conftest conftest.c $deplibs
2802           if test $? -eq 0 ; then
2803             ldd_output=`ldd conftest`
2804             for i in $deplibs; do
2805               name="`expr $i : '-l\(.*\)'`"
2806               # If $name is empty we are operating on a -L argument.
2807               if test -n "$name" && test "$name" != "0"; then
2808                 libname=`eval \\$echo \"$libname_spec\"`
2809                 deplib_matches=`eval \\$echo \"$library_names_spec\"`
2810                 set dummy $deplib_matches
2811                 deplib_match=$2
2812                 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2813                   newdeplibs="$newdeplibs $i"
2814                 else
2815                   droppeddeps=yes
2816                   echo
2817                   echo "*** Warning: This library needs some functionality provided by $i."
2818                   echo "*** I have the capability to make that library automatically link in when"
2819                   echo "*** you link to this library.  But I can only do this if you have a"
2820                   echo "*** shared version of the library, which you do not appear to have."
2821                 fi
2822               else
2823                 newdeplibs="$newdeplibs $i"
2824               fi
2825             done
2826           else
2827             # Error occured in the first compile.  Let's try to salvage the situation:
2828             # Compile a seperate program for each library.
2829             for i in $deplibs; do
2830               name="`expr $i : '-l\(.*\)'`"
2831              # If $name is empty we are operating on a -L argument.
2832               if test -n "$name" && test "$name" != "0"; then
2833                 $rm conftest
2834                 $LTCC -o conftest conftest.c $i
2835                 # Did it work?
2836                 if test $? -eq 0 ; then
2837                   ldd_output=`ldd conftest`
2838                   libname=`eval \\$echo \"$libname_spec\"`
2839                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
2840                   set dummy $deplib_matches
2841                   deplib_match=$2
2842                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2843                     newdeplibs="$newdeplibs $i"
2844                   else
2845                     droppeddeps=yes
2846                     echo
2847                     echo "*** Warning: This library needs some functionality provided by $i."
2848                     echo "*** I have the capability to make that library automatically link in when"
2849                     echo "*** you link to this library.  But I can only do this if you have a"
2850                     echo "*** shared version of the library, which you do not appear to have."
2851                   fi
2852                 else
2853                   droppeddeps=yes
2854                   echo
2855                   echo "*** Warning!  Library $i is needed by this library but I was not able to"
2856                   echo "***  make it link in!  You will probably need to install it or some"
2857                   echo "*** library that it depends on before this library will be fully"
2858                   echo "*** functional.  Installing it before continuing would be even better."
2859                 fi
2860               else
2861                 newdeplibs="$newdeplibs $i"
2862               fi
2863             done
2864           fi
2865           ;;
2866         file_magic*)
2867           set dummy $deplibs_check_method
2868           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2869           for a_deplib in $deplibs; do
2870             name="`expr $a_deplib : '-l\(.*\)'`"
2871             # If $name is empty we are operating on a -L argument.
2872             if test -n "$name" && test "$name" != "0"; then
2873               libname=`eval \\$echo \"$libname_spec\"`
2874               for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2875                     potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2876                     for potent_lib in $potential_libs; do
2877                       # Follow soft links.
2878                       if ls -lLd "$potent_lib" 2>/dev/null \
2879                          | grep " -> " >/dev/null; then
2880                         continue
2881                       fi
2882                       # The statement above tries to avoid entering an
2883                       # endless loop below, in case of cyclic links.
2884                       # We might still enter an endless loop, since a link
2885                       # loop can be closed while we follow links,
2886                       # but so what?
2887                       potlib="$potent_lib"
2888                       while test -h "$potlib" 2>/dev/null; do
2889                         potliblink=`ls -ld $potlib | sed 's/.* -> //'`
2890                         case $potliblink in
2891                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
2892                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
2893                         esac
2894                       done
2895                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
2896                          | sed 10q \
2897                          | egrep "$file_magic_regex" > /dev/null; then
2898                         newdeplibs="$newdeplibs $a_deplib"
2899                         a_deplib=""
2900                         break 2
2901                       fi
2902                     done
2903               done
2904               if test -n "$a_deplib" ; then
2905                 droppeddeps=yes
2906                 echo
2907                 echo "*** Warning: This library needs some functionality provided by $a_deplib."
2908                 echo "*** I have the capability to make that library automatically link in when"
2909                 echo "*** you link to this library.  But I can only do this if you have a"
2910                 echo "*** shared version of the library, which you do not appear to have."
2911               fi
2912             else
2913               # Add a -L argument.
2914               newdeplibs="$newdeplibs $a_deplib"
2915             fi
2916           done # Gone through all deplibs.
2917           ;;
2918         match_pattern*)
2919           set dummy $deplibs_check_method
2920           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2921           for a_deplib in $deplibs; do
2922             name="`expr $a_deplib : '-l\(.*\)'`"
2923             # If $name is empty we are operating on a -L argument.
2924             if test -n "$name" && test "$name" != "0"; then
2925               libname=`eval \\$echo \"$libname_spec\"`
2926               for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2927                 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2928                 for potent_lib in $potential_libs; do
2929                   if eval echo \"$potent_lib\" 2>/dev/null \
2930                       | sed 10q \
2931                       | egrep "$match_pattern_regex" > /dev/null; then
2932                     newdeplibs="$newdeplibs $a_deplib"
2933                     a_deplib=""
2934                     break 2
2935                   fi
2936                 done
2937               done
2938               if test -n "$a_deplib" ; then
2939                 droppeddeps=yes
2940                 echo
2941                 echo "*** Warning: This library needs some functionality provided by $a_deplib."
2942                 echo "*** I have the capability to make that library automatically link in when"
2943                 echo "*** you link to this library.  But I can only do this if you have a"
2944                 echo "*** shared version of the library, which you do not appear to have."
2945               fi
2946             else
2947               # Add a -L argument.
2948               newdeplibs="$newdeplibs $a_deplib"
2949             fi
2950           done # Gone through all deplibs.
2951           ;;
2952         none | unknown | *)
2953           newdeplibs=""
2954           if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
2955                -e 's/ -[LR][^ ]*//g' -e 's/[    ]//g' |
2956              grep . >/dev/null; then
2957             echo
2958             if test "X$deplibs_check_method" = "Xnone"; then
2959               echo "*** Warning: inter-library dependencies are not supported in this platform."
2960             else
2961               echo "*** Warning: inter-library dependencies are not known to be supported."
2962             fi
2963             echo "*** All declared inter-library dependencies are being dropped."
2964             droppeddeps=yes
2965           fi
2966           ;;
2967         esac
2968         versuffix=$versuffix_save
2969         major=$major_save
2970         release=$release_save
2971         libname=$libname_save
2972         name=$name_save
2973
2974         case $host in
2975         *-*-rhapsody* | *-*-darwin1.[012])
2976           # On Rhapsody replace the C library is the System framework
2977           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
2978           ;;
2979         esac
2980
2981         if test "$droppeddeps" = yes; then
2982           if test "$module" = yes; then
2983             echo
2984             echo "*** Warning: libtool could not satisfy all declared inter-library"
2985             echo "*** dependencies of module $libname.  Therefore, libtool will create"
2986             echo "*** a static module, that should work as long as the dlopening"
2987             echo "*** application is linked with the -dlopen flag."
2988             if test -z "$global_symbol_pipe"; then
2989               echo
2990               echo "*** However, this would only work if libtool was able to extract symbol"
2991               echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2992               echo "*** not find such a program.  So, this module is probably useless."
2993               echo "*** \`nm' from GNU binutils and a full rebuild may help."
2994             fi
2995             if test "$build_old_libs" = no; then
2996               oldlibs="$output_objdir/$libname.$libext"
2997               build_libtool_libs=module
2998               build_old_libs=yes
2999             else
3000               build_libtool_libs=no
3001             fi
3002           else
3003             echo "*** The inter-library dependencies that have been dropped here will be"
3004             echo "*** automatically added whenever a program is linked with this library"
3005             echo "*** or is declared to -dlopen it."
3006
3007             if test $allow_undefined = no; then
3008               echo
3009               echo "*** Since this library must not contain undefined symbols,"
3010               echo "*** because either the platform does not support them or"
3011               echo "*** it was explicitly requested with -no-undefined,"
3012               echo "*** libtool will only create a static version of it."
3013               if test "$build_old_libs" = no; then
3014                 oldlibs="$output_objdir/$libname.$libext"
3015                 build_libtool_libs=module
3016                 build_old_libs=yes
3017               else
3018                 build_libtool_libs=no
3019               fi
3020             fi
3021           fi
3022         fi
3023         # Done checking deplibs!
3024         deplibs=$newdeplibs
3025       fi
3026
3027       # All the library-specific variables (install_libdir is set above).
3028       library_names=
3029       old_library=
3030       dlname=
3031
3032       # Test again, we may have decided not to build it any more
3033       if test "$build_libtool_libs" = yes; then
3034         if test $hardcode_into_libs = yes; then
3035           # Hardcode the library paths
3036           hardcode_libdirs=
3037           dep_rpath=
3038           rpath="$finalize_rpath"
3039           test "$mode" != relink && rpath="$compile_rpath$rpath"
3040           for libdir in $rpath; do
3041             if test -n "$hardcode_libdir_flag_spec"; then
3042               if test -n "$hardcode_libdir_separator"; then
3043                 if test -z "$hardcode_libdirs"; then
3044                   hardcode_libdirs="$libdir"
3045                 else
3046                   # Just accumulate the unique libdirs.
3047                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3048                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3049                     ;;
3050                   *)
3051                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3052                     ;;
3053                   esac
3054                 fi
3055               else
3056                 eval flag=\"$hardcode_libdir_flag_spec\"
3057                 dep_rpath="$dep_rpath $flag"
3058               fi
3059             elif test -n "$runpath_var"; then
3060               case "$perm_rpath " in
3061               *" $libdir "*) ;;
3062               *) perm_rpath="$perm_rpath $libdir" ;;
3063               esac
3064             fi
3065           done
3066           # Substitute the hardcoded libdirs into the rpath.
3067           if test -n "$hardcode_libdir_separator" &&
3068              test -n "$hardcode_libdirs"; then
3069             libdir="$hardcode_libdirs"
3070             eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3071           fi
3072           if test -n "$runpath_var" && test -n "$perm_rpath"; then
3073             # We should set the runpath_var.
3074             rpath=
3075             for dir in $perm_rpath; do
3076               rpath="$rpath$dir:"
3077             done
3078             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3079           fi
3080           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3081         fi
3082
3083         shlibpath="$finalize_shlibpath"
3084         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3085         if test -n "$shlibpath"; then
3086           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3087         fi
3088
3089         # Get the real and link names of the library.
3090         eval library_names=\"$library_names_spec\"
3091         set dummy $library_names
3092         realname="$2"
3093         shift; shift
3094
3095         if test -n "$soname_spec"; then
3096           eval soname=\"$soname_spec\"
3097         else
3098           soname="$realname"
3099         fi
3100         test -z "$dlname" && dlname=$soname
3101
3102         lib="$output_objdir/$realname"
3103         for link
3104         do
3105           linknames="$linknames $link"
3106         done
3107
3108 #       # Ensure that we have .o objects for linkers which dislike .lo
3109 #       # (e.g. aix) in case we are running --disable-static
3110 #       for obj in $libobjs; do
3111 #         xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
3112 #         if test "X$xdir" = "X$obj"; then
3113 #           xdir="."
3114 #         else
3115 #           xdir="$xdir"
3116 #         fi
3117 #         baseobj=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
3118 #         oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
3119 #         if test ! -f $xdir/$oldobj && test "$baseobj" != "$oldobj"; then
3120 #           $show "(cd $xdir && ${LN_S} $baseobj $oldobj)"
3121 #           $run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?
3122 #         fi
3123 #       done
3124
3125         # Use standard objects if they are pic
3126         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3127
3128         # Prepare the list of exported symbols
3129         if test -z "$export_symbols"; then
3130           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3131             $show "generating symbol list for \`$libname.la'"
3132             export_symbols="$output_objdir/$libname.exp"
3133             $run $rm $export_symbols
3134             eval cmds=\"$export_symbols_cmds\"
3135             IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
3136             for cmd in $cmds; do
3137               IFS="$save_ifs"
3138               $show "$cmd"
3139               $run eval "$cmd" || exit $?
3140             done
3141             IFS="$save_ifs"
3142             if test -n "$export_symbols_regex"; then
3143               $show "egrep -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3144               $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3145               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3146               $run eval '$mv "${export_symbols}T" "$export_symbols"'
3147             fi
3148           fi
3149         fi
3150
3151         if test -n "$export_symbols" && test -n "$include_expsyms"; then
3152           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3153         fi
3154
3155         if test -n "$convenience"; then
3156           if test -n "$whole_archive_flag_spec"; then
3157             save_libobjs=$libobjs
3158             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3159           else
3160             gentop="$output_objdir/${outputname}x"
3161             $show "${rm}r $gentop"
3162             $run ${rm}r "$gentop"
3163             $show "$mkdir $gentop"
3164             $run $mkdir "$gentop"
3165             status=$?
3166             if test $status -ne 0 && test ! -d "$gentop"; then
3167               exit $status
3168             fi
3169             generated="$generated $gentop"
3170
3171             for xlib in $convenience; do
3172               # Extract the objects.
3173               case $xlib in
3174               [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3175               *) xabs=`pwd`"/$xlib" ;;
3176               esac
3177               xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3178               xdir="$gentop/$xlib"
3179
3180               $show "${rm}r $xdir"
3181               $run ${rm}r "$xdir"
3182               $show "$mkdir $xdir"
3183               $run $mkdir "$xdir"
3184               status=$?
3185               if test $status -ne 0 && test ! -d "$xdir"; then
3186                 exit $status
3187               fi
3188               $show "(cd $xdir && $AR x $xabs)"
3189               $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3190
3191               libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3192             done
3193           fi
3194         fi
3195
3196         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3197           eval flag=\"$thread_safe_flag_spec\"
3198           linker_flags="$linker_flags $flag"
3199         fi
3200
3201         # Make a backup of the uninstalled library when relinking
3202         if test "$mode" = relink; then
3203           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3204         fi
3205
3206         # Do each of the archive commands.
3207         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3208           eval cmds=\"$archive_expsym_cmds\"
3209         else
3210           eval cmds=\"$archive_cmds\"
3211         fi
3212         if len=`expr "X$cmds" : ".*"` &&
3213            test $len -le $max_cmd_len; then
3214           :
3215         else
3216           # The command line is too long to link in one step, link piecewise.
3217           $echo "creating reloadable object files..."
3218
3219           # Save the value of $output and $libobjs because we want to
3220           # use them later.  If we have whole_archive_flag_spec, we
3221           # want to use save_libobjs as it was before
3222           # whole_archive_flag_spec was expanded, because we can't
3223           # assume the linker understands whole_archive_flag_spec.
3224           # This may have to be revisited, in case too many
3225           # convenience libraries get linked in and end up exceeding
3226           # the spec.
3227           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3228             save_libobjs=$libobjs
3229           fi
3230           save_output=$output
3231
3232           # Clear the reloadable object creation command queue and
3233           # initialize k to one.
3234           test_cmds=
3235           concat_cmds=
3236           objlist=
3237           delfiles=
3238           last_robj=
3239           k=1
3240           output=$output_objdir/$save_output-${k}.$objext
3241           # Loop over the list of objects to be linked.
3242           for obj in $save_libobjs
3243           do
3244             eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3245             if test "X$objlist" = X ||
3246                { len=`expr "X$test_cmds" : ".*"` &&
3247                  test $len -le $max_cmd_len; }; then
3248               objlist="$objlist $obj"
3249             else
3250               # The command $test_cmds is almost too long, add a
3251               # command to the queue.
3252               if test $k -eq 1 ; then
3253                 # The first file doesn't have a previous command to add.
3254                 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3255               else
3256                 # All subsequent reloadable object files will link in
3257                 # the last one created.
3258                 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3259               fi
3260               last_robj=$output_objdir/$save_output-${k}.$objext
3261               k=`expr $k + 1`
3262               output=$output_objdir/$save_output-${k}.$objext
3263               objlist=$obj
3264               len=1
3265             fi
3266           done
3267           # Handle the remaining objects by creating one last
3268           # reloadable object file.  All subsequent reloadable object
3269           # files will link in the last one created.
3270           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3271           eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3272
3273           # Set up a command to remove the reloadale object files
3274           # after they are used.
3275           i=0
3276           while test $i -lt $k
3277           do
3278             i=`expr $i + 1`
3279             delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3280           done
3281
3282           $echo "creating a temporary reloadable object file: $output"
3283
3284           # Loop through the commands generated above and execute them.
3285           IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
3286           for cmd in $concat_cmds; do
3287             IFS="$save_ifs"
3288             $show "$cmd"
3289             $run eval "$cmd" || exit $?
3290           done
3291           IFS="$save_ifs"
3292
3293           libobjs=$output
3294           # Restore the value of output.
3295           output=$save_output
3296
3297           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3298             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3299           fi
3300           # Expand the library linking commands again to reset the
3301           # value of $libobjs for piecewise linking.
3302
3303           # Do each of the archive commands.
3304           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3305             eval cmds=\"$archive_expsym_cmds\"
3306           else
3307             eval cmds=\"$archive_cmds\"
3308           fi
3309
3310           # Append the command to remove the reloadable object files
3311           # to the just-reset $cmds.
3312           eval cmds=\"\$cmds~$rm $delfiles\"
3313         fi
3314         IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
3315         for cmd in $cmds; do
3316           IFS="$save_ifs"
3317           $show "$cmd"
3318           $run eval "$cmd" || exit $?
3319         done
3320         IFS="$save_ifs"
3321
3322         # Restore the uninstalled library and exit
3323         if test "$mode" = relink; then
3324           $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
3325           exit 0
3326         fi
3327
3328         # Create links to the real library.
3329         for linkname in $linknames; do
3330           if test "$realname" != "$linkname"; then
3331             $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
3332             $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
3333           fi
3334         done
3335
3336         # If -module or -export-dynamic was specified, set the dlname.
3337         if test "$module" = yes || test "$export_dynamic" = yes; then
3338           # On all known operating systems, these are identical.
3339           dlname="$soname"
3340         fi
3341       fi
3342       ;;
3343
3344     obj)
3345       if test -n "$deplibs"; then
3346         $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
3347       fi
3348
3349       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3350         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
3351       fi
3352
3353       if test -n "$rpath"; then
3354         $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
3355       fi
3356
3357       if test -n "$xrpath"; then
3358         $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
3359       fi
3360
3361       if test -n "$vinfo"; then
3362         $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
3363       fi
3364
3365       if test -n "$release"; then
3366         $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
3367       fi
3368
3369       case $output in
3370       *.lo)
3371         if test -n "$objs$old_deplibs"; then
3372           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
3373           exit 1
3374         fi
3375         libobj="$output"
3376         obj=`$echo "X$output" | $Xsed -e "$lo2o"`
3377         ;;
3378       *)
3379         libobj=
3380         obj="$output"
3381         ;;
3382       esac
3383
3384       # Delete the old objects.
3385       $run $rm $obj $libobj
3386
3387       # Objects from convenience libraries.  This assumes
3388       # single-version convenience libraries.  Whenever we create
3389       # different ones for PIC/non-PIC, this we'll have to duplicate
3390       # the extraction.
3391       reload_conv_objs=
3392       gentop=
3393       # reload_cmds runs $LD directly, so let us get rid of
3394       # -Wl from whole_archive_flag_spec
3395       wl=
3396
3397       if test -n "$convenience"; then
3398         if test -n "$whole_archive_flag_spec"; then
3399           eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
3400         else
3401           gentop="$output_objdir/${obj}x"
3402           $show "${rm}r $gentop"
3403           $run ${rm}r "$gentop"
3404           $show "$mkdir $gentop"
3405           $run $mkdir "$gentop"
3406           status=$?
3407           if test $status -ne 0 && test ! -d "$gentop"; then
3408             exit $status
3409           fi
3410           generated="$generated $gentop"
3411
3412           for xlib in $convenience; do
3413             # Extract the objects.
3414             case $xlib in
3415             [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3416             *) xabs=`pwd`"/$xlib" ;;
3417             esac
3418             xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3419             xdir="$gentop/$xlib"
3420
3421             $show "${rm}r $xdir"
3422             $run ${rm}r "$xdir"
3423             $show "$mkdir $xdir"
3424             $run $mkdir "$xdir"
3425             status=$?
3426             if test $status -ne 0 && test ! -d "$xdir"; then
3427               exit $status
3428             fi
3429             $show "(cd $xdir && $AR x $xabs)"
3430             $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3431
3432             reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3433           done
3434         fi
3435       fi
3436
3437       # Create the old-style object.
3438       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
3439
3440       output="$obj"
3441       eval cmds=\"$reload_cmds\"
3442       IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
3443       for cmd in $cmds; do
3444         IFS="$save_ifs"
3445         $show "$cmd"
3446         $run eval "$cmd" || exit $?
3447       done
3448       IFS="$save_ifs"
3449
3450       # Exit if we aren't doing a library object file.
3451       if test -z "$libobj"; then
3452         if test -n "$gentop"; then
3453           $show "${rm}r $gentop"
3454           $run ${rm}r $gentop
3455         fi
3456
3457         exit 0
3458       fi
3459
3460       if test "$build_libtool_libs" != yes; then
3461         if test -n "$gentop"; then
3462           $show "${rm}r $gentop"
3463           $run ${rm}r $gentop
3464         fi
3465
3466         # Create an invalid libtool object if no PIC, so that we don't
3467         # accidentally link it into a program.
3468         # $show "echo timestamp > $libobj"
3469         # $run eval "echo timestamp > $libobj" || exit $?
3470         exit 0
3471       fi
3472
3473       if test -n "$pic_flag" || test "$pic_mode" != default; then
3474         # Only do commands if we really have different PIC objects.
3475         reload_objs="$libobjs $reload_conv_objs"
3476         output="$libobj"
3477         eval cmds=\"$reload_cmds\"
3478         IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
3479         for cmd in $cmds; do
3480           IFS="$save_ifs"
3481           $show "$cmd"
3482           $run eval "$cmd" || exit $?
3483         done
3484         IFS="$save_ifs"
3485 #     else
3486 #       # Just create a symlink.
3487 #       $show $rm $libobj
3488 #       $run $rm $libobj
3489 #       xdir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
3490 #       if test "X$xdir" = "X$libobj"; then
3491 #         xdir="."
3492 #       else
3493 #         xdir="$xdir"
3494 #       fi
3495 #       baseobj=`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
3496 #       oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
3497 #       $show "(cd $xdir && $LN_S $oldobj $baseobj)"
3498 #       $run eval '(cd $xdir && $LN_S $oldobj $baseobj)' || exit $?
3499       fi
3500
3501       if test -n "$gentop"; then
3502         $show "${rm}r $gentop"
3503         $run ${rm}r $gentop
3504       fi
3505
3506       exit 0
3507       ;;
3508
3509     prog)
3510       case $host in
3511         *cygwin*) output=`echo $output | sed -e 's,.exe$,,;s,$,.exe,'` ;;
3512       esac
3513       if test -n "$vinfo"; then
3514         $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
3515       fi
3516
3517       if test -n "$release"; then
3518         $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
3519       fi
3520
3521       if test "$preload" = yes; then
3522         if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
3523            test "$dlopen_self_static" = unknown; then
3524           $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
3525         fi
3526       fi
3527
3528       case $host in
3529       *-*-rhapsody* | *-*-darwin1.[012])
3530         # On Rhapsody replace the C library is the System framework
3531         compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
3532         finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
3533         ;;
3534       esac
3535
3536       compile_command="$compile_command $compile_deplibs"
3537       finalize_command="$finalize_command $finalize_deplibs"
3538
3539       if test -n "$rpath$xrpath"; then
3540         # If the user specified any rpath flags, then add them.
3541         for libdir in $rpath $xrpath; do
3542           # This is the magic to use -rpath.
3543           case "$finalize_rpath " in
3544           *" $libdir "*) ;;
3545           *) finalize_rpath="$finalize_rpath $libdir" ;;
3546           esac
3547         done
3548       fi
3549
3550       # Now hardcode the library paths
3551       rpath=
3552       hardcode_libdirs=
3553       for libdir in $compile_rpath; do
3554         if test -n "$hardcode_libdir_flag_spec"; then
3555           if test -n "$hardcode_libdir_separator"; then
3556             if test -z "$hardcode_libdirs"; then
3557               hardcode_libdirs="$libdir"
3558             else
3559               # Just accumulate the unique libdirs.
3560               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3561               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3562                 ;;
3563               *)
3564                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3565                 ;;
3566               esac
3567             fi
3568           else
3569             eval flag=\"$hardcode_libdir_flag_spec\"
3570             rpath="$rpath $flag"
3571           fi
3572         elif test -n "$runpath_var"; then
3573           case "$perm_rpath " in
3574           *" $libdir "*) ;;
3575           *) perm_rpath="$perm_rpath $libdir" ;;
3576           esac
3577         fi
3578         case $host in
3579         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
3580           case :$dllsearchpath: in
3581           *":$libdir:"*) ;;
3582           *) dllsearchpath="$dllsearchpath:$libdir";;
3583           esac
3584           ;;
3585         esac
3586       done
3587       # Substitute the hardcoded libdirs into the rpath.
3588       if test -n "$hardcode_libdir_separator" &&
3589          test -n "$hardcode_libdirs"; then
3590         libdir="$hardcode_libdirs"
3591         eval rpath=\" $hardcode_libdir_flag_spec\"
3592       fi
3593       compile_rpath="$rpath"
3594
3595       rpath=
3596       hardcode_libdirs=
3597       for libdir in $finalize_rpath; do
3598         if test -n "$hardcode_libdir_flag_spec"; then
3599           if test -n "$hardcode_libdir_separator"; then
3600             if test -z "$hardcode_libdirs"; then
3601               hardcode_libdirs="$libdir"
3602             else
3603               # Just accumulate the unique libdirs.
3604               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3605               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3606                 ;;
3607               *)
3608                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3609                 ;;
3610               esac
3611             fi
3612           else
3613             eval flag=\"$hardcode_libdir_flag_spec\"
3614             rpath="$rpath $flag"
3615           fi
3616         elif test -n "$runpath_var"; then
3617           case "$finalize_perm_rpath " in
3618           *" $libdir "*) ;;
3619           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
3620           esac
3621         fi
3622       done
3623       # Substitute the hardcoded libdirs into the rpath.
3624       if test -n "$hardcode_libdir_separator" &&
3625          test -n "$hardcode_libdirs"; then
3626         libdir="$hardcode_libdirs"
3627         eval rpath=\" $hardcode_libdir_flag_spec\"
3628       fi
3629       finalize_rpath="$rpath"
3630
3631       dlsyms=
3632       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3633         if test -n "$NM" && test -n "$global_symbol_pipe"; then
3634           dlsyms="${outputname}S.c"
3635         else
3636           $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
3637         fi
3638       fi
3639
3640       if test -n "$dlsyms"; then
3641         case $dlsyms in
3642         "") ;;
3643         *.c)
3644           # Discover the nlist of each of the dlfiles.
3645           nlist="$output_objdir/${outputname}.nm"
3646
3647           $show "$rm $nlist ${nlist}S ${nlist}T"
3648           $run $rm "$nlist" "${nlist}S" "${nlist}T"
3649
3650           # Parse the name list into a source file.
3651           $show "creating $output_objdir/$dlsyms"
3652
3653           test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
3654 /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
3655 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
3656
3657 #ifdef __cplusplus
3658 extern \"C\" {
3659 #endif
3660
3661 /* Prevent the only kind of declaration conflicts we can make. */
3662 #define lt_preloaded_symbols some_other_symbol
3663
3664 /* External symbol declarations for the compiler. */\
3665 "
3666
3667           if test "$dlself" = yes; then
3668             $show "generating symbol list for \`$output'"
3669
3670             test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
3671
3672             # Add our own program objects to the symbol list.
3673             progfiles="$objs$old_deplibs"
3674             for arg in $progfiles; do
3675               $show "extracting global C symbols from \`$arg'"
3676               $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
3677             done
3678
3679             if test -n "$exclude_expsyms"; then
3680               $run eval 'egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3681               $run eval '$mv "$nlist"T "$nlist"'
3682             fi
3683
3684             if test -n "$export_symbols_regex"; then
3685               $run eval 'egrep -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3686               $run eval '$mv "$nlist"T "$nlist"'
3687             fi
3688
3689             # Prepare the list of exported symbols
3690             if test -z "$export_symbols"; then
3691               export_symbols="$output_objdir/$output.exp"
3692               $run $rm $export_symbols
3693               $run eval "sed -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3694             else
3695               $run eval "sed -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
3696               $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
3697               $run eval 'mv "$nlist"T "$nlist"'
3698             fi
3699           fi
3700
3701           for arg in $dlprefiles; do
3702             $show "extracting global C symbols from \`$arg'"
3703             name=`echo "$arg" | sed -e 's%^.*/%%'`
3704             $run eval 'echo ": $name " >> "$nlist"'
3705             $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
3706           done
3707
3708           if test -z "$run"; then
3709             # Make sure we have at least an empty file.
3710             test -f "$nlist" || : > "$nlist"
3711
3712             if test -n "$exclude_expsyms"; then
3713               egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3714               $mv "$nlist"T "$nlist"
3715             fi
3716
3717             # Try sorting and uniquifying the output.
3718             if grep -v "^: " < "$nlist" | sort +2 | uniq > "$nlist"S; then
3719               :
3720             else
3721               grep -v "^: " < "$nlist" > "$nlist"S
3722             fi
3723
3724             if test -f "$nlist"S; then
3725               eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
3726             else
3727               echo '/* NONE */' >> "$output_objdir/$dlsyms"
3728             fi
3729
3730             $echo >> "$output_objdir/$dlsyms" "\
3731
3732 #undef lt_preloaded_symbols
3733
3734 #if defined (__STDC__) && __STDC__
3735 # define lt_ptr_t void *
3736 #else
3737 # define lt_ptr_t char *
3738 # define const
3739 #endif
3740
3741 /* The mapping between symbol names and symbols. */
3742 const struct {
3743   const char *name;
3744   lt_ptr_t address;
3745 }
3746 lt_preloaded_symbols[] =
3747 {\
3748 "
3749
3750             sed -n -e 's/^: \([^ ]*\) $/  {\"\1\", (lt_ptr_t) 0},/p' \
3751                 -e 's/^. \([^ ]*\) \([^ ]*\)$/  {"\2", (lt_ptr_t) \&\2},/p' \
3752                   < "$nlist" >> "$output_objdir/$dlsyms"
3753
3754             $echo >> "$output_objdir/$dlsyms" "\
3755   {0, (lt_ptr_t) 0}
3756 };
3757
3758 /* This works around a problem in FreeBSD linker */
3759 #ifdef FREEBSD_WORKAROUND
3760 static const void *lt_preloaded_setup() {
3761   return lt_preloaded_symbols;
3762 }
3763 #endif
3764
3765 #ifdef __cplusplus
3766 }
3767 #endif\
3768 "
3769           fi
3770
3771           pic_flag_for_symtable=
3772           case $host in
3773           # compiling the symbol table file with pic_flag works around
3774           # a FreeBSD bug that causes programs to crash when -lm is
3775           # linked before any other PIC object.  But we must not use
3776           # pic_flag when linking with -static.  The problem exists in
3777           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3778           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3779             case "$compile_command " in
3780             *" -static "*) ;;
3781             *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
3782             esac;;
3783           *-*-hpux*)
3784             case "$compile_command " in
3785             *" -static "*) ;;
3786             *) pic_flag_for_symtable=" $pic_flag";;
3787             esac
3788           esac
3789
3790           # Now compile the dynamic symbol file.
3791           $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
3792           $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
3793
3794           # Clean up the generated files.
3795           $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
3796           $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
3797
3798           # Transform the symbol file into the correct name.
3799           compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
3800           finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
3801           ;;
3802         *)
3803           $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
3804           exit 1
3805           ;;
3806         esac
3807       else
3808         # We keep going just in case the user didn't refer to
3809         # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3810         # really was required.
3811
3812         # Nullify the symbol file.
3813         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
3814         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
3815       fi
3816
3817       if test $need_relink = no || test "$build_libtool_libs" != yes; then
3818         # Replace the output file specification.
3819         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
3820         link_command="$compile_command$compile_rpath"
3821
3822         # We have no uninstalled library dependencies, so finalize right now.
3823         $show "$link_command"
3824         $run eval "$link_command"
3825         status=$?
3826
3827         # Delete the generated files.
3828         if test -n "$dlsyms"; then
3829           $show "$rm $output_objdir/${outputname}S.${objext}"
3830           $run $rm "$output_objdir/${outputname}S.${objext}"
3831         fi
3832
3833         exit $status
3834       fi
3835
3836       if test -n "$shlibpath_var"; then
3837         # We should set the shlibpath_var
3838         rpath=
3839         for dir in $temp_rpath; do
3840           case $dir in
3841           [\\/]* | [A-Za-z]:[\\/]*)
3842             # Absolute path.
3843             rpath="$rpath$dir:"
3844             ;;
3845           *)
3846             # Relative path: add a thisdir entry.
3847             rpath="$rpath\$thisdir/$dir:"
3848             ;;
3849           esac
3850         done
3851         temp_rpath="$rpath"
3852       fi
3853
3854       if test -n "$compile_shlibpath$finalize_shlibpath"; then
3855         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
3856       fi
3857       if test -n "$finalize_shlibpath"; then
3858         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
3859       fi
3860
3861       compile_var=
3862       finalize_var=
3863       if test -n "$runpath_var"; then
3864         if test -n "$perm_rpath"; then
3865           # We should set the runpath_var.
3866           rpath=
3867           for dir in $perm_rpath; do
3868             rpath="$rpath$dir:"
3869           done
3870           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
3871         fi
3872         if test -n "$finalize_perm_rpath"; then
3873           # We should set the runpath_var.
3874           rpath=
3875           for dir in $finalize_perm_rpath; do
3876             rpath="$rpath$dir:"
3877           done
3878           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
3879         fi
3880       fi
3881
3882       if test "$no_install" = yes; then
3883         # We don't need to create a wrapper script.
3884         link_command="$compile_var$compile_command$compile_rpath"
3885         # Replace the output file specification.
3886         link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
3887         # Delete the old output file.
3888         $run $rm $output
3889         # Link the executable and exit
3890         $show "$link_command"
3891         $run eval "$link_command" || exit $?
3892         exit 0
3893       fi
3894
3895       if test "$hardcode_action" = relink; then
3896         # Fast installation is not supported
3897         link_command="$compile_var$compile_command$compile_rpath"
3898         relink_command="$finalize_var$finalize_command$finalize_rpath"
3899
3900         $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
3901         $echo "$modename: \`$output' will be relinked during installation" 1>&2
3902       else
3903         if test "$fast_install" != no; then
3904           link_command="$finalize_var$compile_command$finalize_rpath"
3905           if test "$fast_install" = yes; then
3906             relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
3907           else
3908             # fast_install is set to needless
3909             relink_command=
3910           fi
3911         else
3912           link_command="$compile_var$compile_command$compile_rpath"
3913           relink_command="$finalize_var$finalize_command$finalize_rpath"
3914         fi
3915       fi
3916
3917       # Replace the output file specification.
3918       link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
3919
3920       # Delete the old output files.
3921       $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
3922
3923       $show "$link_command"
3924       $run eval "$link_command" || exit $?
3925
3926       # Now create the wrapper script.
3927       $show "creating $output"
3928
3929       # Quote the relink command for shipping.
3930       if test -n "$relink_command"; then
3931         # Preserve any variables that may affect compiler behavior
3932         for var in $variables_saved_for_relink; do
3933           if eval test -z \"\${$var+set}\"; then
3934             relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
3935           elif eval var_value=\$$var; test -z "$var_value"; then
3936             relink_command="$var=; export $var; $relink_command"
3937           else
3938             var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
3939             relink_command="$var=\"$var_value\"; export $var; $relink_command"
3940           fi
3941         done
3942         relink_command="cd `pwd`; $relink_command"
3943         relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
3944       fi
3945
3946       # Quote $echo for shipping.
3947       if test "X$echo" = "X$SHELL $0 --fallback-echo"; then
3948         case $0 in
3949         [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $0 --fallback-echo";;
3950         *) qecho="$SHELL `pwd`/$0 --fallback-echo";;
3951         esac
3952         qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
3953       else
3954         qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
3955       fi
3956
3957       # Only actually do things if our run command is non-null.
3958       if test -z "$run"; then
3959         # win32 will think the script is a binary if it has
3960         # a .exe suffix, so we strip it off here.
3961         case $output in
3962           *.exe) output=`echo $output|sed 's,.exe$,,'` ;;
3963         esac
3964         # test for cygwin because mv fails w/o .exe extensions
3965         case $host in
3966           *cygwin*) exeext=.exe ;;
3967           *) exeext= ;;
3968         esac
3969         $rm $output
3970         trap "$rm $output; exit 1" 1 2 15
3971
3972         $echo > $output "\
3973 #! $SHELL
3974
3975 # $output - temporary wrapper script for $objdir/$outputname
3976 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
3977 #
3978 # The $output program cannot be directly executed until all the libtool
3979 # libraries that it depends on are installed.
3980 #
3981 # This wrapper script should never be moved out of the build directory.
3982 # If it is, it will not operate correctly.
3983
3984 # Sed substitution that helps us do robust quoting.  It backslashifies
3985 # metacharacters that are still active within double-quoted strings.
3986 Xsed='sed -e 1s/^X//'
3987 sed_quote_subst='$sed_quote_subst'
3988
3989 # The HP-UX ksh and POSIX shell print the target directory to stdout
3990 # if CDPATH is set.
3991 if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
3992
3993 relink_command=\"$relink_command\"
3994
3995 # This environment variable determines our operation mode.
3996 if test \"\$libtool_install_magic\" = \"$magic\"; then
3997   # install mode needs the following variable:
3998   notinst_deplibs='$notinst_deplibs'
3999 else
4000   # When we are sourced in execute mode, \$file and \$echo are already set.
4001   if test \"\$libtool_execute_magic\" != \"$magic\"; then
4002     echo=\"$qecho\"
4003     file=\"\$0\"
4004     # Make sure echo works.
4005     if test \"X\$1\" = X--no-reexec; then
4006       # Discard the --no-reexec flag, and continue.
4007       shift
4008     elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
4009       # Yippee, \$echo works!
4010       :
4011     else
4012       # Restart under the correct shell, and then maybe \$echo will work.
4013       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
4014     fi
4015   fi\
4016 "
4017         $echo >> $output "\
4018
4019   # Find the directory that this script lives in.
4020   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
4021   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4022
4023   # Follow symbolic links until we get to the real thisdir.
4024   file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\`
4025   while test -n \"\$file\"; do
4026     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
4027
4028     # If there was a directory component, then change thisdir.
4029     if test \"x\$destdir\" != \"x\$file\"; then
4030       case \"\$destdir\" in
4031       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4032       *) thisdir=\"\$thisdir/\$destdir\" ;;
4033       esac
4034     fi
4035
4036     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
4037     file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\`
4038   done
4039
4040   # Try to get the absolute directory name.
4041   absdir=\`cd \"\$thisdir\" && pwd\`
4042   test -n \"\$absdir\" && thisdir=\"\$absdir\"
4043 "
4044
4045         if test "$fast_install" = yes; then
4046           echo >> $output "\
4047   program=lt-'$outputname'$exeext
4048   progdir=\"\$thisdir/$objdir\"
4049
4050   if test ! -f \"\$progdir/\$program\" || \\
4051      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | sed 1q\`; \\
4052        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4053
4054     file=\"\$\$-\$program\"
4055
4056     if test ! -d \"\$progdir\"; then
4057       $mkdir \"\$progdir\"
4058     else
4059       $rm \"\$progdir/\$file\"
4060     fi"
4061
4062           echo >> $output "\
4063
4064     # relink executable if necessary
4065     if test -n \"\$relink_command\"; then
4066       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4067       else
4068         $echo \"\$relink_command_output\" >&2
4069         $rm \"\$progdir/\$file\"
4070         exit 1
4071       fi
4072     fi
4073
4074     $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4075     { $rm \"\$progdir/\$program\";
4076       $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4077     $rm \"\$progdir/\$file\"
4078   fi"
4079         else
4080           echo >> $output "\
4081   program='$outputname'
4082   progdir=\"\$thisdir/$objdir\"
4083 "
4084         fi
4085
4086         echo >> $output "\
4087
4088   if test -f \"\$progdir/\$program\"; then"
4089
4090         # Export our shlibpath_var if we have one.
4091         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4092           $echo >> $output "\
4093     # Add our own library path to $shlibpath_var
4094     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4095
4096     # Some systems cannot cope with colon-terminated $shlibpath_var
4097     # The second colon is a workaround for a bug in BeOS R4 sed
4098     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
4099
4100     export $shlibpath_var
4101 "
4102         fi
4103
4104         # fixup the dll searchpath if we need to.
4105         if test -n "$dllsearchpath"; then
4106           $echo >> $output "\
4107     # Add the dll search path components to the executable PATH
4108     PATH=$dllsearchpath:\$PATH
4109 "
4110         fi
4111
4112         $echo >> $output "\
4113     if test \"\$libtool_execute_magic\" != \"$magic\"; then
4114       # Run the actual program with our arguments.
4115 "
4116         case $host in
4117         # win32 systems need to use the prog path for dll
4118         # lookup to work
4119         *-*-cygwin* | *-*-pw32*)
4120           $echo >> $output "\
4121       exec \$progdir/\$program \${1+\"\$@\"}
4122 "
4123           ;;
4124
4125         # Backslashes separate directories on plain windows
4126         *-*-mingw | *-*-os2*)
4127           $echo >> $output "\
4128       exec \$progdir\\\\\$program \${1+\"\$@\"}
4129 "
4130           ;;
4131
4132         *)
4133           $echo >> $output "\
4134       # Export the path to the program.
4135       PATH=\"\$progdir:\$PATH\"
4136       export PATH
4137
4138       exec \$program \${1+\"\$@\"}
4139 "
4140           ;;
4141         esac
4142         $echo >> $output "\
4143       \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
4144       exit 1
4145     fi
4146   else
4147     # The program doesn't exist.
4148     \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
4149     \$echo \"This script is just a wrapper for \$program.\" 1>&2
4150     echo \"See the $PACKAGE documentation for more information.\" 1>&2
4151     exit 1
4152   fi
4153 fi\
4154 "
4155         chmod +x $output
4156       fi
4157       exit 0
4158       ;;
4159     esac
4160
4161     # See if we need to build an old-fashioned archive.
4162     for oldlib in $oldlibs; do
4163
4164       if test "$build_libtool_libs" = convenience; then
4165         oldobjs="$libobjs_save"
4166         addlibs="$convenience"
4167         build_libtool_libs=no
4168       else
4169         if test "$build_libtool_libs" = module; then
4170           oldobjs="$libobjs_save"
4171           build_libtool_libs=no
4172         else
4173           oldobjs="$objs$old_deplibs $non_pic_objects"
4174         fi
4175         addlibs="$old_convenience"
4176       fi
4177
4178       if test -n "$addlibs"; then
4179         gentop="$output_objdir/${outputname}x"
4180         $show "${rm}r $gentop"
4181         $run ${rm}r "$gentop"
4182         $show "$mkdir $gentop"
4183         $run $mkdir "$gentop"
4184         status=$?
4185         if test $status -ne 0 && test ! -d "$gentop"; then
4186           exit $status
4187         fi
4188         generated="$generated $gentop"
4189
4190         # Add in members from convenience archives.
4191         for xlib in $addlibs; do
4192           # Extract the objects.
4193           case $xlib in
4194           [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
4195           *) xabs=`pwd`"/$xlib" ;;
4196           esac
4197           xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
4198           xdir="$gentop/$xlib"
4199
4200           $show "${rm}r $xdir"
4201           $run ${rm}r "$xdir"
4202           $show "$mkdir $xdir"
4203           $run $mkdir "$xdir"
4204           status=$?
4205           if test $status -ne 0 && test ! -d "$xdir"; then
4206             exit $status
4207           fi
4208           $show "(cd $xdir && $AR x $xabs)"
4209           $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
4210
4211           oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print | $NL2SP`
4212         done
4213       fi
4214
4215       # Do each command in the archive commands.
4216       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
4217         eval cmds=\"$old_archive_from_new_cmds\"
4218       else
4219 #       # Ensure that we have .o objects in place in case we decided
4220 #       # not to build a shared library, and have fallen back to building
4221 #       # static libs even though --disable-static was passed!
4222 #       for oldobj in $oldobjs; do
4223 #         if test ! -f $oldobj; then
4224 #           xdir=`$echo "X$oldobj" | $Xsed -e 's%/[^/]*$%%'`
4225 #           if test "X$xdir" = "X$oldobj"; then
4226 #             xdir="."
4227 #           else
4228 #             xdir="$xdir"
4229 #           fi
4230 #           baseobj=`$echo "X$oldobj" | $Xsed -e 's%^.*/%%'`
4231 #           obj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`
4232 #           $show "(cd $xdir && ${LN_S} $obj $baseobj)"
4233 #           $run eval '(cd $xdir && ${LN_S} $obj $baseobj)' || exit $?
4234 #         fi
4235 #       done
4236
4237         # POSIX demands no paths to be encoded in archives.  We have
4238         # to avoid creating archives with duplicate basenames if we
4239         # might have to extract them afterwards, e.g., when creating a
4240         # static archive out of a convenience library, or when linking
4241         # the entirety of a libtool archive into another (currently
4242         # not supported by libtool).
4243         if (for obj in $oldobjs
4244             do
4245               $echo "X$obj" | $Xsed -e 's%^.*/%%'
4246             done | sort | sort -uc >/dev/null 2>&1); then
4247           :
4248         else
4249           $echo "copying selected object files to avoid basename conflicts..."
4250
4251           if test -z "$gentop"; then
4252             gentop="$output_objdir/${outputname}x"
4253
4254             $show "${rm}r $gentop"
4255             $run ${rm}r "$gentop"
4256             $show "$mkdir $gentop"
4257             $run $mkdir "$gentop"
4258             status=$?
4259             if test $status -ne 0 && test ! -d "$gentop"; then
4260               exit $status
4261             fi
4262             generated="$generated $gentop"
4263           fi
4264
4265           save_oldobjs=$oldobjs
4266           oldobjs=
4267           counter=1
4268           for obj in $save_oldobjs
4269           do
4270             objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
4271             case " $oldobjs " in
4272             " ") oldobjs=$obj ;;
4273             *[\ /]"$objbase "*)
4274               while :; do
4275                 # Make sure we don't pick an alternate name that also
4276                 # overlaps.
4277                 newobj=lt$counter-$objbase
4278                 counter=`expr $counter + 1`
4279                 case " $oldobjs " in
4280                 *[\ /]"$newobj "*) ;;
4281                 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
4282                 esac
4283               done
4284               $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
4285               $run ln "$obj" "$gentop/$newobj" ||
4286               $run cp "$obj" "$gentop/$newobj"
4287               oldobjs="$oldobjs $gentop/$newobj"
4288               ;;
4289             *) oldobjs="$oldobjs $obj" ;;
4290             esac
4291           done
4292         fi
4293
4294         eval cmds=\"$old_archive_cmds\"
4295
4296         if len=`expr "X$cmds" : ".*"` &&
4297              test $len -le $max_cmd_len; then
4298           :
4299         else
4300           # the command line is too long to link in one step, link in parts
4301           $echo "using piecewise archive linking..."
4302           save_RANLIB=$RANLIB
4303           RANLIB=:
4304           objlist=
4305           concat_cmds=
4306           save_oldobjs=$oldobjs
4307
4308           for obj in $save_oldobjs
4309           do
4310             oldobjs="$objlist $obj"
4311             objlist="$objlist $obj"
4312             eval test_cmds=\"$old_archive_cmds\"
4313             if len=`expr "X$test_cmds" : ".*"` &&
4314                test $len -le $max_cmd_len; then
4315               :
4316             else
4317               # the above command should be used before it gets too long
4318               oldobjs=$objlist
4319               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
4320               eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
4321               objlist=
4322             fi
4323           done
4324           RANLIB=$save_RANLIB
4325           oldobjs=$objlist
4326           eval cmds=\"\$concat_cmds~$old_archive_cmds\"
4327         fi
4328       fi
4329       IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
4330       for cmd in $cmds; do
4331         IFS="$save_ifs"
4332         $show "$cmd"
4333         $run eval "$cmd" || exit $?
4334       done
4335       IFS="$save_ifs"
4336     done
4337
4338     if test -n "$generated"; then
4339       $show "${rm}r$generated"
4340       $run ${rm}r$generated
4341     fi
4342
4343     # Now create the libtool archive.
4344     case $output in
4345     *.la)
4346       old_library=
4347       test "$build_old_libs" = yes && old_library="$libname.$libext"
4348       $show "creating $output"
4349
4350       # Preserve any variables that may affect compiler behavior
4351       for var in $variables_saved_for_relink; do
4352         if eval test -z \"\${$var+set}\"; then
4353           relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
4354         elif eval var_value=\$$var; test -z "$var_value"; then
4355           relink_command="$var=; export $var; $relink_command"
4356         else
4357           var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4358           relink_command="$var=\"$var_value\"; export $var; $relink_command"
4359         fi
4360       done
4361       # Quote the link command for shipping.
4362       tagopts=
4363       for tag in $taglist; do
4364         tagopts="$tagopts --tag $tag"
4365       done
4366       relink_command="(cd `pwd`; $SHELL $0$tagopts --mode=relink $libtool_args)"
4367       relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4368
4369       # Only create the output if not a dry run.
4370       if test -z "$run"; then
4371         for installed in no yes; do
4372           if test "$installed" = yes; then
4373             if test -z "$install_libdir"; then
4374               break
4375             fi
4376             output="$output_objdir/$outputname"i
4377             # Replace all uninstalled libtool libraries with the installed ones
4378             newdependency_libs=
4379             for deplib in $dependency_libs; do
4380               case $deplib in
4381               *.la)
4382                 name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
4383                 eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
4384                 if test -z "$libdir"; then
4385                   $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
4386                   exit 1
4387                 fi
4388                 newdependency_libs="$newdependency_libs $libdir/$name"
4389                 ;;
4390               *) newdependency_libs="$newdependency_libs $deplib" ;;
4391               esac
4392             done
4393             dependency_libs="$newdependency_libs"
4394             newdlfiles=
4395             for lib in $dlfiles; do
4396               name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
4397               eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
4398               if test -z "$libdir"; then
4399                 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
4400                 exit 1
4401               fi
4402               newdlfiles="$newdlfiles $libdir/$name"
4403             done
4404             dlfiles="$newdlfiles"
4405             newdlprefiles=
4406             for lib in $dlprefiles; do
4407               name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
4408               eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
4409               if test -z "$libdir"; then
4410                 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
4411                 exit 1
4412               fi
4413               newdlprefiles="$newdlprefiles $libdir/$name"
4414             done
4415             dlprefiles="$newdlprefiles"
4416           fi
4417           $rm $output
4418           # place dlname in correct position for cygwin
4419           tdlname=$dlname
4420           case $host,$output,$installed,$module,$dlname in
4421             *cygwin*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
4422           esac
4423           $echo > $output "\
4424 # $outputname - a libtool library file
4425 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4426 #
4427 # Please DO NOT delete this file!
4428 # It is necessary for linking the library.
4429
4430 # The name that we can dlopen(3).
4431 dlname='$tdlname'
4432
4433 # Names of this library.
4434 library_names='$library_names'
4435
4436 # The name of the static archive.
4437 old_library='$old_library'
4438
4439 # Libraries that this one depends upon.
4440 dependency_libs='$dependency_libs'
4441
4442 # Version information for $libname.
4443 current=$current
4444 age=$age
4445 revision=$revision
4446
4447 # Is this an already installed library?
4448 installed=$installed
4449
4450 # Files to dlopen/dlpreopen
4451 dlopen='$dlfiles'
4452 dlpreopen='$dlprefiles'
4453
4454 # Directory that this library needs to be installed in:
4455 libdir='$install_libdir'"
4456           if test "$installed" = no && test $need_relink = yes; then
4457             $echo >> $output "\
4458 relink_command=\"$relink_command\""
4459           fi
4460         done
4461       fi
4462
4463       # Do a symbolic link so that the libtool archive can be found in
4464       # LD_LIBRARY_PATH before the program is installed.
4465       $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
4466       $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
4467       ;;
4468     esac
4469     exit 0
4470     ;;
4471
4472   # libtool install mode
4473   install)
4474     modename="$modename: install"
4475
4476     # There may be an optional sh(1) argument at the beginning of
4477     # install_prog (especially on Windows NT).
4478     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
4479        # Allow the use of GNU shtool's install command.
4480        $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
4481       # Aesthetically quote it.
4482       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
4483       case $arg in
4484       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
4485         arg="\"$arg\""
4486         ;;
4487       esac
4488       install_prog="$arg "
4489       arg="$1"
4490       shift
4491     else
4492       install_prog=
4493       arg="$nonopt"
4494     fi
4495
4496     # The real first argument should be the name of the installation program.
4497     # Aesthetically quote it.
4498     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
4499     case $arg in
4500     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
4501       arg="\"$arg\""
4502       ;;
4503     esac
4504     install_prog="$install_prog$arg"
4505
4506     # We need to accept at least all the BSD install flags.
4507     dest=
4508     files=
4509     opts=
4510     prev=
4511     install_type=
4512     isdir=no
4513     stripme=
4514     for arg
4515     do
4516       if test -n "$dest"; then
4517         files="$files $dest"
4518         dest="$arg"
4519         continue
4520       fi
4521
4522       case $arg in
4523       -d) isdir=yes ;;
4524       -f) prev="-f" ;;
4525       -g) prev="-g" ;;
4526       -m) prev="-m" ;;
4527       -o) prev="-o" ;;
4528       -s)
4529         stripme=" -s"
4530         continue
4531         ;;
4532       -*) ;;
4533
4534       *)
4535         # If the previous option needed an argument, then skip it.
4536         if test -n "$prev"; then
4537           prev=
4538         else
4539           dest="$arg"
4540           continue
4541         fi
4542         ;;
4543       esac
4544
4545       # Aesthetically quote the argument.
4546       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
4547       case $arg in
4548       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
4549         arg="\"$arg\""
4550         ;;
4551       esac
4552       install_prog="$install_prog $arg"
4553     done
4554
4555     if test -z "$install_prog"; then
4556       $echo "$modename: you must specify an install program" 1>&2
4557       $echo "$help" 1>&2
4558       exit 1
4559     fi
4560
4561     if test -n "$prev"; then
4562       $echo "$modename: the \`$prev' option requires an argument" 1>&2
4563       $echo "$help" 1>&2
4564       exit 1
4565     fi
4566
4567     if test -z "$files"; then
4568       if test -z "$dest"; then
4569         $echo "$modename: no file or destination specified" 1>&2
4570       else
4571         $echo "$modename: you must specify a destination" 1>&2
4572       fi
4573       $echo "$help" 1>&2
4574       exit 1
4575     fi
4576
4577     # Strip any trailing slash from the destination.
4578     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
4579
4580     # Check to see that the destination is a directory.
4581     test -d "$dest" && isdir=yes
4582     if test "$isdir" = yes; then
4583       destdir="$dest"
4584       destname=
4585     else
4586       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
4587       test "X$destdir" = "X$dest" && destdir=.
4588       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
4589
4590       # Not a directory, so check to see that there is only one file specified.
4591       set dummy $files
4592       if test $# -gt 2; then
4593         $echo "$modename: \`$dest' is not a directory" 1>&2
4594         $echo "$help" 1>&2
4595         exit 1
4596       fi
4597     fi
4598     case $destdir in
4599     [\\/]* | [A-Za-z]:[\\/]*) ;;
4600     *)
4601       for file in $files; do
4602         case $file in
4603         *.lo) ;;
4604         *)
4605           $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
4606           $echo "$help" 1>&2
4607           exit 1
4608           ;;
4609         esac
4610       done
4611       ;;
4612     esac
4613
4614     # This variable tells wrapper scripts just to set variables rather
4615     # than running their programs.
4616     libtool_install_magic="$magic"
4617
4618     staticlibs=
4619     future_libdirs=
4620     current_libdirs=
4621     for file in $files; do
4622
4623       # Do each installation.
4624       case $file in
4625       *.$libext)
4626         # Do the static libraries later.
4627         staticlibs="$staticlibs $file"
4628         ;;
4629
4630       *.la)
4631         # Check to see that this really is a libtool archive.
4632         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
4633         else
4634           $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
4635           $echo "$help" 1>&2
4636           exit 1
4637         fi
4638
4639         library_names=
4640         old_library=
4641         relink_command=
4642         # If there is no directory component, then add one.
4643         case $file in
4644         */* | *\\*) . $file ;;
4645         *) . ./$file ;;
4646         esac
4647
4648         # Add the libdir to current_libdirs if it is the destination.
4649         if test "X$destdir" = "X$libdir"; then
4650           case "$current_libdirs " in
4651           *" $libdir "*) ;;
4652           *) current_libdirs="$current_libdirs $libdir" ;;
4653           esac
4654         else
4655           # Note the libdir as a future libdir.
4656           case "$future_libdirs " in
4657           *" $libdir "*) ;;
4658           *) future_libdirs="$future_libdirs $libdir" ;;
4659           esac
4660         fi
4661
4662         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
4663         test "X$dir" = "X$file/" && dir=
4664         dir="$dir$objdir"
4665
4666         if test -n "$relink_command"; then
4667           $echo "$modename: warning: relinking \`$file'" 1>&2
4668           $show "$relink_command"
4669           if $run eval "$relink_command"; then :
4670           else
4671             $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
4672             exit 1
4673           fi
4674         fi
4675
4676         # See the names of the shared library.
4677         set dummy $library_names
4678         if test -n "$2"; then
4679           realname="$2"
4680           shift
4681           shift
4682
4683           srcname="$realname"
4684           test -n "$relink_command" && srcname="$realname"T
4685
4686           # Install the shared library and build the symlinks.
4687           $show "$install_prog $dir/$srcname $destdir/$realname"
4688           $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
4689           if test -n "$stripme" && test -n "$striplib"; then
4690             $show "$striplib $destdir/$realname"
4691             $run eval "$striplib $destdir/$realname" || exit $?
4692           fi
4693
4694           if test $# -gt 0; then
4695             # Delete the old symlinks, and create new ones.
4696             for linkname
4697             do
4698               if test "$linkname" != "$realname"; then
4699                 $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
4700                 $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
4701               fi
4702             done
4703           fi
4704
4705           # Do each command in the postinstall commands.
4706           lib="$destdir/$realname"
4707           eval cmds=\"$postinstall_cmds\"
4708           IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
4709           for cmd in $cmds; do
4710             IFS="$save_ifs"
4711             $show "$cmd"
4712             $run eval "$cmd" || exit $?
4713           done
4714           IFS="$save_ifs"
4715         fi
4716
4717         # Install the pseudo-library for information purposes.
4718         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4719         instname="$dir/$name"i
4720         $show "$install_prog $instname $destdir/$name"
4721         $run eval "$install_prog $instname $destdir/$name" || exit $?
4722
4723         # Maybe install the static library, too.
4724         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
4725         ;;
4726
4727       *.lo)
4728         # Install (i.e. copy) a libtool object.
4729
4730         # Figure out destination file name, if it wasn't already specified.
4731         if test -n "$destname"; then
4732           destfile="$destdir/$destname"
4733         else
4734           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4735           destfile="$destdir/$destfile"
4736         fi
4737
4738         # Deduce the name of the destination old-style object file.
4739         case $destfile in
4740         *.lo)
4741           staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
4742           ;;
4743         *.$objext)
4744           staticdest="$destfile"
4745           destfile=
4746           ;;
4747         *)
4748           $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
4749           $echo "$help" 1>&2
4750           exit 1
4751           ;;
4752         esac
4753
4754         # Install the libtool object if requested.
4755         if test -n "$destfile"; then
4756           $show "$install_prog $file $destfile"
4757           $run eval "$install_prog $file $destfile" || exit $?
4758         fi
4759
4760         # Install the old object if enabled.
4761         if test "$build_old_libs" = yes; then
4762           # Deduce the name of the old-style object file.
4763           staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
4764
4765           $show "$install_prog $staticobj $staticdest"
4766           $run eval "$install_prog \$staticobj \$staticdest" || exit $?
4767         fi
4768         exit 0
4769         ;;
4770
4771       *)
4772         # Figure out destination file name, if it wasn't already specified.
4773         if test -n "$destname"; then
4774           destfile="$destdir/$destname"
4775         else
4776           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4777           destfile="$destdir/$destfile"
4778         fi
4779
4780         # Do a test to see if this is really a libtool program.
4781         if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
4782           notinst_deplibs=
4783           relink_command=
4784
4785           # If there is no directory component, then add one.
4786           case $file in
4787           */* | *\\*) . $file ;;
4788           *) . ./$file ;;
4789           esac
4790
4791           # Check the variables that should have been set.
4792           if test -z "$notinst_deplibs"; then
4793             $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2
4794             exit 1
4795           fi
4796
4797           finalize=yes
4798           for lib in $notinst_deplibs; do
4799             # Check to see that each library is installed.
4800             libdir=
4801             if test -f "$lib"; then
4802               # If there is no directory component, then add one.
4803               case $lib in
4804               */* | *\\*) . $lib ;;
4805               *) . ./$lib ;;
4806               esac
4807             fi
4808             libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
4809             if test -n "$libdir" && test ! -f "$libfile"; then
4810               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
4811               finalize=no
4812             fi
4813           done
4814
4815           relink_command=
4816           # If there is no directory component, then add one.
4817           case $file in
4818           */* | *\\*) . $file ;;
4819           *) . ./$file ;;
4820           esac
4821
4822           outputname=
4823           if test "$fast_install" = no && test -n "$relink_command"; then
4824             if test "$finalize" = yes && test -z "$run"; then
4825               tmpdir="/tmp"
4826               test -n "$TMPDIR" && tmpdir="$TMPDIR"
4827               tmpdir="$tmpdir/libtool-$$"
4828               if $mkdir -p "$tmpdir" && chmod 700 "$tmpdir"; then :
4829               else
4830                 $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
4831                 continue
4832               fi
4833               file=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4834               outputname="$tmpdir/$file"
4835               # Replace the output file specification.
4836               relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
4837
4838               $show "$relink_command"
4839               if $run eval "$relink_command"; then :
4840               else
4841                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
4842                 ${rm}r "$tmpdir"
4843                 continue
4844               fi
4845               file="$outputname"
4846             else
4847               $echo "$modename: warning: cannot relink \`$file'" 1>&2
4848             fi
4849           else
4850             # Install the binary that we compiled earlier.
4851             file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
4852           fi
4853         fi
4854
4855
4856         # remove .exe since cygwin /usr/bin/install will append another
4857         # one anyways
4858         case $install_prog,$host in
4859         */usr/bin/install*,*cygwin*)
4860           case $file:$destfile in
4861           *.exe:*.exe)
4862             # this is ok
4863             ;;
4864           *.exe:*)
4865             destfile=$destfile.exe
4866             ;;
4867           *:*.exe)
4868             destfile=`echo $destfile | sed -e 's,.exe$,,'`
4869             ;;
4870           esac
4871           ;;
4872         esac
4873
4874         $show "$install_prog$stripme $file $destfile"
4875         $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
4876         test -n "$outputname" && ${rm}r "$tmpdir"
4877         ;;
4878       esac
4879     done
4880
4881     for file in $staticlibs; do
4882       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4883
4884       # Set up the ranlib parameters.
4885       oldlib="$destdir/$name"
4886
4887       $show "$install_prog $file $oldlib"
4888       $run eval "$install_prog \$file \$oldlib" || exit $?
4889
4890       if test -n "$stripme" && test -n "$striplib"; then
4891         $show "$old_striplib $oldlib"
4892         $run eval "$old_striplib $oldlib" || exit $?
4893       fi
4894
4895       # Do each command in the postinstall commands.
4896       eval cmds=\"$old_postinstall_cmds\"
4897       IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
4898       for cmd in $cmds; do
4899         IFS="$save_ifs"
4900         $show "$cmd"
4901         $run eval "$cmd" || exit $?
4902       done
4903       IFS="$save_ifs"
4904     done
4905
4906     if test -n "$future_libdirs"; then
4907       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
4908     fi
4909
4910     if test -n "$current_libdirs"; then
4911       # Maybe just do a dry run.
4912       test -n "$run" && current_libdirs=" -n$current_libdirs"
4913       exec_cmd='$SHELL $0 --finish$current_libdirs'
4914     else
4915       exit 0
4916     fi
4917     ;;
4918
4919   # libtool finish mode
4920   finish)
4921     modename="$modename: finish"
4922     libdirs="$nonopt"
4923     admincmds=
4924
4925     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
4926       for dir
4927       do
4928         libdirs="$libdirs $dir"
4929       done
4930
4931       for libdir in $libdirs; do
4932         if test -n "$finish_cmds"; then
4933           # Do each command in the finish commands.
4934           eval cmds=\"$finish_cmds\"
4935           IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
4936           for cmd in $cmds; do
4937             IFS="$save_ifs"
4938             $show "$cmd"
4939             $run eval "$cmd" || admincmds="$admincmds
4940        $cmd"
4941           done
4942           IFS="$save_ifs"
4943         fi
4944         if test -n "$finish_eval"; then
4945           # Do the single finish_eval.
4946           eval cmds=\"$finish_eval\"
4947           $run eval "$cmds" || admincmds="$admincmds
4948        $cmds"
4949         fi
4950       done
4951     fi
4952
4953     # Exit here if they wanted silent mode.
4954     test "$show" = ":" && exit 0
4955
4956     echo "----------------------------------------------------------------------"
4957     echo "Libraries have been installed in:"
4958     for libdir in $libdirs; do
4959       echo "   $libdir"
4960     done
4961     echo
4962     echo "If you ever happen to want to link against installed libraries"
4963     echo "in a given directory, LIBDIR, you must either use libtool, and"
4964     echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
4965     echo "flag during linking and do at least one of the following:"
4966     if test -n "$shlibpath_var"; then
4967       echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
4968       echo "     during execution"
4969     fi
4970     if test -n "$runpath_var"; then
4971       echo "   - add LIBDIR to the \`$runpath_var' environment variable"
4972       echo "     during linking"
4973     fi
4974     if test -n "$hardcode_libdir_flag_spec"; then
4975       libdir=LIBDIR
4976       eval flag=\"$hardcode_libdir_flag_spec\"
4977
4978       echo "   - use the \`$flag' linker flag"
4979     fi
4980     if test -n "$admincmds"; then
4981       echo "   - have your system administrator run these commands:$admincmds"
4982     fi
4983     if test -f /etc/ld.so.conf; then
4984       echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
4985     fi
4986     echo
4987     echo "See any operating system documentation about shared libraries for"
4988     echo "more information, such as the ld(1) and ld.so(8) manual pages."
4989     echo "----------------------------------------------------------------------"
4990     exit 0
4991     ;;
4992
4993   # libtool execute mode
4994   execute)
4995     modename="$modename: execute"
4996
4997     # The first argument is the command name.
4998     cmd="$nonopt"
4999     if test -z "$cmd"; then
5000       $echo "$modename: you must specify a COMMAND" 1>&2
5001       $echo "$help"
5002       exit 1
5003     fi
5004
5005     # Handle -dlopen flags immediately.
5006     for file in $execute_dlfiles; do
5007       if test ! -f "$file"; then
5008         $echo "$modename: \`$file' is not a file" 1>&2
5009         $echo "$help" 1>&2
5010         exit 1
5011       fi
5012
5013       dir=
5014       case $file in
5015       *.la)
5016         # Check to see that this really is a libtool archive.
5017         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5018         else
5019           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5020           $echo "$help" 1>&2
5021           exit 1
5022         fi
5023
5024         # Read the libtool library.
5025         dlname=
5026         library_names=
5027
5028         # If there is no directory component, then add one.
5029         case $file in
5030         */* | *\\*) . $file ;;
5031         *) . ./$file ;;
5032         esac
5033
5034         # Skip this library if it cannot be dlopened.
5035         if test -z "$dlname"; then
5036           # Warn if it was a shared library.
5037           test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
5038           continue
5039         fi
5040
5041         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5042         test "X$dir" = "X$file" && dir=.
5043
5044         if test -f "$dir/$objdir/$dlname"; then
5045           dir="$dir/$objdir"
5046         else
5047           $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
5048           exit 1
5049         fi
5050         ;;
5051
5052       *.lo)
5053         # Just add the directory containing the .lo file.
5054         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5055         test "X$dir" = "X$file" && dir=.
5056         ;;
5057
5058       *)
5059         $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
5060         continue
5061         ;;
5062       esac
5063
5064       # Get the absolute pathname.
5065       absdir=`cd "$dir" && pwd`
5066       test -n "$absdir" && dir="$absdir"
5067
5068       # Now add the directory to shlibpath_var.
5069       if eval "test -z \"\$$shlibpath_var\""; then
5070         eval "$shlibpath_var=\"\$dir\""
5071       else
5072         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
5073       fi
5074     done
5075
5076     # This variable tells wrapper scripts just to set shlibpath_var
5077     # rather than running their programs.
5078     libtool_execute_magic="$magic"
5079
5080     # Check if any of the arguments is a wrapper script.
5081     args=
5082     for file
5083     do
5084       case $file in
5085       -*) ;;
5086       *)
5087         # Do a test to see if this is really a libtool program.
5088         if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5089           # If there is no directory component, then add one.
5090           case $file in
5091           */* | *\\*) . $file ;;
5092           *) . ./$file ;;
5093           esac
5094
5095           # Transform arg to wrapped name.
5096           file="$progdir/$program"
5097         fi
5098         ;;
5099       esac
5100       # Quote arguments (to preserve shell metacharacters).
5101       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
5102       args="$args \"$file\""
5103     done
5104
5105     if test -z "$run"; then
5106       if test -n "$shlibpath_var"; then
5107         # Export the shlibpath_var.
5108         eval "export $shlibpath_var"
5109       fi
5110
5111       # Restore saved enviroment variables
5112       if test "${save_LC_ALL+set}" = set; then
5113         LC_ALL="$save_LC_ALL"; export LC_ALL
5114       fi
5115       if test "${save_LANG+set}" = set; then
5116         LANG="$save_LANG"; export LANG
5117       fi
5118
5119       # Now prepare to actually exec the command.
5120       exec_cmd='"$cmd"$args'
5121     else
5122       # Display what would be done.
5123       if test -n "$shlibpath_var"; then
5124         eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
5125         $echo "export $shlibpath_var"
5126       fi
5127       $echo "$cmd$args"
5128       exit 0
5129     fi
5130     ;;
5131
5132   # libtool clean and uninstall mode
5133   clean | uninstall)
5134     modename="$modename: $mode"
5135     rm="$nonopt"
5136     files=
5137     rmforce=
5138     exit_status=0
5139
5140     # This variable tells wrapper scripts just to set variables rather
5141     # than running their programs.
5142     libtool_install_magic="$magic"
5143
5144     for arg
5145     do
5146       case $arg in
5147       -f) rm="$rm $arg"; rmforce=yes ;;
5148       -*) rm="$rm $arg" ;;
5149       *) files="$files $arg" ;;
5150       esac
5151     done
5152
5153     if test -z "$rm"; then
5154       $echo "$modename: you must specify an RM program" 1>&2
5155       $echo "$help" 1>&2
5156       exit 1
5157     fi
5158
5159     rmdirs=
5160
5161     for file in $files; do
5162       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5163       if test "X$dir" = "X$file"; then
5164         dir=.
5165         objdir="$objdir"
5166       else
5167         objdir="$dir/$objdir"
5168       fi
5169       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5170       test $mode = uninstall && objdir="$dir"
5171
5172       # Remember objdir for removal later, being careful to avoid duplicates
5173       if test $mode = clean; then
5174         case " $rmdirs " in
5175           *" $objdir "*) ;;
5176           *) rmdirs="$rmdirs $objdir" ;;
5177         esac
5178       fi
5179
5180       # Don't error if the file doesn't exist and rm -f was used.
5181       if (test -L "$file") >/dev/null 2>&1 \
5182         || (test -h "$file") >/dev/null 2>&1 \
5183         || test -f "$file"; then
5184         :
5185       elif test -d "$file"; then
5186         exit_status=1
5187         continue
5188       elif test "$rmforce" = yes; then
5189         continue
5190       fi
5191
5192       rmfiles="$file"
5193
5194       case $name in
5195       *.la)
5196         # Possibly a libtool archive, so verify it.
5197         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5198           . $dir/$name
5199
5200           # Delete the libtool libraries and symlinks.
5201           for n in $library_names; do
5202             rmfiles="$rmfiles $objdir/$n"
5203           done
5204           test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
5205           test $mode = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
5206
5207           if test $mode = uninstall; then
5208             if test -n "$library_names"; then
5209               # Do each command in the postuninstall commands.
5210               eval cmds=\"$postuninstall_cmds\"
5211               IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
5212               for cmd in $cmds; do
5213                 IFS="$save_ifs"
5214                 $show "$cmd"
5215                 $run eval "$cmd"
5216                 if test $? != 0 && test "$rmforce" != yes; then
5217                   exit_status=1
5218                 fi
5219               done
5220               IFS="$save_ifs"
5221             fi
5222
5223             if test -n "$old_library"; then
5224               # Do each command in the old_postuninstall commands.
5225               eval cmds=\"$old_postuninstall_cmds\"
5226               IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
5227               for cmd in $cmds; do
5228                 IFS="$save_ifs"
5229                 $show "$cmd"
5230                 $run eval "$cmd"
5231                 if test $? != 0 && test "$rmforce" != yes; then
5232                   exit_status=1
5233                 fi
5234               done
5235               IFS="$save_ifs"
5236             fi
5237             # FIXME: should reinstall the best remaining shared library.
5238           fi
5239         fi
5240         ;;
5241
5242       *.lo)
5243         # Possibly a libtool object, so verify it.
5244         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5245
5246           # Read the .lo file
5247           . $dir/$name
5248
5249           # Add PIC object to the list of files to remove.
5250           if test -n "$pic_object" \
5251              && test "$pic_object" != none; then
5252             rmfiles="$rmfiles $dir/$pic_object"
5253           fi
5254
5255           # Add non-PIC object to the list of files to remove.
5256           if test -n "$non_pic_object" \
5257              && test "$non_pic_object" != none; then
5258             rmfiles="$rmfiles $dir/$non_pic_object"
5259           fi
5260         fi
5261         ;;
5262
5263       *)
5264         # Do a test to see if this is a libtool program.
5265         if test $mode = clean &&
5266            (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5267           relink_command=
5268           . $dir/$file
5269
5270           rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
5271           if test "$fast_install" = yes && test -n "$relink_command"; then
5272             rmfiles="$rmfiles $objdir/lt-$name"
5273           fi
5274         fi
5275         ;;
5276       esac
5277       $show "$rm $rmfiles"
5278       $run $rm $rmfiles || exit_status=1
5279     done
5280
5281     # Try to remove the ${objdir}s in the directories where we deleted files
5282     for dir in $rmdirs; do
5283       if test -d "$dir"; then
5284         $show "rmdir $dir"
5285         $run rmdir $dir >/dev/null 2>&1
5286       fi
5287     done
5288
5289     exit $exit_status
5290     ;;
5291
5292   "")
5293     $echo "$modename: you must specify a MODE" 1>&2
5294     $echo "$generic_help" 1>&2
5295     exit 1
5296     ;;
5297   esac
5298
5299   if test -z "$exec_cmd"; then
5300     $echo "$modename: invalid operation mode \`$mode'" 1>&2
5301     $echo "$generic_help" 1>&2
5302     exit 1
5303   fi
5304 fi # test -z "$show_help"
5305
5306 if test -n "$exec_cmd"; then
5307   eval exec $exec_cmd
5308   exit 1
5309 fi
5310
5311 # We need to display help for each of the modes.
5312 case $mode in
5313 "") $echo \
5314 "Usage: $modename [OPTION]... [MODE-ARG]...
5315
5316 Provide generalized library-building support services.
5317
5318     --config          show all configuration variables
5319     --debug           enable verbose shell tracing
5320 -n, --dry-run         display commands without modifying any files
5321     --features        display basic configuration information and exit
5322     --finish          same as \`--mode=finish'
5323     --help            display this help message and exit
5324     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
5325     --quiet           same as \`--silent'
5326     --silent          don't print informational messages
5327     --tag=TAG         use configuration variables from tag TAG
5328     --version         print version information
5329
5330 MODE must be one of the following:
5331
5332       clean           remove files from the build directory
5333       compile         compile a source file into a libtool object
5334       execute         automatically set library path, then run a program
5335       finish          complete the installation of libtool libraries
5336       install         install libraries or executables
5337       link            create a library or an executable
5338       uninstall       remove libraries from an installed directory
5339
5340 MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
5341 a more detailed description of MODE."
5342   exit 0
5343   ;;
5344
5345 clean)
5346   $echo \
5347 "Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
5348
5349 Remove files from the build directory.
5350
5351 RM is the name of the program to use to delete files associated with each FILE
5352 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
5353 to RM.
5354
5355 If FILE is a libtool library, object or program, all the files associated
5356 with it are deleted. Otherwise, only FILE itself is deleted using RM."
5357   ;;
5358
5359 compile)
5360   $echo \
5361 "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
5362
5363 Compile a source file into a libtool library object.
5364
5365 This mode accepts the following additional options:
5366
5367   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
5368   -prefer-pic       try to building PIC objects only
5369   -prefer-non-pic   try to building non-PIC objects only
5370   -static           always build a \`.o' file suitable for static linking
5371
5372 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
5373 from the given SOURCEFILE.
5374
5375 The output file name is determined by removing the directory component from
5376 SOURCEFILE, then substituting the C source code suffix \`.c' with the
5377 library object suffix, \`.lo'."
5378   ;;
5379
5380 execute)
5381   $echo \
5382 "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
5383
5384 Automatically set library path, then run a program.
5385
5386 This mode accepts the following additional options:
5387
5388   -dlopen FILE      add the directory containing FILE to the library path
5389
5390 This mode sets the library path environment variable according to \`-dlopen'
5391 flags.
5392
5393 If any of the ARGS are libtool executable wrappers, then they are translated
5394 into their corresponding uninstalled binary, and any of their required library
5395 directories are added to the library path.
5396
5397 Then, COMMAND is executed, with ARGS as arguments."
5398   ;;
5399
5400 finish)
5401   $echo \
5402 "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
5403
5404 Complete the installation of libtool libraries.
5405
5406 Each LIBDIR is a directory that contains libtool libraries.
5407
5408 The commands that this mode executes may require superuser privileges.  Use
5409 the \`--dry-run' option if you just want to see what would be executed."
5410   ;;
5411
5412 install)
5413   $echo \
5414 "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
5415
5416 Install executables or libraries.
5417
5418 INSTALL-COMMAND is the installation command.  The first component should be
5419 either the \`install' or \`cp' program.
5420
5421 The rest of the components are interpreted as arguments to that command (only
5422 BSD-compatible install options are recognized)."
5423   ;;
5424
5425 link)
5426   $echo \
5427 "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
5428
5429 Link object files or libraries together to form another library, or to
5430 create an executable program.
5431
5432 LINK-COMMAND is a command using the C compiler that you would use to create
5433 a program from several object files.
5434
5435 The following components of LINK-COMMAND are treated specially:
5436
5437   -all-static       do not do any dynamic linking at all
5438   -avoid-version    do not add a version suffix if possible
5439   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
5440   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
5441   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
5442   -export-symbols SYMFILE
5443                     try to export only the symbols listed in SYMFILE
5444   -export-symbols-regex REGEX
5445                     try to export only the symbols matching REGEX
5446   -LLIBDIR          search LIBDIR for required installed libraries
5447   -lNAME            OUTPUT-FILE requires the installed library libNAME
5448   -module           build a library that can dlopened
5449   -no-fast-install  disable the fast-install mode
5450   -no-install       link a not-installable executable
5451   -no-undefined     declare that a library does not refer to external symbols
5452   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
5453   -objectlist FILE  Use a list of object files found in FILE to specify objects
5454   -release RELEASE  specify package release information
5455   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
5456   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
5457   -static           do not do any dynamic linking of libtool libraries
5458   -version-info CURRENT[:REVISION[:AGE]]
5459                     specify library version info [each variable defaults to 0]
5460
5461 All other options (arguments beginning with \`-') are ignored.
5462
5463 Every other argument is treated as a filename.  Files ending in \`.la' are
5464 treated as uninstalled libtool libraries, other files are standard or library
5465 object files.
5466
5467 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
5468 only library objects (\`.lo' files) may be specified, and \`-rpath' is
5469 required, except when creating a convenience library.
5470
5471 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
5472 using \`ar' and \`ranlib', or on Windows using \`lib'.
5473
5474 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
5475 is created, otherwise an executable program is created."
5476   ;;
5477
5478 uninstall)
5479   $echo \
5480 "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
5481
5482 Remove libraries from an installation directory.
5483
5484 RM is the name of the program to use to delete files associated with each FILE
5485 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
5486 to RM.
5487
5488 If FILE is a libtool library, all the files associated with it are deleted.
5489 Otherwise, only FILE itself is deleted using RM."
5490   ;;
5491
5492 *)
5493   $echo "$modename: invalid operation mode \`$mode'" 1>&2
5494   $echo "$help" 1>&2
5495   exit 1
5496   ;;
5497 esac
5498
5499 echo
5500 $echo "Try \`$modename --help' for more information about other modes."
5501
5502 exit 0
5503
5504 # The TAGs below are defined such that we never get into a situation
5505 # in which we disable both kinds of libraries.  Given conflicting
5506 # choices, we go for a static library, that is the most portable,
5507 # since we can't tell whether shared libraries were disabled because
5508 # the user asked for that or because the platform doesn't support
5509 # them.  This is particularly important on AIX, because we don't
5510 # support having both static and shared libraries enabled at the same
5511 # time on that platform, so we default to a shared-only configuration.
5512 # If a disable-shared tag is given, we'll fallback to a static-only
5513 # configuration.  But we'll never go from static-only to shared-only.
5514
5515 ### BEGIN LIBTOOL TAG CONFIG: disable-shared
5516 build_libtool_libs=no
5517 build_old_libs=yes
5518 ### END LIBTOOL TAG CONFIG: disable-shared
5519
5520 ### BEGIN LIBTOOL TAG CONFIG: disable-static
5521 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
5522 ### END LIBTOOL TAG CONFIG: disable-static
5523
5524 # Local Variables:
5525 # mode:shell-script
5526 # sh-indentation:2
5527 # End: