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