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