ltmain.sh

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