ltmain.sh

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