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