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         framework)
1115           case $host in
1116            *-*-darwin*)
1117              case "$deplibs " in
1118                *" $qarg.framework "*) ;;
1119                *) deplibs="$deplibs $qarg.framework" # this is fixed later
1120                   ;;
1121              esac
1122              ;;
1123           esac
1124           prev=
1125           continue
1126           ;;
1127         *)
1128           eval "$prev=\"\$arg\""
1129           prev=
1130           continue
1131           ;;
1132         esac
1133       fi # test -n $prev
1134
1135       prevarg="$arg"
1136
1137       case $arg in
1138       -all-static)
1139         if test -n "$link_static_flag"; then
1140           compile_command="$compile_command $link_static_flag"
1141           finalize_command="$finalize_command $link_static_flag"
1142         fi
1143         continue
1144         ;;
1145
1146       -allow-undefined)
1147         # FIXME: remove this flag sometime in the future.
1148         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1149         continue
1150         ;;
1151
1152       -avoid-version)
1153         avoid_version=yes
1154         continue
1155         ;;
1156
1157       -dlopen)
1158         prev=dlfiles
1159         continue
1160         ;;
1161
1162       -dlpreopen)
1163         prev=dlprefiles
1164         continue
1165         ;;
1166
1167       -export-dynamic)
1168         export_dynamic=yes
1169         continue
1170         ;;
1171
1172       -export-symbols | -export-symbols-regex)
1173         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1174           $echo "$modename: more than one -exported-symbols argument is not allowed"
1175           exit 1
1176         fi
1177         if test "X$arg" = "X-export-symbols"; then
1178           prev=expsyms
1179         else
1180           prev=expsyms_regex
1181         fi
1182         continue
1183         ;;
1184
1185       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1186       # so, if we see these flags be careful not to treat them like -L
1187       -L[A-Z][A-Z]*:*)
1188         case $with_gcc/$host in
1189         no/*-*-irix*)
1190           compile_command="$compile_command $arg"
1191           finalize_command="$finalize_command $arg"
1192           ;;
1193         esac
1194         continue
1195         ;;
1196
1197       -L*)
1198         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1199         # We need an absolute path.
1200         case $dir in
1201         [\\/]* | [A-Za-z]:[\\/]*) ;;
1202         *)
1203           absdir=`cd "$dir" && pwd`
1204           if test -z "$absdir"; then
1205             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1206             exit 1
1207           fi
1208           dir="$absdir"
1209           ;;
1210         esac
1211         case "$deplibs " in
1212         *" -L$dir "*) ;;
1213         *)
1214           deplibs="$deplibs -L$dir"
1215           lib_search_path="$lib_search_path $dir"
1216           ;;
1217         esac
1218         case $host in
1219         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1220           case :$dllsearchpath: in
1221           *":$dir:"*) ;;
1222           *) dllsearchpath="$dllsearchpath:$dir";;
1223           esac
1224           ;;
1225         esac
1226         continue
1227         ;;
1228
1229       -l*)
1230         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1231           case $host in
1232           *-*-cygwin* | *-*-pw32* | *-*-beos*)
1233             # These systems don't actually have a C or math library (as such)
1234             continue
1235             ;;
1236           *-*-mingw* | *-*-os2*)
1237             # These systems don't actually have a C library (as such)
1238             test "X$arg" = "X-lc" && continue
1239             ;;
1240           esac
1241         fi
1242         deplibs="$deplibs $arg"
1243         continue
1244         ;;
1245
1246       -module)
1247         module=yes
1248         continue
1249         ;;
1250
1251       -no-fast-install)
1252         fast_install=no
1253         continue
1254         ;;
1255
1256       -no-install)
1257         case $host in
1258         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1259           # The PATH hackery in wrapper scripts is required on Windows
1260           # in order for the loader to find any dlls it needs.
1261           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1262           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1263           fast_install=no
1264           ;;
1265         *) no_install=yes ;;
1266         esac
1267         continue
1268         ;;
1269
1270       -no-undefined)
1271         allow_undefined=no
1272         continue
1273         ;;
1274
1275       -objectlist)
1276         prev=objectlist
1277         continue
1278         ;;
1279
1280       -o) prev=output ;;
1281
1282       -release)
1283         prev=release
1284         continue
1285         ;;
1286
1287       -rpath)
1288         prev=rpath
1289         continue
1290         ;;
1291
1292       -R)
1293         prev=xrpath
1294         continue
1295         ;;
1296
1297       -R*)
1298         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1299         # We need an absolute path.
1300         case $dir in
1301         [\\/]* | [A-Za-z]:[\\/]*) ;;
1302         *)
1303           $echo "$modename: only absolute run-paths are allowed" 1>&2
1304           exit 1
1305           ;;
1306         esac
1307         case "$xrpath " in
1308         *" $dir "*) ;;
1309         *) xrpath="$xrpath $dir" ;;
1310         esac
1311         continue
1312         ;;
1313
1314       -static)
1315         # The effects of -static are defined in a previous loop.
1316         # We used to do the same as -all-static on platforms that
1317         # didn't have a PIC flag, but the assumption that the effects
1318         # would be equivalent was wrong.  It would break on at least
1319         # Digital Unix and AIX.
1320         continue
1321         ;;
1322
1323       -thread-safe)
1324         thread_safe=yes
1325         continue
1326         ;;
1327
1328       -version-info)
1329         prev=vinfo
1330         continue
1331         ;;
1332
1333       -Wc,*)
1334         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1335         arg=
1336         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
1337         for flag in $args; do
1338           IFS="$save_ifs"
1339           case $flag in
1340             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1341             flag="\"$flag\""
1342             ;;
1343           esac
1344           arg="$arg $wl$flag"
1345           compiler_flags="$compiler_flags $flag"
1346         done
1347         IFS="$save_ifs"
1348         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1349         ;;
1350
1351       -Wl,*)
1352         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1353         arg=
1354         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
1355         for flag in $args; do
1356           IFS="$save_ifs"
1357           case $flag in
1358             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1359             flag="\"$flag\""
1360             ;;
1361           esac
1362           arg="$arg $wl$flag"
1363           compiler_flags="$compiler_flags $wl$flag"
1364           linker_flags="$linker_flags $flag"
1365         done
1366         IFS="$save_ifs"
1367         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1368         ;;
1369
1370       -Xcompiler)
1371         prev=xcompiler
1372         continue
1373         ;;
1374
1375       -Xlinker)
1376         prev=xlinker
1377         continue
1378         ;;
1379       -framework)
1380         prev=framework
1381         continue
1382         ;;
1383
1384       # Some other compiler flag.
1385       -* | +*)
1386         # Unknown arguments in both finalize_command and compile_command need
1387         # to be aesthetically quoted because they are evaled later.
1388         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1389         case $arg in
1390         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1391           arg="\"$arg\""
1392           ;;
1393         esac
1394         ;;
1395
1396       *.$objext)
1397         # A standard object.
1398         objs="$objs $arg"
1399         ;;
1400
1401       *.lo)
1402         # A libtool-controlled object.
1403
1404         # Check to see that this really is a libtool object.
1405         if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1406           pic_object=
1407           non_pic_object=
1408
1409           # Read the .lo file
1410           # If there is no directory component, then add one.
1411           case $arg in
1412           */* | *\\*) . $arg ;;
1413           *) . ./$arg ;;
1414           esac
1415
1416           if test -z "$pic_object" || \
1417              test -z "$non_pic_object" ||
1418              test "$pic_object" = none && \
1419              test "$non_pic_object" = none; then
1420             $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1421             exit 1
1422           fi
1423
1424           # Extract subdirectory from the argument.
1425           xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1426           if test "X$xdir" = "X$arg"; then
1427             xdir=
1428           else
1429             xdir="$xdir/"
1430           fi
1431
1432           if test "$pic_object" != none; then
1433             # Prepend the subdirectory the object is found in.
1434             pic_object="$xdir$pic_object"
1435
1436             if test "$prev" = dlfiles; then
1437               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1438                 dlfiles="$dlfiles $pic_object"
1439                 prev=
1440                 continue
1441               else
1442                 # If libtool objects are unsupported, then we need to preload.
1443                 prev=dlprefiles
1444               fi
1445             fi
1446
1447             # CHECK ME:  I think I busted this.  -Ossama
1448             if test "$prev" = dlprefiles; then
1449               # Preload the old-style object.
1450               dlprefiles="$dlprefiles $pic_object"
1451               prev=
1452             fi
1453
1454             # A PIC object.
1455             libobjs="$libobjs $pic_object"
1456             arg="$pic_object"
1457           fi
1458
1459           # Non-PIC object.
1460           if test "$non_pic_object" != none; then
1461             # Prepend the subdirectory the object is found in.
1462             non_pic_object="$xdir$non_pic_object"
1463
1464             # A standard non-PIC object
1465             non_pic_objects="$non_pic_objects $non_pic_object"
1466             if test -z "$pic_object" || test "$pic_object" = none ; then
1467               arg="$non_pic_object"
1468             fi
1469           fi
1470         else
1471           # Only an error if not doing a dry-run.
1472           if test -z "$run"; then
1473             $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1474             exit 1
1475           else
1476             # Dry-run case.
1477
1478             # Extract subdirectory from the argument.
1479             xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1480             if test "X$xdir" = "X$arg"; then
1481               xdir=
1482             else
1483               xdir="$xdir/"
1484             fi
1485
1486             pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1487             non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1488             libobjs="$libobjs $pic_object"
1489             non_pic_objects="$non_pic_objects $non_pic_object"
1490           fi
1491         fi
1492         ;;
1493
1494       *.$libext)
1495         # An archive.
1496         deplibs="$deplibs $arg"
1497         old_deplibs="$old_deplibs $arg"
1498         continue
1499         ;;
1500
1501       *.la)
1502         # A libtool-controlled library.
1503
1504         if test "$prev" = dlfiles; then
1505           # This library was specified with -dlopen.
1506           dlfiles="$dlfiles $arg"
1507           prev=
1508         elif test "$prev" = dlprefiles; then
1509           # The library was specified with -dlpreopen.
1510           dlprefiles="$dlprefiles $arg"
1511           prev=
1512         else
1513           deplibs="$deplibs $arg"
1514         fi
1515         continue
1516         ;;
1517
1518       # Some other compiler argument.
1519       *)
1520         # Unknown arguments in both finalize_command and compile_command need
1521         # to be aesthetically quoted because they are evaled later.
1522         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1523         case $arg in
1524         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1525           arg="\"$arg\""
1526           ;;
1527         esac
1528         ;;
1529       esac # arg
1530
1531       # Now actually substitute the argument into the commands.
1532       if test -n "$arg"; then
1533         compile_command="$compile_command $arg"
1534         finalize_command="$finalize_command $arg"
1535       fi
1536     done # argument parsing loop
1537
1538     if test -n "$prev"; then
1539       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1540       $echo "$help" 1>&2
1541       exit 1
1542     fi
1543
1544     # Infer tagged configuration to use if any are available and
1545     # if one wasn't chosen via the "--tag" command line option.
1546     # Only attempt this if the compiler in the base link
1547     # command doesn't match the default compiler.
1548     if test -n "$available_tags" && test -z "$tagname"; then
1549       case $base_compile in
1550       "$CC "*) ;;
1551       # Blanks in the command may have been stripped by the calling shell,
1552       # but not from the CC environment variable when ltconfig was run.
1553       "`$echo $CC` "*) ;;
1554       *)
1555         for z in $available_tags; do
1556           if grep "^### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
1557             # Evaluate the configuration.
1558             eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
1559             case $base_compile in
1560             "$CC "*)
1561               # The compiler in $compile_command matches
1562               # the one in the tagged configuration.
1563               # Assume this is the tagged configuration we want.
1564               tagname=$z
1565               break
1566               ;;
1567             "`$echo $CC` "*)
1568               tagname=$z
1569               break
1570               ;;
1571             esac
1572           fi
1573         done
1574         # If $tagname still isn't set, then no tagged configuration
1575         # was found and let the user know that the "--tag" command
1576         # line option must be used.
1577         if test -z "$tagname"; then
1578           echo "$modename: unable to infer tagged configuration"
1579           echo "$modename: specify a tag with \`--tag'" 1>&2
1580           exit 1
1581 #       else
1582 #         echo "$modename: using $tagname tagged configuration"
1583         fi
1584         ;;
1585       esac
1586     fi
1587
1588     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1589       eval arg=\"$export_dynamic_flag_spec\"
1590       compile_command="$compile_command $arg"
1591       finalize_command="$finalize_command $arg"
1592     fi
1593
1594     # calculate the name of the file, without its directory
1595     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1596     libobjs_save="$libobjs"
1597
1598     if test -n "$shlibpath_var"; then
1599       # get the directories listed in $shlibpath_var
1600       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1601     else
1602       shlib_search_path=
1603     fi
1604     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1605     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1606
1607     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1608     if test "X$output_objdir" = "X$output"; then
1609       output_objdir="$objdir"
1610     else
1611       output_objdir="$output_objdir/$objdir"
1612     fi
1613     # Create the object directory.
1614     if test ! -d $output_objdir; then
1615       $show "$mkdir $output_objdir"
1616       $run $mkdir $output_objdir
1617       status=$?
1618       if test $status -ne 0 && test ! -d $output_objdir; then
1619         exit $status
1620       fi
1621     fi
1622
1623     # Determine the type of output
1624     case $output in
1625     "")
1626       $echo "$modename: you must specify an output file" 1>&2
1627       $echo "$help" 1>&2
1628       exit 1
1629       ;;
1630     *.$libext) linkmode=oldlib ;;
1631     *.lo | *.$objext) linkmode=obj ;;
1632     *.la) linkmode=lib ;;
1633     *) linkmode=prog ;; # Anything else should be a program.
1634     esac
1635
1636     specialdeplibs=
1637     libs=
1638     # Find all interdependent deplibs by searching for libraries
1639     # that are linked more than once (e.g. -la -lb -la)
1640     for deplib in $deplibs; do
1641       case "$libs " in
1642       *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1643       esac
1644       libs="$libs $deplib"
1645     done
1646
1647     if test $linkmode = lib; then
1648       libs="$predeps $libs $compiler_lib_search_path $postdeps"
1649
1650       # Compute libraries that are listed more than once in $predeps
1651       # $postdeps and mark them as special (i.e., whose duplicates are
1652       # not to be eliminated).
1653       pre_post_deps=
1654       for pre_post_dep in $predeps $postdeps; do
1655         case "$pre_post_deps " in
1656         *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1657         esac
1658         pre_post_deps="$pre_post_deps $pre_post_dep"
1659       done
1660       pre_post_deps=
1661     fi
1662
1663     deplibs=
1664     newdependency_libs=
1665     newlib_search_path=
1666     need_relink=no # whether we're linking any uninstalled libtool libraries
1667     notinst_deplibs= # not-installed libtool libraries
1668     notinst_path= # paths that contain not-installed libtool libraries
1669     case $linkmode in
1670     lib)
1671         passes="conv link"
1672         for file in $dlfiles $dlprefiles; do
1673           case $file in
1674           *.la) ;;
1675           *)
1676             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1677             exit 1
1678             ;;
1679           esac
1680         done
1681         ;;
1682     prog)
1683         compile_deplibs=
1684         finalize_deplibs=
1685         alldeplibs=no
1686         newdlfiles=
1687         newdlprefiles=
1688         passes="conv scan dlopen dlpreopen link"
1689         ;;
1690     *)  passes="conv"
1691         ;;
1692     esac
1693     for pass in $passes; do
1694       if test $linkmode = prog; then
1695         # Determine which files to process
1696         case $pass in
1697         dlopen)
1698           libs="$dlfiles"
1699           save_deplibs="$deplibs" # Collect dlpreopened libraries
1700           deplibs=
1701           ;;
1702         dlpreopen) libs="$dlprefiles" ;;
1703         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1704         esac
1705       fi
1706       for deplib in $libs; do
1707         lib=
1708         found=no
1709         case $deplib in
1710         -l*)
1711           if test $linkmode = oldlib && test $linkmode = obj; then
1712             $echo "$modename: warning: \`-l' is ignored for archives/objects: $deplib" 1>&2
1713             continue
1714           fi
1715           if test $pass = conv; then
1716             deplibs="$deplib $deplibs"
1717             continue
1718           fi
1719           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1720           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1721             # Search the libtool library
1722             lib="$searchdir/lib${name}.la"
1723             if test -f "$lib"; then
1724               found=yes
1725               break
1726             fi
1727           done
1728           if test "$found" != yes; then
1729             # deplib doesn't seem to be a libtool library
1730             if test "$linkmode,$pass" = "prog,link"; then
1731               compile_deplibs="$deplib $compile_deplibs"
1732               finalize_deplibs="$deplib $finalize_deplibs"
1733             else
1734               deplibs="$deplib $deplibs"
1735               test $linkmode = lib && newdependency_libs="$deplib $newdependency_libs"
1736             fi
1737             continue
1738           fi
1739           ;; # -l
1740         -L*)
1741           case $linkmode in
1742           lib)
1743             deplibs="$deplib $deplibs"
1744             test $pass = conv && continue
1745             newdependency_libs="$deplib $newdependency_libs"
1746             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1747             ;;
1748           prog)
1749             if test $pass = conv; then
1750               deplibs="$deplib $deplibs"
1751               continue
1752             fi
1753             if test $pass = scan; then
1754               deplibs="$deplib $deplibs"
1755               newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1756             else
1757               compile_deplibs="$deplib $compile_deplibs"
1758               finalize_deplibs="$deplib $finalize_deplibs"
1759             fi
1760             ;;
1761           *)
1762             $echo "$modename: warning: \`-L' is ignored for archives/objects: $deplib" 1>&2
1763             ;;
1764           esac # linkmode
1765           continue
1766           ;; # -L
1767         -R*)
1768           if test $pass = link; then
1769             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1770             # Make sure the xrpath contains only unique directories.
1771             case "$xrpath " in
1772             *" $dir "*) ;;
1773             *) xrpath="$xrpath $dir" ;;
1774             esac
1775           fi
1776           deplibs="$deplib $deplibs"
1777           continue
1778           ;;
1779         *.la) lib="$deplib" ;;
1780         *.$libext)
1781           if test $pass = conv; then
1782             deplibs="$deplib $deplibs"
1783             continue
1784           fi
1785           case $linkmode in
1786           lib)
1787             if test "$deplibs_check_method" != pass_all; then
1788               echo
1789               echo "*** Warning: This library needs some functionality provided by $deplib."
1790               echo "*** I have the capability to make that library automatically link in when"
1791               echo "*** you link to this library.  But I can only do this if you have a"
1792               echo "*** shared version of the library, which you do not appear to have."
1793             else
1794               echo
1795               echo "*** Warning: Linking the shared library $output against the"
1796               echo "*** static library $deplib is not portable!"
1797               deplibs="$deplib $deplibs"
1798             fi
1799             continue
1800             ;;
1801           prog)
1802             if test $pass != link; then
1803               deplibs="$deplib $deplibs"
1804             else
1805               compile_deplibs="$deplib $compile_deplibs"
1806               finalize_deplibs="$deplib $finalize_deplibs"
1807             fi
1808             continue
1809             ;;
1810           esac # linkmode
1811           ;; # *.$libext
1812         *.lo | *.$objext)
1813           if test $pass = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1814             # If there is no dlopen support or we're linking statically,
1815             # we need to preload.
1816             newdlprefiles="$newdlprefiles $deplib"
1817             compile_deplibs="$deplib $compile_deplibs"
1818             finalize_deplibs="$deplib $finalize_deplibs"
1819           else
1820             newdlfiles="$newdlfiles $deplib"
1821           fi
1822           continue
1823           ;;
1824         %DEPLIBS%)
1825           alldeplibs=yes
1826           continue
1827           ;;
1828         esac # case $deplib
1829         if test $found = yes || test -f "$lib"; then :
1830         else
1831           $echo "$modename: cannot find the library \`$lib'" 1>&2
1832           exit 1
1833         fi
1834
1835         # Check to see that this really is a libtool archive.
1836         if (sed -e '2q' $lib | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
1837         else
1838           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
1839           exit 1
1840         fi
1841
1842         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1843         test "X$ladir" = "X$lib" && ladir="."
1844
1845         dlname=
1846         dlopen=
1847         dlpreopen=
1848         libdir=
1849         library_names=
1850         old_library=
1851         # If the library was installed with an old release of libtool,
1852         # it will not redefine variable installed.
1853         installed=yes
1854
1855         # Read the .la file
1856         case $lib in
1857         */* | *\\*) . $lib ;;
1858         *) . ./$lib ;;
1859         esac
1860
1861         case $host in
1862             *-*-darwin*)
1863           # Convert "-framework foo" to "foo.framework" in dependency_libs
1864                 test -n "$dependency_libs" && dependency_libs=`$echo "X$dependency_libs" | $Xsed -e 's/-framework \([^ $]*\)/\1.framework/g'`
1865                 ;;
1866         esac
1867
1868         if test "$linkmode,$pass" = "lib,link" ||
1869            test "$linkmode,$pass" = "prog,scan" ||
1870            { test $linkmode = oldlib && test $linkmode = obj; }; then
1871            # Add dl[pre]opened files of deplib
1872           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
1873           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
1874         fi
1875
1876         if test $pass = conv; then
1877           # Only check for convenience libraries
1878           deplibs="$lib $deplibs"
1879           if test -z "$libdir"; then
1880             if test -z "$old_library"; then
1881               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1882               exit 1
1883             fi
1884             # It is a libtool convenience library, so add in its objects.
1885             convenience="$convenience $ladir/$objdir/$old_library"
1886             old_convenience="$old_convenience $ladir/$objdir/$old_library"
1887             tmp_libs=
1888             for deplib in $dependency_libs; do
1889               deplibs="$deplib $deplibs"
1890               case "$tmp_libs " in
1891               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1892               esac
1893               tmp_libs="$tmp_libs $deplib"
1894             done
1895           elif test $linkmode != prog && test $linkmode != lib; then
1896             $echo "$modename: \`$lib' is not a convenience library" 1>&2
1897             exit 1
1898           fi
1899           continue
1900         fi # $pass = conv
1901
1902         # Get the name of the library we link against.
1903         linklib=
1904         for l in $old_library $library_names; do
1905           linklib="$l"
1906         done
1907         if test -z "$linklib"; then
1908           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1909           exit 1
1910         fi
1911
1912         # This library was specified with -dlopen.
1913         if test $pass = dlopen; then
1914           if test -z "$libdir"; then
1915             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
1916             exit 1
1917           fi
1918           if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1919             # If there is no dlname, no dlopen support or we're linking
1920             # statically, we need to preload.
1921             dlprefiles="$dlprefiles $lib"
1922           else
1923             newdlfiles="$newdlfiles $lib"
1924           fi
1925           continue
1926         fi # $pass = dlopen
1927
1928         # We need an absolute path.
1929         case $ladir in
1930         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
1931         *)
1932           abs_ladir=`cd "$ladir" && pwd`
1933           if test -z "$abs_ladir"; then
1934             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
1935             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
1936             abs_ladir="$ladir"
1937           fi
1938           ;;
1939         esac
1940         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
1941
1942         # Find the relevant object directory and library name.
1943         if test "X$installed" = Xyes; then
1944           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
1945             $echo "$modename: warning: library \`$lib' was moved." 1>&2
1946             dir="$ladir"
1947             absdir="$abs_ladir"
1948             libdir="$abs_ladir"
1949           else
1950             dir="$libdir"
1951             absdir="$libdir"
1952           fi
1953         else
1954           dir="$ladir/$objdir"
1955           absdir="$abs_ladir/$objdir"
1956           # Remove this search path later
1957           notinst_path="$notinst_path $abs_ladir"
1958         fi # $installed = yes
1959         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
1960
1961         # This library was specified with -dlpreopen.
1962         if test $pass = dlpreopen; then
1963           if test -z "$libdir"; then
1964             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
1965             exit 1
1966           fi
1967           # Prefer using a static library (so that no silly _DYNAMIC symbols
1968           # are required to link).
1969           if test -n "$old_library"; then
1970             newdlprefiles="$newdlprefiles $dir/$old_library"
1971           # Otherwise, use the dlname, so that lt_dlopen finds it.
1972           elif test -n "$dlname"; then
1973             newdlprefiles="$newdlprefiles $dir/$dlname"
1974           else
1975             newdlprefiles="$newdlprefiles $dir/$linklib"
1976           fi
1977         fi # $pass = dlpreopen
1978
1979         if test -z "$libdir"; then
1980           # Link the convenience library
1981           if test $linkmode = lib; then
1982             deplibs="$dir/$old_library $deplibs"
1983           elif test "$linkmode,$pass" = "prog,link"; then
1984             compile_deplibs="$dir/$old_library $compile_deplibs"
1985             finalize_deplibs="$dir/$old_library $finalize_deplibs"
1986           else
1987             deplibs="$lib $deplibs"
1988           fi
1989           continue
1990         fi
1991
1992         if test $linkmode = prog && test $pass != link; then
1993           newlib_search_path="$newlib_search_path $ladir"
1994           deplibs="$lib $deplibs"
1995
1996           linkalldeplibs=no
1997           if test "$link_all_deplibs" != no || test -z "$library_names" ||
1998              test "$build_libtool_libs" = no; then
1999             linkalldeplibs=yes
2000           fi
2001
2002           tmp_libs=
2003           for deplib in $dependency_libs; do
2004             case $deplib in
2005             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2006             esac
2007             # Need to link against all dependency_libs?
2008             if test $linkalldeplibs = yes; then
2009               deplibs="$deplib $deplibs"
2010             else
2011               # Need to hardcode shared library paths
2012               # or/and link against static libraries
2013               newdependency_libs="$deplib $newdependency_libs"
2014             fi
2015             case "$tmp_libs " in
2016             *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2017             esac
2018             tmp_libs="$tmp_libs $deplib"
2019           done # for deplib
2020           continue
2021         fi # $linkmode = prog...
2022
2023         link_static=no # Whether the deplib will be linked statically
2024         if test -n "$library_names" &&
2025            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2026           # Link against this shared library
2027
2028           if test "$linkmode,$pass" = "prog,link" ||
2029            { test $linkmode = lib && test $hardcode_into_libs = yes; }; then
2030             # Hardcode the library path.
2031             # Skip directories that are in the system default run-time
2032             # search path.
2033             case " $sys_lib_dlsearch_path " in
2034             *" $absdir "*) ;;
2035             *)
2036               case "$compile_rpath " in
2037               *" $absdir "*) ;;
2038               *) compile_rpath="$compile_rpath $absdir"
2039               esac
2040               ;;
2041             esac
2042             case " $sys_lib_dlsearch_path " in
2043             *" $libdir "*) ;;
2044             *)
2045               case "$finalize_rpath " in
2046               *" $libdir "*) ;;
2047               *) finalize_rpath="$finalize_rpath $libdir"
2048               esac
2049               ;;
2050             esac
2051             if test $linkmode = prog; then
2052               # We need to hardcode the library path
2053               if test -n "$shlibpath_var"; then
2054                 # Make sure the rpath contains only unique directories.
2055                 case "$temp_rpath " in
2056                 *" $dir "*) ;;
2057                 *" $absdir "*) ;;
2058                 *) temp_rpath="$temp_rpath $dir" ;;
2059                 esac
2060               fi
2061             fi
2062           fi # $linkmode,$pass = prog,link...
2063
2064           if test "$alldeplibs" = yes &&
2065              { test "$deplibs_check_method" = pass_all ||
2066                { test "$build_libtool_libs" = yes &&
2067                  test -n "$library_names"; }; }; then
2068             # We only need to search for static libraries
2069             continue
2070           fi
2071
2072           if test "$installed" = no; then
2073             notinst_deplibs="$notinst_deplibs $lib"
2074             need_relink=yes
2075           fi
2076
2077           if test -n "$old_archive_from_expsyms_cmds"; then
2078             # figure out the soname
2079             set dummy $library_names
2080             realname="$2"
2081             shift; shift
2082             libname=`eval \\$echo \"$libname_spec\"`
2083             # use dlname if we got it. it's perfectly good, no?
2084             if test -n "$dlname"; then
2085               soname="$dlname"
2086             elif test -n "$soname_spec"; then
2087               # bleh windows
2088               case $host in
2089               *cygwin*)
2090                 major=`expr $current - $age`
2091                 versuffix="-$major"
2092                 ;;
2093               esac
2094               eval soname=\"$soname_spec\"
2095             else
2096               soname="$realname"
2097             fi
2098
2099             # Make a new name for the extract_expsyms_cmds to use
2100             soroot="$soname"
2101             soname=`echo $soroot | sed -e 's/^.*\///'`
2102             newlib="libimp-`echo $soname | sed 's/^lib//;s/\.dll$//'`.a"
2103
2104             # If the library has no export list, then create one now
2105             if test -f "$output_objdir/$soname-def"; then :
2106             else
2107               $show "extracting exported symbol list from \`$soname'"
2108               IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2109               cmds=$extract_expsyms_cmds
2110               for cmd in $cmds; do
2111                 IFS="$save_ifs"
2112                 eval cmd=\"$cmd\"
2113                 $show "$cmd"
2114                 $run eval "$cmd" || exit $?
2115               done
2116               IFS="$save_ifs"
2117             fi
2118
2119             # Create $newlib
2120             if test -f "$output_objdir/$newlib"; then :; else
2121               $show "generating import library for \`$soname'"
2122               IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2123               cmds=$old_archive_from_expsyms_cmds
2124               for cmd in $cmds; do
2125                 IFS="$save_ifs"
2126                 eval cmd=\"$cmd\"
2127                 $show "$cmd"
2128                 $run eval "$cmd" || exit $?
2129               done
2130               IFS="$save_ifs"
2131             fi
2132             # make sure the library variables are pointing to the new library
2133             dir=$output_objdir
2134             linklib=$newlib
2135           fi # test -n $old_archive_from_expsyms_cmds
2136
2137           if test $linkmode = prog || test "$mode" != relink; then
2138             add_shlibpath=
2139             add_dir=
2140             add=
2141             lib_linked=yes
2142             case $hardcode_action in
2143             immediate | unsupported)
2144               if test "$hardcode_direct" = no; then
2145                 add="$dir/$linklib"
2146               elif test "$hardcode_minus_L" = no; then
2147                 case $host in
2148                 *-*-sunos*) add_shlibpath="$dir" ;;
2149                 esac
2150                 add_dir="-L$dir"
2151                 add="-l$name"
2152               elif test "$hardcode_shlibpath_var" = no; then
2153                 add_shlibpath="$dir"
2154                 add="-l$name"
2155               else
2156                 lib_linked=no
2157               fi
2158               ;;
2159             relink)
2160               if test "$hardcode_direct" = yes; then
2161                 add="$dir/$linklib"
2162               elif test "$hardcode_minus_L" = yes; then
2163                 add_dir="-L$dir"
2164                 add="-l$name"
2165               elif test "$hardcode_shlibpath_var" = yes; then
2166                 add_shlibpath="$dir"
2167                 add="-l$name"
2168               else
2169                 lib_linked=no
2170               fi
2171               ;;
2172             *) lib_linked=no ;;
2173             esac
2174
2175             if test "$lib_linked" != yes; then
2176               $echo "$modename: configuration error: unsupported hardcode properties"
2177               exit 1
2178             fi
2179
2180             if test -n "$add_shlibpath"; then
2181               case :$compile_shlibpath: in
2182               *":$add_shlibpath:"*) ;;
2183               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2184               esac
2185             fi
2186             if test $linkmode = prog; then
2187               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2188               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2189             else
2190               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2191               test -n "$add" && deplibs="$add $deplibs"
2192               if test "$hardcode_direct" != yes && \
2193                  test "$hardcode_minus_L" != yes && \
2194                  test "$hardcode_shlibpath_var" = yes; then
2195                 case :$finalize_shlibpath: in
2196                 *":$libdir:"*) ;;
2197                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2198                 esac
2199               fi
2200             fi
2201           fi
2202
2203           if test $linkmode = prog || test "$mode" = relink; then
2204             add_shlibpath=
2205             add_dir=
2206             add=
2207             # Finalize command for both is simple: just hardcode it.
2208             if test "$hardcode_direct" = yes; then
2209               add="$libdir/$linklib"
2210             elif test "$hardcode_minus_L" = yes; then
2211               add_dir="-L$libdir"
2212               add="-l$name"
2213             elif test "$hardcode_shlibpath_var" = yes; then
2214               case :$finalize_shlibpath: in
2215               *":$libdir:"*) ;;
2216               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2217               esac
2218               add="-l$name"
2219             else
2220               # We cannot seem to hardcode it, guess we'll fake it.
2221               add_dir="-L$libdir"
2222               add="-l$name"
2223             fi
2224
2225             if test $linkmode = prog; then
2226               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2227               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2228             else
2229               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2230               test -n "$add" && deplibs="$add $deplibs"
2231             fi
2232           fi
2233         elif test $linkmode = prog; then
2234           if test "$alldeplibs" = yes &&
2235              { test "$deplibs_check_method" = pass_all ||
2236                { test "$build_libtool_libs" = yes &&
2237                  test -n "$library_names"; }; }; then
2238             # We only need to search for static libraries
2239             continue
2240           fi
2241
2242           # Try to link the static library
2243           # Here we assume that one of hardcode_direct or hardcode_minus_L
2244           # is not unsupported.  This is valid on all known static and
2245           # shared platforms.
2246           if test "$hardcode_direct" != unsupported; then
2247             test -n "$old_library" && linklib="$old_library"
2248             compile_deplibs="$dir/$linklib $compile_deplibs"
2249             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2250           else
2251             compile_deplibs="-l$name -L$dir $compile_deplibs"
2252             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2253           fi
2254         elif test "$build_libtool_libs" = yes; then
2255           # Not a shared library
2256           if test "$deplibs_check_method" != pass_all; then
2257             # We're trying link a shared library against a static one
2258             # but the system doesn't support it.
2259
2260             # Just print a warning and add the library to dependency_libs so
2261             # that the program can be linked against the static library.
2262             echo
2263             echo "*** Warning: This library needs some functionality provided by $lib."
2264             echo "*** I have the capability to make that library automatically link in when"
2265             echo "*** you link to this library.  But I can only do this if you have a"
2266             echo "*** shared version of the library, which you do not appear to have."
2267             if test "$module" = yes; then
2268               echo "*** Therefore, libtool will create a static module, that should work "
2269               echo "*** as long as the dlopening application is linked with the -dlopen flag."
2270               if test -z "$global_symbol_pipe"; then
2271                 echo
2272                 echo "*** However, this would only work if libtool was able to extract symbol"
2273                 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2274                 echo "*** not find such a program.  So, this module is probably useless."
2275                 echo "*** \`nm' from GNU binutils and a full rebuild may help."
2276               fi
2277               if test "$build_old_libs" = no; then
2278                 build_libtool_libs=module
2279                 build_old_libs=yes
2280               else
2281                 build_libtool_libs=no
2282               fi
2283             fi
2284           else
2285             convenience="$convenience $dir/$old_library"
2286             old_convenience="$old_convenience $dir/$old_library"
2287             deplibs="$dir/$old_library $deplibs"
2288             link_static=yes
2289           fi
2290         fi # link shared/static library?
2291
2292         if test $linkmode = lib; then
2293           if test -n "$dependency_libs" &&
2294              { test $hardcode_into_libs != yes || test $build_old_libs = yes ||
2295                test $link_static = yes; }; then
2296             # Extract -R from dependency_libs
2297             temp_deplibs=
2298             for libdir in $dependency_libs; do
2299               case $libdir in
2300               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2301                    case " $xrpath " in
2302                    *" $temp_xrpath "*) ;;
2303                    *) xrpath="$xrpath $temp_xrpath";;
2304                    esac;;
2305               *) temp_deplibs="$temp_deplibs $libdir";;
2306               esac
2307             done
2308             dependency_libs="$temp_deplibs"
2309           fi
2310
2311           newlib_search_path="$newlib_search_path $absdir"
2312           # Link against this library
2313           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2314           # ... and its dependency_libs
2315           tmp_libs=
2316           for deplib in $dependency_libs; do
2317             newdependency_libs="$deplib $newdependency_libs"
2318             case "$tmp_libs " in
2319             *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2320             esac
2321             tmp_libs="$tmp_libs $deplib"
2322           done
2323
2324           if test $link_all_deplibs != no; then
2325             # Add the search paths of all dependency libraries
2326             for deplib in $dependency_libs; do
2327               case $deplib in
2328               -L*) path="$deplib" ;;
2329               *.la)
2330                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2331                 test "X$dir" = "X$deplib" && dir="."
2332                 # We need an absolute path.
2333                 case $dir in
2334                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2335                 *)
2336                   absdir=`cd "$dir" && pwd`
2337                   if test -z "$absdir"; then
2338                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2339                     absdir="$dir"
2340                   fi
2341                   ;;
2342                 esac
2343                 if grep "^installed=no" $deplib > /dev/null; then
2344                   path="-L$absdir/$objdir"
2345                 else
2346                   eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2347                   if test -z "$libdir"; then
2348                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2349                     exit 1
2350                   fi
2351                   if test "$absdir" != "$libdir"; then
2352                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2353                   fi
2354                   path="-L$absdir"
2355                 fi
2356                 ;;
2357               *) continue ;;
2358               esac
2359               case " $deplibs " in
2360               *" $path "*) ;;
2361               *) deplibs="$path $deplibs" ;;
2362               esac
2363             done
2364           fi # link_all_deplibs != no
2365         fi # linkmode = lib
2366       done # for deplib in $libs
2367       if test $pass = dlpreopen; then
2368         # Link the dlpreopened libraries before other libraries
2369         for deplib in $save_deplibs; do
2370           deplibs="$deplib $deplibs"
2371         done
2372       fi
2373       if test $pass != dlopen; then
2374         test $pass != scan && dependency_libs="$newdependency_libs"
2375         if test $pass != conv; then
2376           # Make sure lib_search_path contains only unique directories.
2377           lib_search_path=
2378           for dir in $newlib_search_path; do
2379             case "$lib_search_path " in
2380             *" $dir "*) ;;
2381             *) lib_search_path="$lib_search_path $dir" ;;
2382             esac
2383           done
2384           newlib_search_path=
2385         fi
2386
2387         if test "$linkmode,$pass" != "prog,link"; then
2388           vars="deplibs"
2389         else
2390           vars="compile_deplibs finalize_deplibs"
2391         fi
2392         for var in $vars dependency_libs; do
2393           # Add libraries to $var in reverse order
2394           eval tmp_libs=\"\$$var\"
2395           new_libs=
2396           for deplib in $tmp_libs; do
2397             case $deplib in
2398             -L*) new_libs="$deplib $new_libs" ;;
2399             *)
2400               case " $specialdeplibs " in
2401               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2402               *)
2403                 case " $new_libs " in
2404                 *" $deplib "*) ;;
2405                 *) new_libs="$deplib $new_libs" ;;
2406                 esac
2407                 ;;
2408               esac
2409               ;;
2410             esac
2411           done
2412           tmp_libs=
2413           for deplib in $new_libs; do
2414             case $deplib in
2415             -L*)
2416               case " $tmp_libs " in
2417               *" $deplib "*) ;;
2418               *) tmp_libs="$tmp_libs $deplib" ;;
2419               esac
2420               ;;
2421             *) tmp_libs="$tmp_libs $deplib" ;;
2422             esac
2423           done
2424           eval $var=\"$tmp_libs\"
2425         done # for var
2426       fi
2427       if test "$pass" = "conv" &&
2428        { test "$linkmode" = "lib" || test "$linkmode" = "prog"; }; then
2429         libs="$deplibs" # reset libs
2430         deplibs=
2431       fi
2432     done # for pass
2433     if test $linkmode = prog; then
2434       dlfiles="$newdlfiles"
2435       dlprefiles="$newdlprefiles"
2436     fi
2437
2438     case $linkmode in
2439     oldlib)
2440       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2441         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2442       fi
2443
2444       if test -n "$rpath"; then
2445         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2446       fi
2447
2448       if test -n "$xrpath"; then
2449         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2450       fi
2451
2452       if test -n "$vinfo"; then
2453         $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
2454       fi
2455
2456       if test -n "$release"; then
2457         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2458       fi
2459
2460       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2461         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2462       fi
2463
2464       # Now set the variables for building old libraries.
2465       build_libtool_libs=no
2466       oldlibs="$output"
2467       objs="$objs$old_deplibs"
2468       ;;
2469
2470     lib)
2471       # Make sure we only generate libraries of the form `libNAME.la'.
2472       case $outputname in
2473       lib*)
2474         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2475         eval shared_ext=\"$shrext\"
2476         eval libname=\"$libname_spec\"
2477         ;;
2478       *)
2479         if test "$module" = no; then
2480           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2481           $echo "$help" 1>&2
2482           exit 1
2483         fi
2484         if test "$need_lib_prefix" != no; then
2485           # Add the "lib" prefix for modules if required
2486           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2487           eval shared_ext=\"$shrext\"
2488           eval libname=\"$libname_spec\"
2489         else
2490           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2491         fi
2492         ;;
2493       esac
2494
2495       if test -n "$objs"; then
2496         if test "$deplibs_check_method" != pass_all; then
2497           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2498           exit 1
2499         else
2500           echo
2501           echo "*** Warning: Linking the shared library $output against the non-libtool"
2502           echo "*** objects $objs is not portable!"
2503           libobjs="$libobjs $objs"
2504         fi
2505       fi
2506
2507       if test "$dlself" != no; then
2508         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2509       fi
2510
2511       set dummy $rpath
2512       if test $# -gt 2; then
2513         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2514       fi
2515       install_libdir="$2"
2516
2517       oldlibs=
2518       if test -z "$rpath"; then
2519         if test "$build_libtool_libs" = yes; then
2520           # Building a libtool convenience library.
2521           # Some compilers have problems with a `.al' extension so
2522           # convenience libraries should have the same extension an
2523           # archive normally would.
2524           oldlibs="$output_objdir/$libname.$libext $oldlibs"
2525           build_libtool_libs=convenience
2526           build_old_libs=yes
2527         fi
2528
2529         if test -n "$vinfo"; then
2530           $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
2531         fi
2532
2533         if test -n "$release"; then
2534           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2535         fi
2536       else
2537
2538         # Parse the version information argument.
2539         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
2540         set dummy $vinfo 0 0 0
2541         IFS="$save_ifs"
2542
2543         if test -n "$8"; then
2544           $echo "$modename: too many parameters to \`-version-info'" 1>&2
2545           $echo "$help" 1>&2
2546           exit 1
2547         fi
2548
2549         current="$2"
2550         revision="$3"
2551         age="$4"
2552
2553         # Check that each of the things are valid numbers.
2554         case $current in
2555         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2556         *)
2557           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2558           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2559           exit 1
2560           ;;
2561         esac
2562
2563         case $revision in
2564         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2565         *)
2566           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2567           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2568           exit 1
2569           ;;
2570         esac
2571
2572         case $age in
2573         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2574         *)
2575           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2576           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2577           exit 1
2578           ;;
2579         esac
2580
2581         if test $age -gt $current; then
2582           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2583           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2584           exit 1
2585         fi
2586
2587         # Calculate the version variables.
2588         major=
2589         versuffix=
2590         verstring=
2591         case $version_type in
2592         none) ;;
2593
2594         darwin)
2595           # Like Linux, but with the current version available in
2596           # verstring for coding it into the library header
2597           major=.`expr $current - $age`
2598           versuffix="$major.$age.$revision"
2599           # Darwin ld doesn't like 0 for these options...
2600           minor_current=`expr $current + 1`
2601           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2602           ;;
2603
2604         freebsd-aout)
2605           major=".$current"
2606           versuffix=".$current.$revision";
2607           ;;
2608
2609         freebsd-elf)
2610           major=".$current"
2611           versuffix=".$current";
2612           ;;
2613
2614         irix)
2615           major=`expr $current - $age + 1`
2616           verstring="sgi$major.$revision"
2617
2618           # Add in all the interfaces that we are compatible with.
2619           loop=$revision
2620           while test $loop != 0; do
2621             iface=`expr $revision - $loop`
2622             loop=`expr $loop - 1`
2623             verstring="sgi$major.$iface:$verstring"
2624           done
2625
2626           # Before this point, $major must not contain `.'.
2627           major=.$major
2628           versuffix="$major.$revision"
2629           ;;
2630
2631         linux)
2632           major=.`expr $current - $age`
2633           versuffix="$major.$age.$revision"
2634           ;;
2635
2636         osf)
2637           major=.`expr $current - $age`
2638           versuffix=".$current.$age.$revision"
2639           verstring="$current.$age.$revision"
2640
2641           # Add in all the interfaces that we are compatible with.
2642           loop=$age
2643           while test $loop != 0; do
2644             iface=`expr $current - $loop`
2645             loop=`expr $loop - 1`
2646             verstring="$verstring:${iface}.0"
2647           done
2648
2649           # Make executables depend on our current version.
2650           verstring="$verstring:${current}.0"
2651           ;;
2652
2653         sunos)
2654           major=".$current"
2655           versuffix=".$current.$revision"
2656           ;;
2657
2658         windows)
2659           # Use '-' rather than '.', since we only want one
2660           # extension on DOS 8.3 filesystems.
2661           major=`expr $current - $age`
2662           versuffix="-$major"
2663           ;;
2664
2665         *)
2666           $echo "$modename: unknown library version type \`$version_type'" 1>&2
2667           echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
2668           exit 1
2669           ;;
2670         esac
2671
2672         # Clear the version info if we defaulted, and they specified a release.
2673         if test -z "$vinfo" && test -n "$release"; then
2674           major=
2675           case $version_type in
2676           darwin)
2677             # we can't check for "0.0" in archive_cmds due to quoting
2678             # problems, so we reset it completely
2679             verstring=
2680             ;;
2681           *)
2682             verstring="0.0"
2683             ;;
2684           esac
2685           if test "$need_version" = no; then
2686             versuffix=
2687           else
2688             versuffix=".0.0"
2689           fi
2690         fi
2691
2692         # Remove version info from name if versioning should be avoided
2693         if test "$avoid_version" = yes && test "$need_version" = no; then
2694           major=
2695           versuffix=
2696           verstring=""
2697         fi
2698
2699         # Check to see if the archive will have undefined symbols.
2700         if test "$allow_undefined" = yes; then
2701           if test "$allow_undefined_flag" = unsupported; then
2702             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
2703             build_libtool_libs=no
2704             build_old_libs=yes
2705           fi
2706         else
2707           # Don't allow undefined symbols.
2708           allow_undefined_flag="$no_undefined_flag"
2709         fi
2710       fi
2711
2712       if test "$mode" != relink; then
2713         # Remove our outputs, but don't remove object files since they
2714         # may have been created when compiling PIC objects.
2715         removelist=
2716         tempremovelist=`echo "$output_objdir/*"`
2717         for p in $tempremovelist; do
2718           case $p in
2719             *.$objext)
2720                ;;
2721             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
2722                removelist="$removelist $p"
2723                ;;
2724             *) ;;
2725           esac
2726         done
2727         if test -n "$removelist"; then
2728           $show "${rm}r $removelist"
2729           $run ${rm}r $removelist
2730         fi
2731       fi
2732
2733       # Now set the variables for building old libraries.
2734       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
2735         oldlibs="$oldlibs $output_objdir/$libname.$libext"
2736
2737         # Transform .lo files to .o files.
2738         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
2739       fi
2740
2741       # Eliminate all temporary directories.
2742       for path in $notinst_path; do
2743         lib_search_path=`echo "$lib_search_path " | sed -e 's% $path % %g'`
2744         deplibs=`echo "$deplibs " | sed -e 's% -L$path % %g'`
2745         dependency_libs=`echo "$dependency_libs " | sed -e 's% -L$path % %g'`
2746       done
2747
2748       if test -n "$xrpath"; then
2749         # If the user specified any rpath flags, then add them.
2750         temp_xrpath=
2751         for libdir in $xrpath; do
2752           temp_xrpath="$temp_xrpath -R$libdir"
2753           case "$finalize_rpath " in
2754           *" $libdir "*) ;;
2755           *) finalize_rpath="$finalize_rpath $libdir" ;;
2756           esac
2757         done
2758         if test $hardcode_into_libs != yes || test $build_old_libs = yes; then
2759           dependency_libs="$temp_xrpath $dependency_libs"
2760         fi
2761       fi
2762
2763       # Make sure dlfiles contains only unique files that won't be dlpreopened
2764       old_dlfiles="$dlfiles"
2765       dlfiles=
2766       for lib in $old_dlfiles; do
2767         case " $dlprefiles $dlfiles " in
2768         *" $lib "*) ;;
2769         *) dlfiles="$dlfiles $lib" ;;
2770         esac
2771       done
2772
2773       # Make sure dlprefiles contains only unique files
2774       old_dlprefiles="$dlprefiles"
2775       dlprefiles=
2776       for lib in $old_dlprefiles; do
2777         case "$dlprefiles " in
2778         *" $lib "*) ;;
2779         *) dlprefiles="$dlprefiles $lib" ;;
2780         esac
2781       done
2782
2783       if test "$build_libtool_libs" = yes; then
2784         if test -n "$rpath"; then
2785           case $host in
2786           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
2787             # these systems don't actually have a c library (as such)!
2788             ;;
2789           *-*-rhapsody* | *-*-darwin1.[012])
2790             # Rhapsody C library is in the System framework
2791             deplibs="$deplibs -framework System"
2792             ;;
2793           *-*-netbsd*)
2794             # Don't link with libc until the a.out ld.so is fixed.
2795             ;;
2796           *)
2797             # Add libc to deplibs on all other systems if necessary.
2798             if test $build_libtool_need_lc = "yes"; then
2799               deplibs="$deplibs -lc"
2800             fi
2801             ;;
2802           esac
2803         fi
2804
2805         # Transform deplibs into only deplibs that can be linked in shared.
2806         name_save=$name
2807         libname_save=$libname
2808         release_save=$release
2809         versuffix_save=$versuffix
2810         major_save=$major
2811         # I'm not sure if I'm treating the release correctly.  I think
2812         # release should show up in the -l (ie -lgmp5) so we don't want to
2813         # add it in twice.  Is that correct?
2814         release=""
2815         versuffix=""
2816         major=""
2817         newdeplibs=
2818         droppeddeps=no
2819         case $deplibs_check_method in
2820         pass_all)
2821           # Don't check for shared/static.  Everything works.
2822           # This might be a little naive.  We might want to check
2823           # whether the library exists or not.  But this is on
2824           # osf3 & osf4 and I'm not really sure... Just
2825           # implementing what was already the behaviour.
2826           newdeplibs=$deplibs
2827           ;;
2828         test_compile)
2829           # This code stresses the "libraries are programs" paradigm to its
2830           # limits. Maybe even breaks it.  We compile a program, linking it
2831           # against the deplibs as a proxy for the library.  Then we can check
2832           # whether they linked in statically or dynamically with ldd.
2833           $rm conftest.c
2834           cat > conftest.c <<EOF
2835           int main() { return 0; }
2836 EOF
2837           $rm conftest
2838           $LTCC -o conftest conftest.c $deplibs
2839           if test $? -eq 0 ; then
2840             ldd_output=`ldd conftest`
2841             for i in $deplibs; do
2842               name="`expr $i : '-l\(.*\)'`"
2843               # If $name is empty we are operating on a -L argument.
2844               if test -n "$name" && test "$name" != "0"; then
2845                 libname=`eval \\$echo \"$libname_spec\"`
2846                 deplib_matches=`eval \\$echo \"$library_names_spec\"`
2847                 set dummy $deplib_matches
2848                 deplib_match=$2
2849                 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2850                   newdeplibs="$newdeplibs $i"
2851                 else
2852                   droppeddeps=yes
2853                   echo
2854                   echo "*** Warning: This library needs some functionality provided by $i."
2855                   echo "*** I have the capability to make that library automatically link in when"
2856                   echo "*** you link to this library.  But I can only do this if you have a"
2857                   echo "*** shared version of the library, which you do not appear to have."
2858                 fi
2859               else
2860                 newdeplibs="$newdeplibs $i"
2861               fi
2862             done
2863           else
2864             # Error occured in the first compile.  Let's try to salvage the situation:
2865             # Compile a seperate program for each library.
2866             for i in $deplibs; do
2867               name="`expr $i : '-l\(.*\)'`"
2868              # If $name is empty we are operating on a -L argument.
2869               if test -n "$name" && test "$name" != "0"; then
2870                 $rm conftest
2871                 $LTCC -o conftest conftest.c $i
2872                 # Did it work?
2873                 if test $? -eq 0 ; then
2874                   ldd_output=`ldd conftest`
2875                   libname=`eval \\$echo \"$libname_spec\"`
2876                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
2877                   set dummy $deplib_matches
2878                   deplib_match=$2
2879                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2880                     newdeplibs="$newdeplibs $i"
2881                   else
2882                     droppeddeps=yes
2883                     echo
2884                     echo "*** Warning: This library needs some functionality provided by $i."
2885                     echo "*** I have the capability to make that library automatically link in when"
2886                     echo "*** you link to this library.  But I can only do this if you have a"
2887                     echo "*** shared version of the library, which you do not appear to have."
2888                   fi
2889                 else
2890                   droppeddeps=yes
2891                   echo
2892                   echo "*** Warning!  Library $i is needed by this library but I was not able to"
2893                   echo "***  make it link in!  You will probably need to install it or some"
2894                   echo "*** library that it depends on before this library will be fully"
2895                   echo "*** functional.  Installing it before continuing would be even better."
2896                 fi
2897               else
2898                 newdeplibs="$newdeplibs $i"
2899               fi
2900             done
2901           fi
2902           ;;
2903         file_magic*)
2904           set dummy $deplibs_check_method
2905           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2906           for a_deplib in $deplibs; do
2907             name="`expr $a_deplib : '-l\(.*\)'`"
2908             # If $name is empty we are operating on a -L argument.
2909             if test -n "$name" && test "$name" != "0"; then
2910               libname=`eval \\$echo \"$libname_spec\"`
2911               for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2912                     potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2913                     for potent_lib in $potential_libs; do
2914                       # Follow soft links.
2915                       if ls -lLd "$potent_lib" 2>/dev/null \
2916                          | grep " -> " >/dev/null; then
2917                         continue
2918                       fi
2919                       # The statement above tries to avoid entering an
2920                       # endless loop below, in case of cyclic links.
2921                       # We might still enter an endless loop, since a link
2922                       # loop can be closed while we follow links,
2923                       # but so what?
2924                       potlib="$potent_lib"
2925                       while test -h "$potlib" 2>/dev/null; do
2926                         potliblink=`ls -ld $potlib | sed 's/.* -> //'`
2927                         case $potliblink in
2928                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
2929                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
2930                         esac
2931                       done
2932                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
2933                          | sed 10q \
2934                          | egrep "$file_magic_regex" > /dev/null; then
2935                         newdeplibs="$newdeplibs $a_deplib"
2936                         a_deplib=""
2937                         break 2
2938                       fi
2939                     done
2940               done
2941               if test -n "$a_deplib" ; then
2942                 droppeddeps=yes
2943                 echo
2944                 echo "*** Warning: This library needs some functionality provided by $a_deplib."
2945                 echo "*** I have the capability to make that library automatically link in when"
2946                 echo "*** you link to this library.  But I can only do this if you have a"
2947                 echo "*** shared version of the library, which you do not appear to have."
2948               fi
2949             else
2950               # Add a -L argument.
2951               newdeplibs="$newdeplibs $a_deplib"
2952             fi
2953           done # Gone through all deplibs.
2954           ;;
2955         match_pattern*)
2956           set dummy $deplibs_check_method
2957           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2958           for a_deplib in $deplibs; do
2959             name="`expr $a_deplib : '-l\(.*\)'`"
2960             # If $name is empty we are operating on a -L argument.
2961             if test -n "$name" && test "$name" != "0"; then
2962               libname=`eval \\$echo \"$libname_spec\"`
2963               for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2964                 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2965                 for potent_lib in $potential_libs; do
2966                   if eval echo \"$potent_lib\" 2>/dev/null \
2967                       | sed 10q \
2968                       | egrep "$match_pattern_regex" > /dev/null; then
2969                     newdeplibs="$newdeplibs $a_deplib"
2970                     a_deplib=""
2971                     break 2
2972                   fi
2973                 done
2974               done
2975               if test -n "$a_deplib" ; then
2976                 droppeddeps=yes
2977                 echo
2978                 echo "*** Warning: This library needs some functionality provided by $a_deplib."
2979                 echo "*** I have the capability to make that library automatically link in when"
2980                 echo "*** you link to this library.  But I can only do this if you have a"
2981                 echo "*** shared version of the library, which you do not appear to have."
2982               fi
2983             else
2984               # Add a -L argument.
2985               newdeplibs="$newdeplibs $a_deplib"
2986             fi
2987           done # Gone through all deplibs.
2988           ;;
2989         none | unknown | *)
2990           newdeplibs=""
2991           if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
2992                -e 's/ -[LR][^ ]*//g' -e 's/[    ]//g' |
2993              grep . >/dev/null; then
2994             echo
2995             if test "X$deplibs_check_method" = "Xnone"; then
2996               echo "*** Warning: inter-library dependencies are not supported in this platform."
2997             else
2998               echo "*** Warning: inter-library dependencies are not known to be supported."
2999             fi
3000             echo "*** All declared inter-library dependencies are being dropped."
3001             droppeddeps=yes
3002           fi
3003           ;;
3004         esac
3005         versuffix=$versuffix_save
3006         major=$major_save
3007         release=$release_save
3008         libname=$libname_save
3009         name=$name_save
3010
3011         case $host in
3012         *-*-rhapsody* | *-*-darwin1.[012])
3013           # On Rhapsody replace the C library is the System framework
3014           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3015           ;;
3016         esac
3017
3018         if test "$droppeddeps" = yes; then
3019           if test "$module" = yes; then
3020             echo
3021             echo "*** Warning: libtool could not satisfy all declared inter-library"
3022             echo "*** dependencies of module $libname.  Therefore, libtool will create"
3023             echo "*** a static module, that should work as long as the dlopening"
3024             echo "*** application is linked with the -dlopen flag."
3025             if test -z "$global_symbol_pipe"; then
3026               echo
3027               echo "*** However, this would only work if libtool was able to extract symbol"
3028               echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3029               echo "*** not find such a program.  So, this module is probably useless."
3030               echo "*** \`nm' from GNU binutils and a full rebuild may help."
3031             fi
3032             if test "$build_old_libs" = no; then
3033               oldlibs="$output_objdir/$libname.$libext"
3034               build_libtool_libs=module
3035               build_old_libs=yes
3036             else
3037               build_libtool_libs=no
3038             fi
3039           else
3040             echo "*** The inter-library dependencies that have been dropped here will be"
3041             echo "*** automatically added whenever a program is linked with this library"
3042             echo "*** or is declared to -dlopen it."
3043
3044             if test $allow_undefined = no; then
3045               echo
3046               echo "*** Since this library must not contain undefined symbols,"
3047               echo "*** because either the platform does not support them or"
3048               echo "*** it was explicitly requested with -no-undefined,"
3049               echo "*** libtool will only create a static version of it."
3050               if test "$build_old_libs" = no; then
3051                 oldlibs="$output_objdir/$libname.$libext"
3052                 build_libtool_libs=module
3053                 build_old_libs=yes
3054               else
3055                 build_libtool_libs=no
3056               fi
3057             fi
3058           fi
3059         fi
3060         # Time to change all our "foo.framework" stuff back to "-framework foo"
3061         case $host in
3062             *-*-darwin*)
3063                 newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).framework% -framework \1%g'`
3064                 dependency_libs=`$echo "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).framework% -framework \1%g'`
3065                 ;;
3066         esac
3067         # Done checking deplibs!
3068         # Done checking deplibs!
3069         deplibs=$newdeplibs
3070       fi
3071
3072       # All the library-specific variables (install_libdir is set above).
3073       library_names=
3074       old_library=
3075       dlname=
3076
3077       # Test again, we may have decided not to build it any more
3078       if test "$build_libtool_libs" = yes; then
3079         if test $hardcode_into_libs = yes; then
3080           # Hardcode the library paths
3081           hardcode_libdirs=
3082           dep_rpath=
3083           rpath="$finalize_rpath"
3084           test "$mode" != relink && rpath="$compile_rpath$rpath"
3085           for libdir in $rpath; do
3086             if test -n "$hardcode_libdir_flag_spec"; then
3087               if test -n "$hardcode_libdir_separator"; then
3088                 if test -z "$hardcode_libdirs"; then
3089                   hardcode_libdirs="$libdir"
3090                 else
3091                   # Just accumulate the unique libdirs.
3092                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3093                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3094                     ;;
3095                   *)
3096                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3097                     ;;
3098                   esac
3099                 fi
3100               else
3101                 eval flag=\"$hardcode_libdir_flag_spec\"
3102                 dep_rpath="$dep_rpath $flag"
3103               fi
3104             elif test -n "$runpath_var"; then
3105               case "$perm_rpath " in
3106               *" $libdir "*) ;;
3107               *) perm_rpath="$perm_rpath $libdir" ;;
3108               esac
3109             fi
3110           done
3111           # Substitute the hardcoded libdirs into the rpath.
3112           if test -n "$hardcode_libdir_separator" &&
3113              test -n "$hardcode_libdirs"; then
3114             libdir="$hardcode_libdirs"
3115             eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3116           fi
3117           if test -n "$runpath_var" && test -n "$perm_rpath"; then
3118             # We should set the runpath_var.
3119             rpath=
3120             for dir in $perm_rpath; do
3121               rpath="$rpath$dir:"
3122             done
3123             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3124           fi
3125           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3126         fi
3127
3128         shlibpath="$finalize_shlibpath"
3129         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3130         if test -n "$shlibpath"; then
3131           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3132         fi
3133
3134         # Get the real and link names of the library.
3135         eval library_names=\"$library_names_spec\"
3136         eval shared_ext=\"$shrext\"
3137         set dummy $library_names
3138         realname="$2"
3139         shift; shift
3140
3141         if test -n "$soname_spec"; then
3142           eval soname=\"$soname_spec\"
3143         else
3144           soname="$realname"
3145         fi
3146         test -z "$dlname" && dlname=$soname
3147
3148         lib="$output_objdir/$realname"
3149         for link
3150         do
3151           linknames="$linknames $link"
3152         done
3153
3154 #       # Ensure that we have .o objects for linkers which dislike .lo
3155 #       # (e.g. aix) in case we are running --disable-static
3156 #       for obj in $libobjs; do
3157 #         xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
3158 #         if test "X$xdir" = "X$obj"; then
3159 #           xdir="."
3160 #         else
3161 #           xdir="$xdir"
3162 #         fi
3163 #         baseobj=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
3164 #         oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
3165 #         if test ! -f $xdir/$oldobj && test "$baseobj" != "$oldobj"; then
3166 #           $show "(cd $xdir && ${LN_S} $baseobj $oldobj)"
3167 #           $run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?
3168 #         fi
3169 #       done
3170
3171         # Use standard objects if they are pic
3172         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3173
3174         # Prepare the list of exported symbols
3175         if test -z "$export_symbols"; then
3176           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3177             $show "generating symbol list for \`$libname.la'"
3178             export_symbols="$output_objdir/$libname.exp"
3179             $run $rm $export_symbols
3180             eval cmds=\"$export_symbols_cmds\"
3181             IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
3182             for cmd in $cmds; do
3183               IFS="$save_ifs"
3184               $show "$cmd"
3185               $run eval "$cmd" || exit $?
3186             done
3187             IFS="$save_ifs"
3188             if test -n "$export_symbols_regex"; then
3189               $show "egrep -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3190               $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3191               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3192               $run eval '$mv "${export_symbols}T" "$export_symbols"'
3193             fi
3194           fi
3195         fi
3196
3197         if test -n "$export_symbols" && test -n "$include_expsyms"; then
3198           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3199         fi
3200
3201         if test -n "$convenience"; then
3202           if test -n "$whole_archive_flag_spec"; then
3203             save_libobjs=$libobjs
3204             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3205           else
3206             gentop="$output_objdir/${outputname}x"
3207             $show "${rm}r $gentop"
3208             $run ${rm}r "$gentop"
3209             $show "$mkdir $gentop"
3210             $run $mkdir "$gentop"
3211             status=$?
3212             if test $status -ne 0 && test ! -d "$gentop"; then
3213               exit $status
3214             fi
3215             generated="$generated $gentop"
3216
3217             for xlib in $convenience; do
3218               # Extract the objects.
3219               case $xlib in
3220               [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3221               *) xabs=`pwd`"/$xlib" ;;
3222               esac
3223               xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3224               xdir="$gentop/$xlib"
3225
3226               $show "${rm}r $xdir"
3227               $run ${rm}r "$xdir"
3228               $show "$mkdir $xdir"
3229               $run $mkdir "$xdir"
3230               status=$?
3231               if test $status -ne 0 && test ! -d "$xdir"; then
3232                 exit $status
3233               fi
3234               $show "(cd $xdir && $AR x $xabs)"
3235               $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3236
3237               libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3238             done
3239           fi
3240         fi
3241
3242         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3243           eval flag=\"$thread_safe_flag_spec\"
3244           linker_flags="$linker_flags $flag"
3245         fi
3246
3247         # Make a backup of the uninstalled library when relinking
3248         if test "$mode" = relink; then
3249           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3250         fi
3251
3252         # Do each of the archive commands.
3253         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3254           eval test_cmds=\"$archive_expsym_cmds\"
3255           cmds=$archive_expsym_cmds
3256         else
3257           eval test_cmds=\"$archive_cmds\"
3258           cmds=$archive_cmds
3259         fi
3260         if len=`expr "X$test_cmds" : ".*"` &&
3261            test $len -le $max_cmd_len; then
3262           :
3263         else
3264           # The command line is too long to link in one step, link piecewise.
3265           $echo "creating reloadable object files..."
3266
3267           # Save the value of $output and $libobjs because we want to
3268           # use them later.  If we have whole_archive_flag_spec, we
3269           # want to use save_libobjs as it was before
3270           # whole_archive_flag_spec was expanded, because we can't
3271           # assume the linker understands whole_archive_flag_spec.
3272           # This may have to be revisited, in case too many
3273           # convenience libraries get linked in and end up exceeding
3274           # the spec.
3275           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3276             save_libobjs=$libobjs
3277           fi
3278           save_output=$output
3279
3280           # Clear the reloadable object creation command queue and
3281           # initialize k to one.
3282           test_cmds=
3283           concat_cmds=
3284           objlist=
3285           delfiles=
3286           last_robj=
3287           k=1
3288           output=$output_objdir/$save_output-${k}.$objext
3289           # Loop over the list of objects to be linked.
3290           for obj in $save_libobjs
3291           do
3292             eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3293             if test "X$objlist" = X ||
3294                { len=`expr "X$test_cmds" : ".*"` &&
3295                  test $len -le $max_cmd_len; }; then
3296               objlist="$objlist $obj"
3297             else
3298               # The command $test_cmds is almost too long, add a
3299               # command to the queue.
3300               if test $k -eq 1 ; then
3301                 # The first file doesn't have a previous command to add.
3302                 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3303               else
3304                 # All subsequent reloadable object files will link in
3305                 # the last one created.
3306                 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3307               fi
3308               last_robj=$output_objdir/$save_output-${k}.$objext
3309               k=`expr $k + 1`
3310               output=$output_objdir/$save_output-${k}.$objext
3311               objlist=$obj
3312               len=1
3313             fi
3314           done
3315           # Handle the remaining objects by creating one last
3316           # reloadable object file.  All subsequent reloadable object
3317           # files will link in the last one created.
3318           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3319           eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3320
3321           # Set up a command to remove the reloadale object files
3322           # after they are used.
3323           i=0
3324           while test $i -lt $k
3325           do
3326             i=`expr $i + 1`
3327             delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3328           done
3329
3330           $echo "creating a temporary reloadable object file: $output"
3331
3332           # Loop through the commands generated above and execute them.
3333           IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
3334           for cmd in $concat_cmds; do
3335             IFS="$save_ifs"
3336             eval cmd=\"$cmd\"
3337             $show "$cmd"
3338             $run eval "$cmd" || exit $?
3339           done
3340           IFS="$save_ifs"
3341
3342           libobjs=$output
3343           # Restore the value of output.
3344           output=$save_output
3345
3346           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3347             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3348           fi
3349           # Expand the library linking commands again to reset the
3350           # value of $libobjs for piecewise linking.
3351
3352           # Do each of the archive commands.
3353           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3354             cmds=$archive_expsym_cmds
3355           else
3356             cmds=$archive_cmds
3357           fi
3358
3359           # Append the command to remove the reloadable object files
3360           # to the just-reset $cmds.
3361           eval cmds=\"\$cmds~$rm $delfiles\"
3362         fi
3363         IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
3364         for cmd in $cmds; do
3365           IFS="$save_ifs"
3366           eval cmd=\"$cmd\"
3367           $show "$cmd"
3368           $run eval "$cmd" || exit $?
3369         done
3370         IFS="$save_ifs"
3371
3372         # Restore the uninstalled library and exit
3373         if test "$mode" = relink; then
3374           $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
3375           exit 0
3376         fi
3377
3378         # Create links to the real library.
3379         for linkname in $linknames; do
3380           if test "$realname" != "$linkname"; then
3381             $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
3382             $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
3383           fi
3384         done
3385
3386         # If -module or -export-dynamic was specified, set the dlname.
3387         if test "$module" = yes || test "$export_dynamic" = yes; then
3388           # On all known operating systems, these are identical.
3389           dlname="$soname"
3390         fi
3391       fi
3392       ;;
3393
3394     obj)
3395       if test -n "$deplibs"; then
3396         $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
3397       fi
3398
3399       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3400         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
3401       fi
3402