ltmain.sh

   1 # ltmain.sh - Provide generalized library-building support services.
   2 # NOTE: Changing this file will not affect anything until you rerun ltconfig.
   3 #
   4 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
   5 # Free Software Foundation, Inc.
   6 # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful, but
  14 # WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 # General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program; if not, write to the Free Software
  20 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21 #
  22 # As a special exception to the GNU General Public License, if you
  23 # distribute this file as part of a program that contains a
  24 # configuration script generated by Autoconf, you may include it under
  25 # the same distribution terms that you use for the rest of that program.
  26
  27 # Check that we have a working $echo.
  28 if test "X$1" = X--no-reexec; then
  29   # Discard the --no-reexec flag, and continue.
  30   shift
  31 elif test "X$1" = X--fallback-echo; then
  32   # Avoid inline document here, it may be left over
  33   :
  34 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
  35   # Yippee, $echo works!
  36   :
  37 else
  38   # Restart under the correct shell, and then maybe $echo will work.
  39   exec $SHELL "$0" --no-reexec ${1+"$@"}
  40 fi
  41
  42 if test "X$1" = X--fallback-echo; then
  43   # used as fallback echo
  44   shift
  45   cat <<EOF
  46 $*
  47 EOF
  48   exit 0
  49 fi
  50
  51 # The name of this program.
  52 progname=`$echo "$0" | sed 's%^.*/%%'`
  53 modename="$progname"
  54
  55 # Constants.
  56 PROGRAM=ltmain.sh
  57 PACKAGE=libtool
  58 VERSION=1.4a-GCC3.0
  59 TIMESTAMP=" (1.641.2.256 2001/05/28 20:09:07 with GCC-local changes)"
  60
  61 default_mode=
  62 help="Try \`$progname --help' for more information."
  63 magic="%%%MAGIC variable%%%"
  64 mkdir="mkdir"
  65 mv="mv -f"
  66 rm="rm -f"
  67
  68 # Sed substitution that helps us do robust quoting.  It backslashifies
  69 # metacharacters that are still active within double-quoted strings.
  70 Xsed='sed -e 1s/^X//'
  71 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
  72 SP2NL='tr \040 \012'
  73 NL2SP='tr \015\012 \040\040'
  74
  75 # NLS nuisances.
  76 # Only set LANG and LC_ALL to C if already set.
  77 # These must not be set unconditionally because not all systems understand
  78 # e.g. LANG=C (notably SCO).
  79 # We save the old values to restore during execute mode.
  80 if test "${LC_ALL+set}" = set; then
  81   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
  82 fi
  83 if test "${LANG+set}" = set; then
  84   save_LANG="$LANG"; LANG=C; export LANG
  85 fi
  86
  87 if test "$LTCONFIG_VERSION" != "$VERSION"; then
  88   echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2
  89   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  90   exit 1
  91 fi
  92
  93 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
  94   echo "$modename: not configured to build any kind of library" 1>&2
  95   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  96   exit 1
  97 fi
  98
  99 # Global variables.
 100 mode=$default_mode
 101 nonopt=
 102 prev=
 103 prevopt=
 104 run=
 105 show="$echo"
 106 show_help=
 107 execute_dlfiles=
 108 lo2o="s/\\.lo\$/.${objext}/"
 109 o2lo="s/\\.${objext}\$/.lo/"
 110 taglist=
 111
 112 # Parse our command line options once, thoroughly.
 113 while test $# -gt 0
 114 do
 115   arg="$1"
 116   shift
 117
 118   case $arg in
 119   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
 120   *) optarg= ;;
 121   esac
 122
 123   # If the previous option needs an argument, assign it.
 124   if test -n "$prev"; then
 125     case $prev in
 126     execute_dlfiles)
 127       execute_dlfiles="$execute_dlfiles $arg"
 128       ;;
 129     tag)
 130       tagname="$arg"
 131
 132       # Check whether tagname contains only valid characters
 133       case $tagname in
 134       *[!-_A-Za-z0-9,/]*)
 135         echo "$progname: invalid tag name: $tagname" 1>&2
 136         exit 1
 137         ;;
 138       esac
 139
 140       case $tagname in
 141       CC)
 142         # Don't test for the "default" C tag, as we know, it's there, but
 143         # not specially marked.
 144         taglist="$taglist $tagname"
 145         ;;
 146       *)
 147         if grep "^### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$0" > /dev/null; then
 148           taglist="$taglist $tagname"
 149           # Evaluate the configuration.
 150           eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $0`"
 151         else
 152           echo "$progname: ignoring unknown tag $tagname" 1>&2
 153         fi
 154         ;;
 155       esac
 156       ;;
 157     *)
 158       eval "$prev=\$arg"
 159       ;;
 160     esac
 161
 162     prev=
 163     prevopt=
 164     continue
 165   fi
 166
 167   # Have we seen a non-optional argument yet?
 168   case $arg in
 169   --help)
 170     show_help=yes
 171     ;;
 172
 173   --version)
 174     echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
 175     exit 0
 176     ;;
 177
 178   --config)
 179     sed -n -e '/^### BEGIN LIBTOOL CONFIG/,/^### END LIBTOOL CONFIG/p' < "$0"
 180     # Now print the configurations for the tags.
 181     for tagname in $taglist; do
 182       sed -n -e "/^### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^### END LIBTOOL TAG CONFIG: $tagname$/p" < "$0"
 183     done
 184     exit 0
 185     ;;
 186
 187   --debug)
 188     echo "$progname: enabling shell trace mode"
 189     set -x
 190     ;;
 191
 192   --dry-run | -n)
 193     run=:
 194     ;;
 195
 196   --features)
 197     echo "host: $host"
 198     if test "$build_libtool_libs" = yes; then
 199       echo "enable shared libraries"
 200     else
 201       echo "disable shared libraries"
 202     fi
 203     if test "$build_old_libs" = yes; then
 204       echo "enable static libraries"
 205     else
 206       echo "disable static libraries"
 207     fi
 208     exit 0
 209     ;;
 210
 211   --finish) mode="finish" ;;
 212
 213   --mode) prevopt="--mode" prev=mode ;;
 214   --mode=*) mode="$optarg" ;;
 215
 216   --quiet | --silent)
 217     show=:
 218     ;;
 219
 220   --tag) prevopt="--tag" prev=tag ;;
 221   --tag=*)
 222     set tag "$optarg" ${1+"$@"}
 223     shift
 224     prev=tag
 225     ;;
 226
 227   -dlopen)
 228     prevopt="-dlopen"
 229     prev=execute_dlfiles
 230     ;;
 231
 232   -*)
 233     $echo "$modename: unrecognized option \`$arg'" 1>&2
 234     $echo "$help" 1>&2
 235     exit 1
 236     ;;
 237
 238   *)
 239     nonopt="$arg"
 240     break
 241     ;;
 242   esac
 243 done
 244
 245 if test -n "$prevopt"; then
 246   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
 247   $echo "$help" 1>&2
 248   exit 1
 249 fi
 250
 251 # If this variable is set in any of the actions, the command in it
 252 # will be execed at the end.  This prevents here-documents from being
 253 # left over by shells.
 254 exec_cmd=
 255
 256 if test -z "$show_help"; then
 257
 258   # Infer the operation mode.
 259   if test -z "$mode"; then
 260     case $nonopt in
 261     *cc | *++ | gcc* | *-gcc*)
 262       mode=link
 263       for arg
 264       do
 265         case $arg in
 266         -c)
 267            mode=compile
 268            break
 269            ;;
 270         esac
 271       done
 272       ;;
 273     *db | *dbx | *strace | *truss)
 274       mode=execute
 275       ;;
 276     *install*|cp|mv)
 277       mode=install
 278       ;;
 279     *rm)
 280       mode=uninstall
 281       ;;
 282     *)
 283       # If we have no mode, but dlfiles were specified, then do execute mode.
 284       test -n "$execute_dlfiles" && mode=execute
 285
 286       # Just use the default operation mode.
 287       if test -z "$mode"; then
 288         if test -n "$nonopt"; then
 289           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
 290         else
 291           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
 292         fi
 293       fi
 294       ;;
 295     esac
 296   fi
 297
 298   # Only execute mode is allowed to have -dlopen flags.
 299   if test -n "$execute_dlfiles" && test "$mode" != execute; then
 300     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
 301     $echo "$help" 1>&2
 302     exit 1
 303   fi
 304
 305   # Change the help message to a mode-specific one.
 306   generic_help="$help"
 307   help="Try \`$modename --help --mode=$mode' for more information."
 308
 309   # These modes are in order of execution frequency so that they run quickly.
 310   case $mode in
 311   # libtool compile mode
 312   compile)
 313     modename="$modename: compile"
 314     # Get the compilation command and the source file.
 315     base_compile=
 316     prev=
 317     lastarg=
 318     srcfile="$nonopt"
 319     suppress_output=
 320
 321     user_target=no
 322     for arg
 323     do
 324       case $prev in
 325       "") ;;
 326       xcompiler)
 327         # Aesthetically quote the previous argument.
 328         prev=
 329         lastarg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
 330
 331         case $arg in
 332         # Double-quote args containing other shell metacharacters.
 333         # Many Bourne shells cannot handle close brackets correctly
 334         # in scan sets, so we specify it separately.
 335         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
 336           arg="\"$arg\""
 337           ;;
 338         esac
 339
 340         # Add the previous argument to base_compile.
 341         if test -z "$base_compile"; then
 342           base_compile="$lastarg"
 343         else
 344           base_compile="$base_compile $lastarg"
 345         fi
 346         continue
 347         ;;
 348       esac
 349
 350       # Accept any command-line options.
 351       case $arg in
 352       -o)
 353         if test "$user_target" != "no"; then
 354           $echo "$modename: you cannot specify \`-o' more than once" 1>&2
 355           exit 1
 356         fi
 357         user_target=next
 358         ;;
 359
 360       -static)
 361         build_old_libs=yes
 362         continue
 363         ;;
 364
 365       -prefer-pic)
 366         pic_mode=yes
 367         continue
 368         ;;
 369
 370       -prefer-non-pic)
 371         pic_mode=no
 372         continue
 373         ;;
 374
 375       -Xcompiler)
 376         prev=xcompiler
 377         continue
 378         ;;
 379
 380       -Wc,*)
 381         args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
 382         lastarg=
 383         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
 384         for arg in $args; do
 385           IFS="$save_ifs"
 386
 387           # Double-quote args containing other shell metacharacters.
 388           # Many Bourne shells cannot handle close brackets correctly
 389           # in scan sets, so we specify it separately.
 390           case $arg in
 391             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
 392             arg="\"$arg\""
 393             ;;
 394           esac
 395           lastarg="$lastarg $arg"
 396         done
 397         IFS="$save_ifs"
 398         lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
 399
 400         # Add the arguments to base_compile.
 401         if test -z "$base_compile"; then
 402           base_compile="$lastarg"
 403         else
 404           base_compile="$base_compile $lastarg"
 405         fi
 406         continue
 407         ;;
 408       esac
 409
 410       case $user_target in
 411       next)
 412         # The next one is the -o target name
 413         user_target=yes
 414         continue
 415         ;;
 416       yes)
 417         # We got the output file
 418         user_target=set
 419         libobj="$arg"
 420         continue
 421         ;;
 422       esac
 423
 424       # Accept the current argument as the source file.
 425       lastarg="$srcfile"
 426       srcfile="$arg"
 427
 428       # Aesthetically quote the previous argument.
 429
 430       # Backslashify any backslashes, double quotes, and dollar signs.
 431       # These are the only characters that are still specially
 432       # interpreted inside of double-quoted scrings.
 433       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
 434
 435       # Double-quote args containing other shell metacharacters.
 436       # Many Bourne shells cannot handle close brackets correctly
 437       # in scan sets, so we specify it separately.
 438       case $lastarg in
 439       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 440         lastarg="\"$lastarg\""
 441         ;;
 442       esac
 443
 444       # Add the previous argument to base_compile.
 445       if test -z "$base_compile"; then
 446         base_compile="$lastarg"
 447       else
 448         base_compile="$base_compile $lastarg"
 449       fi
 450     done
 451
 452     case $user_target in
 453     set)
 454       ;;
 455     no)
 456       # Get the name of the library object.
 457       libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
 458       ;;
 459     *)
 460       $echo "$modename: you must specify a target with \`-o'" 1>&2
 461       exit 1
 462       ;;
 463     esac
 464
 465     # Recognize several different file suffixes.
 466     # If the user specifies -o file.o, it is replaced with file.lo
 467     xform='[cCFSfmso]'
 468     case $libobj in
 469     *.ada) xform=ada ;;
 470     *.adb) xform=adb ;;
 471     *.ads) xform=ads ;;
 472     *.asm) xform=asm ;;
 473     *.c++) xform=c++ ;;
 474     *.cc) xform=cc ;;
 475     *.class) xform=class ;;
 476     *.cpp) xform=cpp ;;
 477     *.cxx) xform=cxx ;;
 478     *.f90) xform=f90 ;;
 479     *.for) xform=for ;;
 480     *.java) xform=java ;;
 481     esac
 482
 483     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
 484
 485     case $libobj in
 486     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
 487     *)
 488       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
 489       exit 1
 490       ;;
 491     esac
 492
 493     # Infer tagged configuration to use if any are available and
 494     # if one wasn't chosen via the "--tag" command line option.
 495     # Only attempt this if the compiler in the base compile
 496     # command doesn't match the default compiler.
 497     if test -n "$available_tags" && test -z "$tagname"; then
 498       case $base_compile in
 499       "$CC "*) ;;
 500       # Blanks in the command may have been stripped by the calling shell,
 501       # but not from the CC environment variable when ltconfig was run.
 502       "`$echo $CC` "*) ;;
 503       *)
 504         for z in $available_tags; do
 505           if grep "^### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
 506             # Evaluate the configuration.
 507             eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
 508             case $base_compile in
 509             "$CC "*)
 510               # The compiler in the base compile command matches
 511               # the one in the tagged configuration.
 512               # Assume this is the tagged configuration we want.
 513               tagname=$z
 514               break
 515               ;;
 516             "`$echo $CC` "*)
 517               tagname=$z
 518               break
 519               ;;
 520             esac
 521           fi
 522         done
 523         # If $tagname still isn't set, then no tagged configuration
 524         # was found and let the user know that the "--tag" command
 525         # line option must be used.
 526         if test -z "$tagname"; then
 527           echo "$modename: unable to infer tagged configuration"
 528           echo "$modename: specify a tag with \`--tag'" 1>&2
 529           exit 1
 530 #        else
 531 #          echo "$modename: using $tagname tagged configuration"
 532         fi
 533         ;;
 534       esac
 535     fi
 536
 537     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
 538     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
 539     if test "X$xdir" = "X$obj"; then
 540       xdir=
 541     else
 542       xdir=$xdir/
 543     fi
 544     lobj=${xdir}$objdir/$objname
 545
 546     if test -z "$base_compile"; then
 547       $echo "$modename: you must specify a compilation command" 1>&2
 548       $echo "$help" 1>&2
 549       exit 1
 550     fi
 551
 552     # Delete any leftover library objects.
 553     if test "$build_old_libs" = yes; then
 554       removelist="$obj $lobj $libobj ${libobj}T"
 555     else
 556       removelist="$lobj $libobj ${libobj}T"
 557     fi
 558
 559     $run $rm $removelist
 560     trap "$run $rm $removelist; exit 1" 1 2 15
 561
 562     # On Cygwin there's no "real" PIC flag so we must build both object types
 563     case $host_os in
 564     cygwin* | mingw* | pw32* | os2*)
 565       pic_mode=default
 566       ;;
 567     esac
 568     if test $pic_mode = no && test "$deplibs_check_method" != pass_all; then
 569       # non-PIC code in shared libraries is not supported
 570       pic_mode=default
 571     fi
 572
 573     # Calculate the filename of the output object if compiler does
 574     # not support -o with -c
 575     if test "$compiler_c_o" = no; then
 576       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
 577       lockfile="$output_obj.lock"
 578       removelist="$removelist $output_obj $lockfile"
 579       trap "$run $rm $removelist; exit 1" 1 2 15
 580     else
 581       output_obj=
 582       need_locks=no
 583       lockfile=
 584     fi
 585
 586     # Lock this critical section if it is needed
 587     # We use this script file to make the link, it avoids creating a new file
 588     if test "$need_locks" = yes; then
 589       until $run ln "$0" "$lockfile" 2>/dev/null; do
 590         $show "Waiting for $lockfile to be removed"
 591         sleep 2
 592       done
 593     elif test "$need_locks" = warn; then
 594       if test -f "$lockfile"; then
 595         echo "\
 596 *** ERROR, $lockfile exists and contains:
 597 `cat $lockfile 2>/dev/null`
 598
 599 This indicates that another process is trying to use the same
 600 temporary object file, and libtool could not work around it because
 601 your compiler does not support \`-c' and \`-o' together.  If you
 602 repeat this compilation, it may succeed, by chance, but you had better
 603 avoid parallel builds (make -j) in this platform, or get a better
 604 compiler."
 605
 606         $run $rm $removelist
 607         exit 1
 608       fi
 609       echo $srcfile > "$lockfile"
 610     fi
 611
 612     if test -n "$fix_srcfile_path"; then
 613       eval srcfile=\"$fix_srcfile_path\"
 614     fi
 615
 616     $run $rm "$libobj" "${libobj}T"
 617
 618     # Create a libtool object file (analogous to a ".la" file),
 619     # but don't create it if we're doing a dry run.
 620     test -z "$run" && cat > ${libobj}T <<EOF
 621 # $libobj - a libtool object file
 622 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 623 #
 624 # Please DO NOT delete this file!
 625 # It is necessary for linking the library.
 626
 627 # Name of the PIC object.
 628 EOF
 629
 630     # Only build a PIC object if we are building libtool libraries.
 631     if test "$build_libtool_libs" = yes; then
 632       # Without this assignment, base_compile gets emptied.
 633       fbsd_hideous_sh_bug=$base_compile
 634
 635       if test "$pic_mode" != no; then
 636         command="$base_compile $srcfile $pic_flag"
 637       else
 638         # Don't build PIC code
 639         command="$base_compile $srcfile"
 640       fi
 641
 642       if test ! -d ${xdir}$objdir; then
 643         $show "$mkdir ${xdir}$objdir"
 644         $run $mkdir ${xdir}$objdir
 645         status=$?
 646         if test $status -ne 0 && test ! -d ${xdir}$objdir; then
 647           exit $status
 648         fi
 649       fi
 650
 651       if test -z "$output_obj"; then
 652         # Place PIC objects in $objdir
 653         command="$command -o $lobj"
 654       fi
 655
 656       $run $rm "$lobj" "$output_obj"
 657
 658       $show "$command"
 659       if $run eval "$command"; then :
 660       else
 661         test -n "$output_obj" && $run $rm $removelist
 662         exit 1
 663       fi
 664
 665       if test "$need_locks" = warn &&
 666          test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
 667         echo "\
 668 *** ERROR, $lockfile contains:
 669 `cat $lockfile 2>/dev/null`
 670
 671 but it should contain:
 672 $srcfile
 673
 674 This indicates that another process is trying to use the same
 675 temporary object file, and libtool could not work around it because
 676 your compiler does not support \`-c' and \`-o' together.  If you
 677 repeat this compilation, it may succeed, by chance, but you had better
 678 avoid parallel builds (make -j) in this platform, or get a better
 679 compiler."
 680
 681         $run $rm $removelist
 682         exit 1
 683       fi
 684
 685       # Just move the object if needed, then go on to compile the next one
 686       if test -n "$output_obj" && test "x$output_obj" != "x$lobj"; then
 687         $show "$mv $output_obj $lobj"
 688         if $run $mv $output_obj $lobj; then :
 689         else
 690           error=$?
 691           $run $rm $removelist
 692           exit $error
 693         fi
 694       fi
 695
 696       # Append the name of the PIC object to the libtool object file.
 697       test -z "$run" && cat >> ${libobj}T <<EOF
 698 pic_object='$objdir/$objname'
 699
 700 EOF
 701
 702       # Allow error messages only from the first compilation.
 703       suppress_output=' >/dev/null 2>&1'
 704     else
 705       # No PIC object so indicate it doesn't exist in the libtool
 706       # object file.
 707       test -z "$run" && cat >> ${libobj}T <<EOF
 708 pic_object=none
 709
 710 EOF
 711     fi
 712
 713     # Only build a position-dependent object if we build old libraries.
 714     if test "$build_old_libs" = yes; then
 715       if test "$pic_mode" != yes; then
 716         # Don't build PIC code
 717         command="$base_compile $srcfile"
 718       else
 719         command="$base_compile $srcfile $pic_flag"
 720       fi
 721       if test "$compiler_c_o" = yes; then
 722         command="$command -o $obj"
 723       fi
 724
 725       # Suppress compiler output if we already did a PIC compilation.
 726       command="$command$suppress_output"
 727       $run $rm "$obj" "$output_obj"
 728       $show "$command"
 729       if $run eval "$command"; then :
 730       else
 731         $run $rm $removelist
 732         exit 1
 733       fi
 734
 735       if test "$need_locks" = warn &&
 736          test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
 737         echo "\
 738 *** ERROR, $lockfile contains:
 739 `cat $lockfile 2>/dev/null`
 740
 741 but it should contain:
 742 $srcfile
 743
 744 This indicates that another process is trying to use the same
 745 temporary object file, and libtool could not work around it because
 746 your compiler does not support \`-c' and \`-o' together.  If you
 747 repeat this compilation, it may succeed, by chance, but you had better
 748 avoid parallel builds (make -j) in this platform, or get a better
 749 compiler."
 750
 751         $run $rm $removelist
 752         exit 1
 753       fi
 754
 755       # Just move the object if needed
 756       if test -n "$output_obj" && test "x$output_obj" != "x$obj"; then
 757         $show "$mv $output_obj $obj"
 758         if $run $mv $output_obj $obj; then :
 759         else
 760           error=$?
 761           $run $rm $removelist
 762           exit $error
 763         fi
 764       fi
 765
 766       # Append the name of the non-PIC object the libtool object file.
 767       # Only append if the libtool object file exists.
 768       test -z "$run" && cat >> ${libobj}T <<EOF
 769 # Name of the non-PIC object.
 770 non_pic_object='$objname'
 771
 772 EOF
 773     else
 774       # Append the name of the non-PIC object the libtool object file.
 775       # Only append if the libtool object file exists.
 776       test -z "$run" && cat >> ${libobj}T <<EOF
 777 # Name of the non-PIC object.
 778 non_pic_object=none
 779
 780 EOF
 781     fi
 782
 783     $run $mv "${libobj}T" "${libobj}"
 784
 785     # Unlock the critical section if it was locked
 786     if test "$need_locks" != no; then
 787       $run $rm "$lockfile"
 788     fi
 789
 790     exit 0
 791     ;;
 792
 793   # libtool link mode
 794   link | relink)
 795     modename="$modename: link"
 796     case $host in
 797     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 798       # It is impossible to link a dll without this setting, and
 799       # we shouldn't force the makefile maintainer to figure out
 800       # which system we are compiling for in order to pass an extra
 801       # flag for every libtool invokation.
 802       # allow_undefined=no
 803
 804       # FIXME: Unfortunately, there are problems with the above when trying
 805       # to make a dll which has undefined symbols, in which case not
 806       # even a static library is built.  For now, we need to specify
 807       # -no-undefined on the libtool link line when we can be certain
 808       # that all symbols are satisfied, otherwise we get a static library.
 809       allow_undefined=yes
 810       ;;
 811     *)
 812       allow_undefined=yes
 813       ;;
 814     esac
 815     libtool_args="$nonopt"
 816     base_compile="$nonopt"
 817     compile_command="$nonopt"
 818     finalize_command="$nonopt"
 819
 820     compile_rpath=
 821     finalize_rpath=
 822     compile_shlibpath=
 823     finalize_shlibpath=
 824     convenience=
 825     old_convenience=
 826     deplibs=
 827     old_deplibs=
 828     compiler_flags=
 829     linker_flags=
 830     dllsearchpath=
 831     lib_search_path=`pwd`
 832
 833     avoid_version=no
 834     dlfiles=
 835     dlprefiles=
 836     dlself=no
 837     export_dynamic=no
 838     export_symbols=
 839     export_symbols_regex=
 840     generated=
 841     libobjs=
 842     ltlibs=
 843     module=no
 844     no_install=no
 845     objs=
 846     non_pic_objects=
 847     prefer_static_libs=no
 848     preload=no
 849     prev=
 850     prevarg=
 851     release=
 852     rpath=
 853     xrpath=
 854     perm_rpath=
 855     temp_rpath=
 856     thread_safe=no
 857     vinfo=
 858
 859     # We need to know -static, to get the right output filenames.
 860     for arg
 861     do
 862       case $arg in
 863       -all-static | -static)
 864         if test "X$arg" = "X-all-static"; then
 865           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
 866             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
 867           fi
 868           if test -n "$link_static_flag"; then
 869             dlopen_self=$dlopen_self_static
 870           fi
 871         else
 872           if test -z "$pic_flag" && test -n "$link_static_flag"; then
 873             dlopen_self=$dlopen_self_static
 874           fi
 875         fi
 876         build_libtool_libs=no
 877         build_old_libs=yes
 878         prefer_static_libs=yes
 879         break
 880         ;;
 881       esac
 882     done
 883
 884     # See if our shared archives depend on static archives.
 885     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
 886
 887     # Go through the arguments, transforming them on the way.
 888     while test $# -gt 0; do
 889       arg="$1"
 890       base_compile="$base_compile $arg"
 891       shift
 892       case $arg in
 893       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 894         qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
 895         ;;
 896       *) qarg=$arg ;;
 897       esac
 898       libtool_args="$libtool_args $qarg"
 899
 900       # If the previous option needs an argument, assign it.
 901       if test -n "$prev"; then
 902         case $prev in
 903         output)
 904           compile_command="$compile_command @OUTPUT@"
 905           finalize_command="$finalize_command @OUTPUT@"
 906           ;;
 907         esac
 908
 909         case $prev in
 910         dlfiles|dlprefiles)
 911           if test "$preload" = no; then
 912             # Add the symbol object into the linking commands.
 913             compile_command="$compile_command @SYMFILE@"
 914             finalize_command="$finalize_command @SYMFILE@"
 915             preload=yes
 916           fi
 917           case $arg in
 918           *.la | *.lo) ;;  # We handle these cases below.
 919           force)
 920             if test "$dlself" = no; then
 921               dlself=needless
 922               export_dynamic=yes
 923             fi
 924             prev=
 925             continue
 926             ;;
 927           self)
 928             if test "$prev" = dlprefiles; then
 929               dlself=yes
 930             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
 931               dlself=yes
 932             else
 933               dlself=needless
 934               export_dynamic=yes
 935             fi
 936             prev=
 937             continue
 938             ;;
 939           *)
 940             if test "$prev" = dlfiles; then
 941               dlfiles="$dlfiles $arg"
 942             else
 943               dlprefiles="$dlprefiles $arg"
 944             fi
 945             prev=
 946             continue
 947             ;;
 948           esac
 949           ;;
 950         expsyms)
 951           export_symbols="$arg"
 952           if test ! -f "$arg"; then
 953             $echo "$modename: symbol file \`$arg' does not exist"
 954             exit 1
 955           fi
 956           prev=
 957           continue
 958           ;;
 959         expsyms_regex)
 960           export_symbols_regex="$arg"
 961           prev=
 962           continue
 963           ;;
 964         release)
 965           release="-$arg"
 966           prev=
 967           continue
 968           ;;
 969         objectlist)
 970           if test -f "$arg"; then
 971             save_arg=$arg
 972             moreargs=
 973             for fil in `cat $save_arg`
 974             do
 975 #             moreargs="$moreargs $fil"
 976               arg=$fil
 977               # A libtool-controlled object.
 978
 979               # Check to see that this really is a libtool object.
 980               if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 981                 pic_object=
 982                 non_pic_object=
 983
 984                 # Read the .lo file
 985                 # If there is no directory component, then add one.
 986                 case $arg in
 987                 */* | *\\*) . $arg ;;
 988                 *) . ./$arg ;;
 989                 esac
 990
 991                 if test -z "$pic_object" || \
 992                    test -z "$non_pic_object" ||
 993                    test "$pic_object" = none && \
 994                    test "$non_pic_object" = none; then
 995                   $echo "$modename: cannot find name of object for \`$arg'" 1>&2
 996                   exit 1
 997                 fi
 998
 999                 # Extract subdirectory from the argument.
1000                 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1001                 if test "X$xdir" = "X$arg"; then
1002                   xdir=
1003                 else
1004                   xdir="$xdir/"
1005                 fi
1006
1007                 if test "$pic_object" != none; then
1008                   # Prepend the subdirectory the object is found in.
1009                   pic_object="$xdir$pic_object"
1010
1011                   if test "$prev" = dlfiles; then
1012                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1013                       dlfiles="$dlfiles $pic_object"
1014                       prev=
1015                       continue
1016                     else
1017                       # If libtool objects are unsupported, then we need to preload.
1018                       prev=dlprefiles
1019                     fi
1020                   fi
1021
1022                   # CHECK ME:  I think I busted this.  -Ossama
1023                   if test "$prev" = dlprefiles; then
1024                     # Preload the old-style object.
1025                     dlprefiles="$dlprefiles $pic_object"
1026                     prev=
1027                   fi
1028
1029                   # A PIC object.
1030                   libobjs="$libobjs $pic_object"
1031                   arg="$pic_object"
1032                 fi
1033
1034                 # Non-PIC object.
1035                 if test "$non_pic_object" != none; then
1036                   # Prepend the subdirectory the object is found in.
1037                   non_pic_object="$xdir$non_pic_object"
1038
1039                   # A standard non-PIC object
1040                   non_pic_objects="$non_pic_objects $non_pic_object"
1041                   if test -z "$pic_object" || test "$pic_object" = none ; then
1042                     arg="$non_pic_object"
1043                   fi
1044                 else
1045                   # If the PIC object exists, use it instead.
1046                   # $xdir was prepended to $pic_object above.
1047                   non_pic_object="$pic_object"
1048                   non_pic_objects="$non_pic_objects $non_pic_object"
1049                 fi
1050               else
1051                 # Only an error if not doing a dry-run.
1052                 if test -z "$run"; then
1053                   $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1054                   exit 1
1055                 else
1056                   # Dry-run case.
1057
1058                   # Extract subdirectory from the argument.
1059                   xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1060                   if test "X$xdir" = "X$arg"; then
1061                     xdir=
1062                   else
1063                     xdir="$xdir/"
1064                   fi
1065
1066                   pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1067                   non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1068                   libobjs="$libobjs $pic_object"
1069                   non_pic_objects="$non_pic_objects $non_pic_object"
1070                 fi
1071               fi
1072             done
1073           else
1074             $echo "$modename: link input file \`$save_arg' does not exist"
1075             exit 1
1076           fi
1077           arg=$save_arg
1078           prev=
1079           continue
1080           ;;
1081         rpath | xrpath)
1082           # We need an absolute path.
1083           case $arg in
1084           [\\/]* | [A-Za-z]:[\\/]*) ;;
1085           *)
1086             $echo "$modename: only absolute run-paths are allowed" 1>&2
1087             exit 1
1088             ;;
1089           esac
1090           if test "$prev" = rpath; then
1091             case "$rpath " in
1092             *" $arg "*) ;;
1093             *) rpath="$rpath $arg" ;;
1094             esac
1095           else
1096             case "$xrpath " in
1097             *" $arg "*) ;;
1098             *) xrpath="$xrpath $arg" ;;
1099             esac
1100           fi
1101           prev=
1102           continue
1103           ;;
1104         xcompiler)
1105           compiler_flags="$compiler_flags $qarg"
1106           prev=
1107           compile_command="$compile_command $qarg"
1108           finalize_command="$finalize_command $qarg"
1109           continue
1110           ;;
1111         xlinker)
1112           linker_flags="$linker_flags $qarg"
1113           compiler_flags="$compiler_flags $wl$qarg"
1114           prev=
1115           compile_command="$compile_command $wl$qarg"
1116           finalize_command="$finalize_command $wl$qarg"
1117           continue
1118           ;;
1119         framework)
1120           case $host in
1121            *-*-darwin*)
1122              case "$deplibs " in
1123                *" $qarg.framework "*) ;;
1124                *) deplibs="$deplibs $qarg.framework" # this is fixed later
1125                   ;;
1126              esac
1127              ;;
1128           esac
1129           prev=
1130           continue
1131           ;;
1132         *)
1133           eval "$prev=\"\$arg\""
1134           prev=
1135           continue
1136           ;;
1137         esac
1138       fi # test -n $prev
1139
1140       prevarg="$arg"
1141
1142       case $arg in
1143       -all-static)
1144         if test -n "$link_static_flag"; then
1145           compile_command="$compile_command $link_static_flag"
1146           finalize_command="$finalize_command $link_static_flag"
1147         fi
1148         continue
1149         ;;
1150
1151       -allow-undefined)
1152         # FIXME: remove this flag sometime in the future.
1153         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1154         continue
1155         ;;
1156
1157       -avoid-version)
1158         avoid_version=yes
1159         continue
1160         ;;
1161
1162       -dlopen)
1163         prev=dlfiles
1164         continue
1165         ;;
1166
1167       -dlpreopen)
1168         prev=dlprefiles
1169         continue
1170         ;;
1171
1172       -export-dynamic)
1173         export_dynamic=yes
1174         continue
1175         ;;
1176
1177       -export-symbols | -export-symbols-regex)
1178         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1179           $echo "$modename: more than one -exported-symbols argument is not allowed"
1180           exit 1
1181         fi
1182         if test "X$arg" = "X-export-symbols"; then
1183           prev=expsyms
1184         else
1185           prev=expsyms_regex
1186         fi
1187         continue
1188         ;;
1189
1190       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1191       # so, if we see these flags be careful not to treat them like -L
1192       -L[A-Z][A-Z]*:*)
1193         case $with_gcc/$host in
1194         no/*-*-irix*)
1195           compile_command="$compile_command $arg"
1196           finalize_command="$finalize_command $arg"
1197           ;;
1198         esac
1199         continue
1200         ;;
1201
1202       -L*)
1203         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1204         # We need an absolute path.
1205         case $dir in
1206         [\\/]* | [A-Za-z]:[\\/]*) ;;
1207         *)
1208           absdir=`cd "$dir" && pwd`
1209           if test -z "$absdir"; then
1210             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1211             exit 1
1212           fi
1213           dir="$absdir"
1214           ;;
1215         esac
1216         case "$deplibs " in
1217         *" -L$dir "*) ;;
1218         *)
1219           deplibs="$deplibs -L$dir"
1220           lib_search_path="$lib_search_path $dir"
1221           ;;
1222         esac
1223         case $host in
1224         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1225           case :$dllsearchpath: in
1226           *":$dir:"*) ;;
1227           *) dllsearchpath="$dllsearchpath:$dir";;
1228           esac
1229           ;;
1230         esac
1231         continue
1232         ;;
1233
1234       -l*)
1235         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1236           case $host in
1237           *-*-cygwin* | *-*-pw32* | *-*-beos*)
1238             # These systems don't actually have a C or math library (as such)
1239             continue
1240             ;;
1241           *-*-mingw* | *-*-os2*)
1242             # These systems don't actually have a C library (as such)
1243             test "X$arg" = "X-lc" && continue
1244             ;;
1245           esac
1246         fi
1247         deplibs="$deplibs $arg"
1248         continue
1249         ;;
1250
1251       -module)
1252         module=yes
1253         continue
1254         ;;
1255
1256       -no-fast-install)
1257         fast_install=no
1258         continue
1259         ;;
1260
1261       -no-install)
1262         case $host in
1263         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1264           # The PATH hackery in wrapper scripts is required on Windows
1265           # in order for the loader to find any dlls it needs.
1266           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1267           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1268           fast_install=no
1269           ;;
1270         *) no_install=yes ;;
1271         esac
1272         continue
1273         ;;
1274
1275       -no-undefined)
1276         allow_undefined=no
1277         continue
1278         ;;
1279
1280       -objectlist)
1281         prev=objectlist
1282         continue
1283         ;;
1284
1285       -o) prev=output ;;
1286
1287       -release)
1288         prev=release
1289         continue
1290         ;;
1291
1292       -rpath)
1293         prev=rpath
1294         continue
1295         ;;
1296
1297       -R)
1298         prev=xrpath
1299         continue
1300         ;;
1301
1302       -R*)
1303         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1304         # We need an absolute path.
1305         case $dir in
1306         [\\/]* | [A-Za-z]:[\\/]*) ;;
1307         *)
1308           $echo "$modename: only absolute run-paths are allowed" 1>&2
1309           exit 1
1310           ;;
1311         esac
1312         case "$xrpath " in
1313         *" $dir "*) ;;
1314         *) xrpath="$xrpath $dir" ;;
1315         esac
1316         continue
1317         ;;
1318
1319       -static)
1320         # The effects of -static are defined in a previous loop.
1321         # We used to do the same as -all-static on platforms that
1322         # didn't have a PIC flag, but the assumption that the effects
1323         # would be equivalent was wrong.  It would break on at least
1324         # Digital Unix and AIX.
1325         continue
1326         ;;
1327
1328       -thread-safe)
1329         thread_safe=yes
1330         continue
1331         ;;
1332
1333       -version-info)
1334         prev=vinfo
1335         continue
1336         ;;
1337
1338       -Wc,*)
1339         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1340         arg=
1341         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
1342         for flag in $args; do
1343           IFS="$save_ifs"
1344           case $flag in
1345             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1346             flag="\"$flag\""
1347             ;;
1348           esac
1349           arg="$arg $wl$flag"
1350           compiler_flags="$compiler_flags $flag"
1351         done
1352         IFS="$save_ifs"
1353         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1354         ;;
1355
1356       -Wl,*)
1357         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1358         arg=
1359         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
1360         for flag in $args; do
1361           IFS="$save_ifs"
1362           case $flag in
1363             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1364             flag="\"$flag\""
1365             ;;
1366           esac
1367           arg="$arg $wl$flag"
1368           compiler_flags="$compiler_flags $wl$flag"
1369           linker_flags="$linker_flags $flag"
1370         done
1371         IFS="$save_ifs"
1372         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1373         ;;
1374
1375       -Xcompiler)
1376         prev=xcompiler
1377         continue
1378         ;;
1379
1380       -Xlinker)
1381         prev=xlinker
1382         continue
1383         ;;
1384       -framework)
1385         prev=framework
1386         continue
1387         ;;
1388
1389       # Some other compiler flag.
1390       -* | +*)
1391         # Unknown arguments in both finalize_command and compile_command need
1392         # to be aesthetically quoted because they are evaled later.
1393         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1394         case $arg in
1395         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1396           arg="\"$arg\""
1397           ;;
1398         esac
1399         ;;
1400
1401       *.$objext)
1402         # A standard object.
1403         objs="$objs $arg"
1404         ;;
1405
1406       *.lo)
1407         # A libtool-controlled object.
1408
1409         # Check to see that this really is a libtool object.
1410         if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1411           pic_object=
1412           non_pic_object=
1413
1414           # Read the .lo file
1415           # If there is no directory component, then add one.
1416           case $arg in
1417           */* | *\\*) . $arg ;;
1418           *) . ./$arg ;;
1419           esac
1420
1421           if test -z "$pic_object" || \
1422              test -z "$non_pic_object" ||
1423              test "$pic_object" = none && \
1424              test "$non_pic_object" = none; then
1425             $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1426             exit 1
1427           fi
1428
1429           # Extract subdirectory from the argument.
1430           xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1431           if test "X$xdir" = "X$arg"; then
1432             xdir=
1433           else
1434             xdir="$xdir/"
1435           fi
1436
1437           if test "$pic_object" != none; then
1438             # Prepend the subdirectory the object is found in.
1439             pic_object="$xdir$pic_object"
1440
1441             if test "$prev" = dlfiles; then
1442               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1443                 dlfiles="$dlfiles $pic_object"
1444                 prev=
1445                 continue
1446               else
1447                 # If libtool objects are unsupported, then we need to preload.
1448                 prev=dlprefiles
1449               fi
1450             fi
1451
1452             # CHECK ME:  I think I busted this.  -Ossama
1453             if test "$prev" = dlprefiles; then
1454               # Preload the old-style object.
1455               dlprefiles="$dlprefiles $pic_object"
1456               prev=
1457             fi
1458
1459             # A PIC object.
1460             libobjs="$libobjs $pic_object"
1461             arg="$pic_object"
1462           fi
1463
1464           # Non-PIC object.
1465           if test "$non_pic_object" != none; then
1466             # Prepend the subdirectory the object is found in.
1467             non_pic_object="$xdir$non_pic_object"
1468
1469             # A standard non-PIC object
1470             non_pic_objects="$non_pic_objects $non_pic_object"
1471             if test -z "$pic_object" || test "$pic_object" = none ; then
1472               arg="$non_pic_object"
1473             fi
1474           else
1475             # If the PIC object exists, use it instead.
1476             # $xdir was prepended to $pic_object above.
1477             non_pic_object="$pic_object"
1478             non_pic_objects="$non_pic_objects $non_pic_object"
1479           fi
1480         else
1481           # Only an error if not doing a dry-run.
1482           if test -z "$run"; then
1483             $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1484             exit 1
1485           else
1486             # Dry-run case.
1487
1488             # Extract subdirectory from the argument.
1489             xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1490             if test "X$xdir" = "X$arg"; then
1491               xdir=
1492             else
1493               xdir="$xdir/"
1494             fi
1495
1496             pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1497             non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1498             libobjs="$libobjs $pic_object"
1499             non_pic_objects="$non_pic_objects $non_pic_object"
1500           fi
1501         fi
1502         ;;
1503
1504       *.$libext)
1505         # An archive.
1506         deplibs="$deplibs $arg"
1507         old_deplibs="$old_deplibs $arg"
1508         continue
1509         ;;
1510
1511       *.la)
1512         # A libtool-controlled library.
1513
1514         if test "$prev" = dlfiles; then
1515           # This library was specified with -dlopen.
1516           dlfiles="$dlfiles $arg"
1517           prev=
1518         elif test "$prev" = dlprefiles; then
1519           # The library was specified with -dlpreopen.
1520           dlprefiles="$dlprefiles $arg"
1521           prev=
1522         else
1523           deplibs="$deplibs $arg"
1524         fi
1525         continue
1526         ;;
1527
1528       # Some other compiler argument.
1529       *)
1530         # Unknown arguments in both finalize_command and compile_command need
1531         # to be aesthetically quoted because they are evaled later.
1532         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1533         case $arg in
1534         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1535           arg="\"$arg\""
1536           ;;
1537         esac
1538         ;;
1539       esac # arg
1540
1541       # Now actually substitute the argument into the commands.
1542       if test -n "$arg"; then
1543         compile_command="$compile_command $arg"
1544         finalize_command="$finalize_command $arg"
1545       fi
1546     done # argument parsing loop
1547
1548     if test -n "$prev"; then
1549       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1550       $echo "$help" 1>&2
1551       exit 1
1552     fi
1553
1554     # Infer tagged configuration to use if any are available and
1555     # if one wasn't chosen via the "--tag" command line option.
1556     # Only attempt this if the compiler in the base link
1557     # command doesn't match the default compiler.
1558     if test -n "$available_tags" && test -z "$tagname"; then
1559       case $base_compile in
1560       "$CC "*) ;;
1561       # Blanks in the command may have been stripped by the calling shell,
1562       # but not from the CC environment variable when ltconfig was run.
1563       "`$echo $CC` "*) ;;
1564       *)
1565         for z in $available_tags; do
1566           if grep "^### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
1567             # Evaluate the configuration.
1568             eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
1569             case $base_compile in
1570             "$CC "*)
1571               # The compiler in $compile_command matches
1572               # the one in the tagged configuration.
1573               # Assume this is the tagged configuration we want.
1574               tagname=$z
1575               break
1576               ;;
1577             "`$echo $CC` "*)
1578               tagname=$z
1579               break
1580               ;;
1581             esac
1582           fi
1583         done
1584         # If $tagname still isn't set, then no tagged configuration
1585         # was found and let the user know that the "--tag" command
1586         # line option must be used.
1587         if test -z "$tagname"; then
1588           echo "$modename: unable to infer tagged configuration"
1589           echo "$modename: specify a tag with \`--tag'" 1>&2
1590           exit 1
1591 #       else
1592 #         echo "$modename: using $tagname tagged configuration"
1593         fi
1594         ;;
1595       esac
1596     fi
1597
1598     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1599       eval arg=\"$export_dynamic_flag_spec\"
1600       compile_command="$compile_command $arg"
1601       finalize_command="$finalize_command $arg"
1602     fi
1603
1604     # calculate the name of the file, without its directory
1605     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1606     libobjs_save="$libobjs"
1607
1608     if test -n "$shlibpath_var"; then
1609       # get the directories listed in $shlibpath_var
1610       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1611     else
1612       shlib_search_path=
1613     fi
1614     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1615     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1616
1617     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1618     if test "X$output_objdir" = "X$output"; then
1619       output_objdir="$objdir"
1620     else
1621       output_objdir="$output_objdir/$objdir"
1622     fi
1623     # Create the object directory.
1624     if test ! -d $output_objdir; then
1625       $show "$mkdir $output_objdir"
1626       $run $mkdir $output_objdir
1627       status=$?
1628       if test $status -ne 0 && test ! -d $output_objdir; then
1629         exit $status
1630       fi
1631     fi
1632
1633     # Determine the type of output
1634     case $output in
1635     "")
1636       $echo "$modename: you must specify an output file" 1>&2
1637       $echo "$help" 1>&2
1638       exit 1
1639       ;;
1640     *.$libext) linkmode=oldlib ;;
1641     *.lo | *.$objext) linkmode=obj ;;
1642     *.la) linkmode=lib ;;
1643     *) linkmode=prog ;; # Anything else should be a program.
1644     esac
1645
1646     specialdeplibs=
1647     libs=
1648     # Find all interdependent deplibs by searching for libraries
1649     # that are linked more than once (e.g. -la -lb -la)
1650     for deplib in $deplibs; do
1651       case "$libs " in
1652       *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1653       esac
1654       libs="$libs $deplib"
1655     done
1656
1657     if test $linkmode = lib; then
1658       libs="$predeps $libs $compiler_lib_search_path $postdeps"
1659
1660       # Compute libraries that are listed more than once in $predeps
1661       # $postdeps and mark them as special (i.e., whose duplicates are
1662       # not to be eliminated).
1663       pre_post_deps=
1664       for pre_post_dep in $predeps $postdeps; do
1665         case "$pre_post_deps " in
1666         *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1667         esac
1668         pre_post_deps="$pre_post_deps $pre_post_dep"
1669       done
1670       pre_post_deps=
1671     fi
1672
1673     deplibs=
1674     newdependency_libs=
1675     newlib_search_path=
1676     need_relink=no # whether we're linking any uninstalled libtool libraries
1677     notinst_deplibs= # not-installed libtool libraries
1678     notinst_path= # paths that contain not-installed libtool libraries
1679     case $linkmode in
1680     lib)
1681         passes="conv link"
1682         for file in $dlfiles $dlprefiles; do
1683           case $file in
1684           *.la) ;;
1685           *)
1686             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1687             exit 1
1688             ;;
1689           esac
1690         done
1691         ;;
1692     prog)
1693         compile_deplibs=
1694         finalize_deplibs=
1695         alldeplibs=no
1696         newdlfiles=
1697         newdlprefiles=
1698         passes="conv scan dlopen dlpreopen link"
1699         ;;
1700     *)  passes="conv"
1701         ;;
1702     esac
1703     for pass in $passes; do
1704       if test $linkmode = prog; then
1705         # Determine which files to process
1706         case $pass in
1707         dlopen)
1708           libs="$dlfiles"
1709           save_deplibs="$deplibs" # Collect dlpreopened libraries
1710           deplibs=
1711           ;;
1712         dlpreopen) libs="$dlprefiles" ;;
1713         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1714         esac
1715       fi
1716       for deplib in $libs; do
1717         lib=
1718         found=no
1719         case $deplib in
1720         -l*)
1721           if test $linkmode = oldlib && test $linkmode = obj; then
1722             $echo "$modename: warning: \`-l' is ignored for archives/objects: $deplib" 1>&2
1723             continue
1724           fi
1725           if test $pass = conv; then
1726             deplibs="$deplib $deplibs"
1727             continue
1728           fi
1729           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1730           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1731             # Search the libtool library
1732             lib="$searchdir/lib${name}.la"
1733             if test -f "$lib"; then
1734               found=yes
1735               break
1736             fi
1737           done
1738           if test "$found" != yes; then
1739             # deplib doesn't seem to be a libtool library
1740             if test "$linkmode,$pass" = "prog,link"; then
1741               compile_deplibs="$deplib $compile_deplibs"
1742               finalize_deplibs="$deplib $finalize_deplibs"
1743             else
1744               deplibs="$deplib $deplibs"
1745               test $linkmode = lib && newdependency_libs="$deplib $newdependency_libs"
1746             fi
1747             continue
1748           fi
1749           ;; # -l
1750         -L*)
1751           case $linkmode in
1752           lib)
1753             deplibs="$deplib $deplibs"
1754             test $pass = conv && continue
1755             newdependency_libs="$deplib $newdependency_libs"
1756             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1757             ;;
1758           prog)
1759             if test $pass = conv; then
1760               deplibs="$deplib $deplibs"
1761               continue
1762             fi
1763             if test $pass = scan; then
1764               deplibs="$deplib $deplibs"
1765               newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1766             else
1767               compile_deplibs="$deplib $compile_deplibs"
1768               finalize_deplibs="$deplib $finalize_deplibs"
1769             fi
1770             ;;
1771           *)
1772             $echo "$modename: warning: \`-L' is ignored for archives/objects: $deplib" 1>&2
1773             ;;
1774           esac # linkmode
1775           continue
1776           ;; # -L
1777         -R*)
1778           if test $pass = link; then
1779             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1780             # Make sure the xrpath contains only unique directories.
1781             case "$xrpath " in
1782             *" $dir "*) ;;
1783             *) xrpath="$xrpath $dir" ;;
1784             esac
1785           fi
1786           deplibs="$deplib $deplibs"
1787           continue
1788           ;;
1789         *.la) lib="$deplib" ;;
1790         *.$libext)
1791           if test $pass = conv; then
1792             deplibs="$deplib $deplibs"
1793             continue
1794           fi
1795           case $linkmode in
1796           lib)
1797             if test "$deplibs_check_method" != pass_all; then
1798               echo
1799               echo "*** Warning: This library needs some functionality provided by $deplib."
1800               echo "*** I have the capability to make that library automatically link in when"
1801               echo "*** you link to this library.  But I can only do this if you have a"
1802               echo "*** shared version of the library, which you do not appear to have."
1803             else
1804               echo
1805               echo "*** Warning: Linking the shared library $output against the"
1806               echo "*** static library $deplib is not portable!"
1807               deplibs="$deplib $deplibs"
1808             fi
1809             continue
1810             ;;
1811           prog)
1812             if test $pass != link; then
1813               deplibs="$deplib $deplibs"
1814             else
1815               compile_deplibs="$deplib $compile_deplibs"
1816               finalize_deplibs="$deplib $finalize_deplibs"
1817             fi
1818             continue
1819             ;;
1820           esac # linkmode
1821           ;; # *.$libext
1822         *.lo | *.$objext)
1823           if test $pass = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1824             # If there is no dlopen support or we're linking statically,
1825             # we need to preload.
1826             newdlprefiles="$newdlprefiles $deplib"
1827             compile_deplibs="$deplib $compile_deplibs"
1828             finalize_deplibs="$deplib $finalize_deplibs"
1829           else
1830             newdlfiles="$newdlfiles $deplib"
1831           fi
1832           continue
1833           ;;
1834         %DEPLIBS%)
1835           alldeplibs=yes
1836           continue
1837           ;;
1838         esac # case $deplib
1839         if test $found = yes || test -f "$lib"; then :
1840         else
1841           $echo "$modename: cannot find the library \`$lib'" 1>&2
1842           exit 1
1843         fi
1844
1845         # Check to see that this really is a libtool archive.
1846         if (sed -e '2q' $lib | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
1847         else
1848           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
1849           exit 1
1850         fi
1851
1852         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1853         test "X$ladir" = "X$lib" && ladir="."
1854
1855         dlname=
1856         dlopen=
1857         dlpreopen=
1858         libdir=
1859         library_names=
1860         old_library=
1861         # If the library was installed with an old release of libtool,
1862         # it will not redefine variable installed.
1863         installed=yes
1864
1865         # Read the .la file
1866         case $lib in
1867         */* | *\\*) . $lib ;;
1868         *) . ./$lib ;;
1869         esac
1870
1871         case $host in
1872             *-*-darwin*)
1873           # Convert "-framework foo" to "foo.framework" in dependency_libs
1874                 test -n "$dependency_libs" && dependency_libs=`$echo "X$dependency_libs" | $Xsed -e 's/-framework \([^ $]*\)/\1.framework/g'`
1875                 ;;
1876         esac
1877
1878         if test "$linkmode,$pass" = "lib,link" ||
1879            test "$linkmode,$pass" = "prog,scan" ||
1880            { test $linkmode = oldlib && test $linkmode = obj; }; then
1881            # Add dl[pre]opened files of deplib
1882           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
1883           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
1884         fi
1885
1886         if test $pass = conv; then
1887           # Only check for convenience libraries
1888           deplibs="$lib $deplibs"
1889           if test -z "$libdir"; then
1890             if test -z "$old_library"; then
1891               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1892               exit 1
1893             fi
1894             # It is a libtool convenience library, so add in its objects.
1895             convenience="$convenience $ladir/$objdir/$old_library"
1896             old_convenience="$old_convenience $ladir/$objdir/$old_library"
1897             tmp_libs=
1898             for deplib in $dependency_libs; do
1899               deplibs="$deplib $deplibs"
1900               case "$tmp_libs " in
1901               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1902               esac
1903               tmp_libs="$tmp_libs $deplib"
1904             done
1905           elif test $linkmode != prog && test $linkmode != lib; then
1906             $echo "$modename: \`$lib' is not a convenience library" 1>&2
1907             exit 1
1908           fi
1909           continue
1910         fi # $pass = conv
1911
1912         # Get the name of the library we link against.
1913         linklib=
1914         for l in $old_library $library_names; do
1915           linklib="$l"
1916         done
1917         if test -z "$linklib"; then
1918           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1919           exit 1
1920         fi
1921
1922         # This library was specified with -dlopen.
1923         if test $pass = dlopen; then
1924           if test -z "$libdir"; then
1925             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
1926             exit 1
1927           fi
1928           if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1929             # If there is no dlname, no dlopen support or we're linking
1930             # statically, we need to preload.
1931             dlprefiles="$dlprefiles $lib"
1932           else
1933             newdlfiles="$newdlfiles $lib"
1934           fi
1935           continue
1936         fi # $pass = dlopen
1937
1938         # We need an absolute path.
1939         case $ladir in
1940         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
1941         *)
1942           abs_ladir=`cd "$ladir" && pwd`
1943           if test -z "$abs_ladir"; then
1944             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
1945             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
1946             abs_ladir="$ladir"
1947           fi
1948           ;;
1949         esac
1950         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
1951
1952         # Find the relevant object directory and library name.
1953         if test "X$installed" = Xyes; then
1954           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
1955             $echo "$modename: warning: library \`$lib' was moved." 1>&2
1956             dir="$ladir"
1957             absdir="$abs_ladir"
1958             libdir="$abs_ladir"
1959           else
1960             dir="$libdir"
1961             absdir="$libdir"
1962           fi
1963         else
1964           dir="$ladir/$objdir"
1965           absdir="$abs_ladir/$objdir"
1966           # Remove this search path later
1967           notinst_path="$notinst_path $abs_ladir"
1968         fi # $installed = yes
1969         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
1970
1971         # This library was specified with -dlpreopen.
1972         if test $pass = dlpreopen; then
1973           if test -z "$libdir"; then
1974             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
1975             exit 1
1976           fi
1977           # Prefer using a static library (so that no silly _DYNAMIC symbols
1978           # are required to link).
1979           if test -n "$old_library"; then
1980             newdlprefiles="$newdlprefiles $dir/$old_library"
1981           # Otherwise, use the dlname, so that lt_dlopen finds it.
1982           elif test -n "$dlname"; then
1983             newdlprefiles="$newdlprefiles $dir/$dlname"
1984           else
1985             newdlprefiles="$newdlprefiles $dir/$linklib"
1986           fi
1987         fi # $pass = dlpreopen
1988
1989         if test -z "$libdir"; then
1990           # Link the convenience library
1991           if test $linkmode = lib; then
1992             deplibs="$dir/$old_library $deplibs"
1993           elif test "$linkmode,$pass" = "prog,link"; then
1994             compile_deplibs="$dir/$old_library $compile_deplibs"
1995             finalize_deplibs="$dir/$old_library $finalize_deplibs"
1996           else
1997             deplibs="$lib $deplibs"
1998           fi
1999           continue
2000         fi
2001
2002         if test $linkmode = prog && test $pass != link; then
2003           newlib_search_path="$newlib_search_path $ladir"
2004           deplibs="$lib $deplibs"
2005
2006           linkalldeplibs=no
2007           if test "$link_all_deplibs" != no || test -z "$library_names" ||
2008              test "$build_libtool_libs" = no; then
2009             linkalldeplibs=yes
2010           fi
2011
2012           tmp_libs=
2013           for deplib in $dependency_libs; do
2014             case $deplib in
2015             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2016             esac
2017             # Need to link against all dependency_libs?
2018             if test $linkalldeplibs = yes; then
2019               deplibs="$deplib $deplibs"
2020             else
2021               # Need to hardcode shared library paths
2022               # or/and link against static libraries
2023               newdependency_libs="$deplib $newdependency_libs"
2024             fi
2025             case "$tmp_libs " in
2026             *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2027             esac
2028             tmp_libs="$tmp_libs $deplib"
2029           done # for deplib
2030           continue
2031         fi # $linkmode = prog...
2032
2033         link_static=no # Whether the deplib will be linked statically
2034         if test -n "$library_names" &&
2035            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2036           # Link against this shared library
2037
2038           if test "$linkmode,$pass" = "prog,link" ||
2039            { test $linkmode = lib && test $hardcode_into_libs = yes; }; then
2040             # Hardcode the library path.
2041             # Skip directories that are in the system default run-time
2042             # search path.
2043             case " $sys_lib_dlsearch_path " in
2044             *" $absdir "*) ;;
2045             *)
2046               case "$compile_rpath " in
2047               *" $absdir "*) ;;
2048               *) compile_rpath="$compile_rpath $absdir"
2049               esac
2050               ;;
2051             esac
2052             case " $sys_lib_dlsearch_path " in
2053             *" $libdir "*) ;;
2054             *)
2055               case "$finalize_rpath " in
2056               *" $libdir "*) ;;
2057               *) finalize_rpath="$finalize_rpath $libdir"
2058               esac
2059               ;;
2060             esac
2061             if test $linkmode = prog; then
2062               # We need to hardcode the library path
2063               if test -n "$shlibpath_var"; then
2064                 # Make sure the rpath contains only unique directories.
2065                 case "$temp_rpath " in
2066                 *" $dir "*) ;;
2067                 *" $absdir "*) ;;
2068                 *) temp_rpath="$temp_rpath $dir" ;;
2069                 esac
2070               fi
2071             fi
2072           fi # $linkmode,$pass = prog,link...
2073
2074           if test "$alldeplibs" = yes &&
2075              { test "$deplibs_check_method" = pass_all ||
2076                { test "$build_libtool_libs" = yes &&
2077                  test -n "$library_names"; }; }; then
2078             # We only need to search for static libraries
2079             continue
2080           fi
2081
2082           if test "$installed" = no; then
2083             notinst_deplibs="$notinst_deplibs $lib"
2084             need_relink=yes
2085           fi
2086
2087           if test -n "$old_archive_from_expsyms_cmds"; then
2088             # figure out the soname
2089             set dummy $library_names
2090             realname="$2"
2091             shift; shift
2092             libname=`eval \\$echo \"$libname_spec\"`
2093             # use dlname if we got it. it's perfectly good, no?
2094             if test -n "$dlname"; then
2095               soname="$dlname"
2096             elif test -n "$soname_spec"; then
2097               # bleh windows
2098               case $host in
2099               *cygwin*)
2100                 major=`expr $current - $age`
2101                 versuffix="-$major"
2102                 ;;
2103               esac
2104               eval soname=\"$soname_spec\"
2105             else
2106               soname="$realname"
2107             fi
2108
2109             # Make a new name for the extract_expsyms_cmds to use
2110             soroot="$soname"
2111             soname=`echo $soroot | sed -e 's/^.*\///'`
2112             newlib="libimp-`echo $soname | sed 's/^lib//;s/\.dll$//'`.a"
2113
2114             # If the library has no export list, then create one now
2115             if test -f "$output_objdir/$soname-def"; then :
2116             else
2117               $show "extracting exported symbol list from \`$soname'"
2118               IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2119               cmds=$extract_expsyms_cmds
2120               for cmd in $cmds; do
2121                 IFS="$save_ifs"
2122                 eval cmd=\"$cmd\"
2123                 $show "$cmd"
2124                 $run eval "$cmd" || exit $?
2125               done
2126               IFS="$save_ifs"
2127             fi
2128
2129             # Create $newlib
2130             if test -f "$output_objdir/$newlib"; then :; else
2131               $show "generating import library for \`$soname'"
2132               IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2133               cmds=$old_archive_from_expsyms_cmds
2134               for cmd in $cmds; do
2135                 IFS="$save_ifs"
2136                 eval cmd=\"$cmd\"
2137                 $show "$cmd"
2138                 $run eval "$cmd" || exit $?
2139               done
2140               IFS="$save_ifs"
2141             fi
2142             # make sure the library variables are pointing to the new library
2143             dir=$output_objdir
2144             linklib=$newlib
2145           fi # test -n $old_archive_from_expsyms_cmds
2146
2147           if test $linkmode = prog || test "$mode" != relink; then
2148             add_shlibpath=
2149             add_dir=
2150             add=
2151             lib_linked=yes
2152             case $hardcode_action in
2153             immediate | unsupported)
2154               if test "$hardcode_direct" = no; then
2155                 add="$dir/$linklib"
2156               elif test "$hardcode_minus_L" = no; then
2157                 case $host in
2158                 *-*-sunos*) add_shlibpath="$dir" ;;
2159                 esac
2160                 add_dir="-L$dir"
2161                 add="-l$name"
2162               elif test "$hardcode_shlibpath_var" = no; then
2163                 add_shlibpath="$dir"
2164                 add="-l$name"
2165               else
2166                 lib_linked=no
2167               fi
2168               ;;
2169             relink)
2170               if test "$hardcode_direct" = yes; then
2171                 add="$dir/$linklib"
2172               elif test "$hardcode_minus_L" = yes; then
2173                 add_dir="-L$dir"
2174                 add="-l$name"
2175               elif test "$hardcode_shlibpath_var" = yes; then
2176                 add_shlibpath="$dir"
2177                 add="-l$name"
2178               else
2179                 lib_linked=no
2180               fi
2181               ;;
2182             *) lib_linked=no ;;
2183             esac
2184
2185             if test "$lib_linked" != yes; then
2186               $echo "$modename: configuration error: unsupported hardcode properties"
2187               exit 1
2188             fi
2189
2190             if test -n "$add_shlibpath"; then
2191               case :$compile_shlibpath: in
2192               *":$add_shlibpath:"*) ;;
2193               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2194               esac
2195             fi
2196             if test $linkmode = prog; then
2197               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2198               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2199             else
2200               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2201               test -n "$add" && deplibs="$add $deplibs"
2202               if test "$hardcode_direct" != yes && \
2203                  test "$hardcode_minus_L" != yes && \
2204                  test "$hardcode_shlibpath_var" = yes; then
2205                 case :$finalize_shlibpath: in
2206                 *":$libdir:"*) ;;
2207                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2208                 esac
2209               fi
2210             fi
2211           fi
2212
2213           if test $linkmode = prog || test "$mode" = relink; then
2214             add_shlibpath=
2215             add_dir=
2216             add=
2217             # Finalize command for both is simple: just hardcode it.
2218             if test "$hardcode_direct" = yes; then
2219               add="$libdir/$linklib"
2220             elif test "$hardcode_minus_L" = yes; then
2221               add_dir="-L$libdir"
2222               add="-l$name"
2223             elif test "$hardcode_shlibpath_var" = yes; then
2224               case :$finalize_shlibpath: in
2225               *":$libdir:"*) ;;
2226               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2227               esac
2228               add="-l$name"
2229             else
2230               # We cannot seem to hardcode it, guess we'll fake it.
2231               add_dir="-L$libdir"
2232               add="-l$name"
2233             fi
2234
2235             if test $linkmode = prog; then
2236               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2237               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2238             else
2239               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2240               test -n "$add" && deplibs="$add $deplibs"
2241             fi
2242           fi
2243         elif test $linkmode = prog; then
2244           if test "$alldeplibs" = yes &&
2245              { test "$deplibs_check_method" = pass_all ||
2246                { test "$build_libtool_libs" = yes &&
2247                  test -n "$library_names"; }; }; then
2248             # We only need to search for static libraries
2249             continue
2250           fi
2251
2252           # Try to link the static library
2253           # Here we assume that one of hardcode_direct or hardcode_minus_L
2254           # is not unsupported.  This is valid on all known static and
2255           # shared platforms.
2256           if test "$hardcode_direct" != unsupported; then
2257             test -n "$old_library" && linklib="$old_library"
2258             compile_deplibs="$dir/$linklib $compile_deplibs"
2259             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2260           else
2261             compile_deplibs="-l$name -L$dir $compile_deplibs"
2262             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2263           fi
2264         elif test "$build_libtool_libs" = yes; then
2265           # Not a shared library
2266           if test "$deplibs_check_method" != pass_all; then
2267             # We're trying link a shared library against a static one
2268             # but the system doesn't support it.
2269
2270             # Just print a warning and add the library to dependency_libs so
2271             # that the program can be linked against the static library.
2272             echo
2273             echo "*** Warning: This library needs some functionality provided by $lib."
2274             echo "*** I have the capability to make that library automatically link in when"
2275             echo "*** you link to this library.  But I can only do this if you have a"
2276             echo "*** shared version of the library, which you do not appear to have."
2277             if test "$module" = yes; then
2278               echo "*** Therefore, libtool will create a static module, that should work "
2279               echo "*** as long as the dlopening application is linked with the -dlopen flag."
2280               if test -z "$global_symbol_pipe"; then
2281                 echo
2282                 echo "*** However, this would only work if libtool was able to extract symbol"
2283                 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2284                 echo "*** not find such a program.  So, this module is probably useless."
2285                 echo "*** \`nm' from GNU binutils and a full rebuild may help."
2286               fi
2287               if test "$build_old_libs" = no; then
2288                 build_libtool_libs=module
2289                 build_old_libs=yes
2290               else
2291                 build_libtool_libs=no
2292               fi
2293             fi
2294           else
2295             convenience="$convenience $dir/$old_library"
2296             old_convenience="$old_convenience $dir/$old_library"
2297             deplibs="$dir/$old_library $deplibs"
2298             link_static=yes
2299           fi
2300         fi # link shared/static library?
2301
2302         if test $linkmode = lib; then
2303           if test -n "$dependency_libs" &&
2304              { test $hardcode_into_libs != yes || test $build_old_libs = yes ||
2305                test $link_static = yes; }; then
2306             # Extract -R from dependency_libs
2307             temp_deplibs=
2308             for libdir in $dependency_libs; do
2309               case $libdir in
2310               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2311                    case " $xrpath " in
2312                    *" $temp_xrpath "*) ;;
2313                    *) xrpath="$xrpath $temp_xrpath";;
2314                    esac;;
2315               *) temp_deplibs="$temp_deplibs $libdir";;
2316               esac
2317             done
2318             dependency_libs="$temp_deplibs"
2319           fi
2320
2321           newlib_search_path="$newlib_search_path $absdir"
2322           # Link against this library
2323           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2324           # ... and its dependency_libs
2325           tmp_libs=
2326           for deplib in $dependency_libs; do
2327             newdependency_libs="$deplib $newdependency_libs"
2328             case "$tmp_libs " in
2329             *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2330             esac
2331             tmp_libs="$tmp_libs $deplib"
2332           done
2333
2334           if test $link_all_deplibs != no; then
2335             # Add the search paths of all dependency libraries
2336             for deplib in $dependency_libs; do
2337               case $deplib in
2338               -L*) path="$deplib" ;;
2339               *.la)
2340                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2341                 test "X$dir" = "X$deplib" && dir="."
2342                 # We need an absolute path.
2343                 case $dir in
2344                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2345                 *)
2346                   absdir=`cd "$dir" && pwd`
2347                   if test -z "$absdir"; then
2348                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2349                     absdir="$dir"
2350                   fi
2351                   ;;
2352                 esac
2353                 if grep "^installed=no" $deplib > /dev/null; then
2354                   path="-L$absdir/$objdir"
2355                 else
2356                   eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2357                   if test -z "$libdir"; then
2358                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2359                     exit 1
2360                   fi
2361                   if test "$absdir" != "$libdir"; then
2362                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2363                   fi
2364                   path="-L$absdir"
2365                 fi
2366                 ;;
2367               *) continue ;;
2368               esac
2369               case " $deplibs " in
2370               *" $path "*) ;;
2371               *) deplibs="$path $deplibs" ;;
2372               esac
2373             done
2374           fi # link_all_deplibs != no
2375         fi # linkmode = lib
2376       done # for deplib in $libs
2377       if test $pass = dlpreopen; then
2378         # Link the dlpreopened libraries before other libraries
2379         for deplib in $save_deplibs; do
2380           deplibs="$deplib $deplibs"
2381         done
2382       fi
2383       if test $pass != dlopen; then
2384         test $pass != scan && dependency_libs="$newdependency_libs"
2385         if test $pass != conv; then
2386           # Make sure lib_search_path contains only unique directories.
2387           lib_search_path=
2388           for dir in $newlib_search_path; do
2389             case "$lib_search_path " in
2390             *" $dir "*) ;;
2391             *) lib_search_path="$lib_search_path $dir" ;;
2392             esac
2393           done
2394           newlib_search_path=
2395         fi
2396
2397         if test "$linkmode,$pass" != "prog,link"; then
2398           vars="deplibs"
2399         else
2400           vars="compile_deplibs finalize_deplibs"
2401         fi
2402         for var in $vars dependency_libs; do
2403           # Add libraries to $var in reverse order
2404           eval tmp_libs=\"\$$var\"
2405           new_libs=
2406           for deplib in $tmp_libs; do
2407             case $deplib in
2408             -L*) new_libs="$deplib $new_libs" ;;
2409             *)
2410               case " $specialdeplibs " in
2411               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2412               *)
2413                 case " $new_libs " in
2414                 *" $deplib "*) ;;
2415                 *) new_libs="$deplib $new_libs" ;;
2416                 esac
2417                 ;;
2418               esac
2419               ;;
2420             esac
2421           done
2422           tmp_libs=
2423           for deplib in $new_libs; do
2424             case $deplib in
2425             -L*)
2426               case " $tmp_libs " in
2427               *" $deplib "*) ;;
2428               *) tmp_libs="$tmp_libs $deplib" ;;
2429               esac
2430               ;;
2431             *) tmp_libs="$tmp_libs $deplib" ;;
2432             esac
2433           done
2434           eval $var=\"$tmp_libs\"
2435         done # for var
2436       fi
2437       if test "$pass" = "conv" &&
2438        { test "$linkmode" = "lib" || test "$linkmode" = "prog"; }; then
2439         libs="$deplibs" # reset libs
2440         deplibs=
2441       fi
2442     done # for pass
2443     if test $linkmode = prog; then
2444       dlfiles="$newdlfiles"
2445       dlprefiles="$newdlprefiles"
2446     fi
2447
2448     case $linkmode in
2449     oldlib)
2450       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2451         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2452       fi
2453
2454       if test -n "$rpath"; then
2455         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2456       fi
2457
2458       if test -n "$xrpath"; then
2459         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2460       fi
2461
2462       if test -n "$vinfo"; then
2463         $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
2464       fi
2465
2466       if test -n "$release"; then
2467         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2468       fi
2469
2470       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2471         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2472       fi
2473
2474       # Now set the variables for building old libraries.
2475       build_libtool_libs=no
2476       oldlibs="$output"
2477       objs="$objs$old_deplibs"
2478       ;;
2479
2480     lib)
2481       # Make sure we only generate libraries of the form `libNAME.la'.
2482       case $outputname in
2483       lib*)
2484         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2485         eval shared_ext=\"$shrext\"
2486         eval libname=\"$libname_spec\"
2487         ;;
2488       *)
2489         if test "$module" = no; then
2490           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2491           $echo "$help" 1>&2
2492           exit 1
2493         fi
2494         if test "$need_lib_prefix" != no; then
2495           # Add the "lib" prefix for modules if required
2496           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2497           eval shared_ext=\"$shrext\"
2498           eval libname=\"$libname_spec\"
2499         else
2500           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2501         fi
2502         ;;
2503       esac
2504
2505       if test -n "$objs"; then
2506         if test "$deplibs_check_method" != pass_all; then
2507           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2508           exit 1
2509         else
2510           echo
2511           echo "*** Warning: Linking the shared library $output against the non-libtool"
2512           echo "*** objects $objs is not portable!"
2513           libobjs="$libobjs $objs"
2514         fi
2515       fi
2516
2517       if test "$dlself" != no; then
2518         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2519       fi
2520
2521       set dummy $rpath
2522       if test $# -gt 2; then
2523         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2524       fi
2525       install_libdir="$2"
2526
2527       oldlibs=
2528       if test -z "$rpath"; then
2529         if test "$build_libtool_libs" = yes; then
2530           # Building a libtool convenience library.
2531           # Some compilers have problems with a `.al' extension so
2532           # convenience libraries should have the same extension an
2533           # archive normally would.
2534           oldlibs="$output_objdir/$libname.$libext $oldlibs"
2535           build_libtool_libs=convenience
2536           build_old_libs=yes
2537         fi
2538
2539         if test -n "$vinfo"; then
2540           $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
2541         fi
2542
2543         if test -n "$release"; then
2544           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2545         fi
2546       else
2547
2548         # Parse the version information argument.
2549         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
2550         set dummy $vinfo 0 0 0
2551         IFS="$save_ifs"
2552
2553         if test -n "$8"; then
2554           $echo "$modename: too many parameters to \`-version-info'" 1>&2
2555           $echo "$help" 1>&2
2556           exit 1
2557         fi
2558
2559         current="$2"
2560         revision="$3"
2561         age="$4"
2562
2563         # Check that each of the things are valid numbers.
2564         case $current in
2565         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2566         *)
2567           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2568           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2569           exit 1
2570           ;;
2571         esac
2572
2573         case $revision in
2574         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2575         *)
2576           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2577           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2578           exit 1
2579           ;;
2580         esac
2581
2582         case $age in
2583         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2584         *)
2585           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2586           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2587           exit 1
2588           ;;
2589         esac
2590
2591         if test $age -gt $current; then
2592           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2593           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2594           exit 1
2595         fi
2596
2597         # Calculate the version variables.
2598         major=
2599         versuffix=
2600         verstring=
2601         case $version_type in
2602         none) ;;
2603
2604         darwin)
2605           # Like Linux, but with the current version available in
2606           # verstring for coding it into the library header
2607           major=.`expr $current - $age`
2608           versuffix="$major.$age.$revision"
2609           # Darwin ld doesn't like 0 for these options...
2610           minor_current=`expr $current + 1`
2611           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2612           ;;
2613
2614         freebsd-aout)
2615           major=".$current"
2616           versuffix=".$current.$revision";
2617           ;;
2618
2619         freebsd-elf)
2620           major=".$current"
2621           versuffix=".$current";
2622           ;;
2623
2624         irix)
2625           major=`expr $current - $age + 1`
2626           verstring="sgi$major.$revision"
2627
2628           # Add in all the interfaces that we are compatible with.
2629           loop=$revision
2630           while test $loop != 0; do
2631             iface=`expr $revision - $loop`
2632             loop=`expr $loop - 1`
2633             verstring="sgi$major.$iface:$verstring"
2634           done
2635
2636           # Before this point, $major must not contain `.'.
2637           major=.$major
2638           versuffix="$major.$revision"
2639           ;;
2640
2641         linux)
2642           major=.`expr $current - $age`
2643           versuffix="$major.$age.$revision"
2644           ;;
2645
2646         osf)
2647           major=.`expr $current - $age`
2648           versuffix=".$current.$age.$revision"
2649           verstring="$current.$age.$revision"
2650
2651           # Add in all the interfaces that we are compatible with.
2652           loop=$age
2653           while test $loop != 0; do
2654             iface=`expr $current - $loop`
2655             loop=`expr $loop - 1`
2656             verstring="$verstring:${iface}.0"
2657           done
2658
2659           # Make executables depend on our current version.
2660           verstring="$verstring:${current}.0"
2661           ;;
2662
2663         sunos)
2664           major=".$current"
2665           versuffix=".$current.$revision"
2666           ;;
2667
2668         windows)
2669           # Use '-' rather than '.', since we only want one
2670           # extension on DOS 8.3 filesystems.
2671           major=`expr $current - $age`
2672           versuffix="-$major"
2673           ;;
2674
2675         *)
2676           $echo "$modename: unknown library version type \`$version_type'" 1>&2
2677           echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
2678           exit 1
2679           ;;
2680         esac
2681
2682         # Clear the version info if we defaulted, and they specified a release.
2683         if test -z "$vinfo" && test -n "$release"; then
2684           major=
2685           case $version_type in
2686           darwin)
2687             # we can't check for "0.0" in archive_cmds due to quoting
2688             # problems, so we reset it completely
2689             verstring=
2690             ;;
2691           *)
2692             verstring="0.0"
2693             ;;
2694           esac
2695           if test "$need_version" = no; then
2696             versuffix=
2697           else
2698             versuffix=".0.0"
2699           fi
2700         fi
2701
2702         # Remove version info from name if versioning should be avoided
2703         if test "$avoid_version" = yes && test "$need_version" = no; then
2704           major=
2705           versuffix=
2706           verstring=""
2707         fi
2708
2709         # Check to see if the archive will have undefined symbols.
2710         if test "$allow_undefined" = yes; then
2711           if test "$allow_undefined_flag" = unsupported; then
2712             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
2713             build_libtool_libs=no
2714             build_old_libs=yes
2715           fi
2716         else
2717           # Don't allow undefined symbols.
2718           allow_undefined_flag="$no_undefined_flag"
2719         fi
2720       fi
2721
2722       if test "$mode" != relink; then
2723         # Remove our outputs, but don't remove object files since they
2724         # may have been created when compiling PIC objects.
2725         removelist=
2726         tempremovelist=`echo "$output_objdir/*"`
2727         for p in $tempremovelist; do
2728           case $p in
2729             *.$objext)
2730                ;;
2731             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
2732                removelist="$removelist $p"
2733                ;;
2734             *) ;;
2735           esac
2736         done
2737         if test -n "$removelist"; then
2738           $show "${rm}r $removelist"
2739           $run ${rm}r $removelist
2740         fi
2741       fi
2742
2743       # Now set the variables for building old libraries.
2744       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
2745         oldlibs="$oldlibs $output_objdir/$libname.$libext"
2746
2747         # Transform .lo files to .o files.
2748         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
2749       fi
2750
2751       # Eliminate all temporary directories.
2752       for path in $notinst_path; do
2753         lib_search_path=`echo "$lib_search_path " | sed -e 's% $path % %g'`
2754         deplibs=`echo "$deplibs " | sed -e 's% -L$path % %g'`
2755         dependency_libs=`echo "$dependency_libs " | sed -e 's% -L$path % %g'`
2756       done
2757
2758       if test -n "$xrpath"; then
2759         # If the user specified any rpath flags, then add them.
2760         temp_xrpath=
2761         for libdir in $xrpath; do
2762           temp_xrpath="$temp_xrpath -R$libdir"
2763           case "$finalize_rpath " in
2764           *" $libdir "*) ;;
2765           *) finalize_rpath="$finalize_rpath $libdir" ;;
2766           esac
2767         done
2768         if test $hardcode_into_libs != yes || test $build_old_libs = yes; then
2769           dependency_libs="$temp_xrpath $dependency_libs"
2770         fi
2771       fi
2772
2773       # Make sure dlfiles contains only unique files that won't be dlpreopened
2774       old_dlfiles="$dlfiles"
2775       dlfiles=
2776       for lib in $old_dlfiles; do
2777         case " $dlprefiles $dlfiles " in
2778         *" $lib "*) ;;
2779         *) dlfiles="$dlfiles $lib" ;;
2780         esac
2781       done
2782
2783       # Make sure dlprefiles contains only unique files
2784       old_dlprefiles="$dlprefiles"
2785       dlprefiles=
2786       for lib in $old_dlprefiles; do
2787         case "$dlprefiles " in
2788         *" $lib "*) ;;
2789         *) dlprefiles="$dlprefiles $lib" ;;
2790         esac
2791       done
2792
2793       if test "$build_libtool_libs" = yes; then
2794         if test -n "$rpath"; then
2795           case $host in
2796           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
2797             # these systems don't actually have a c library (as such)!
2798             ;;
2799           *-*-rhapsody* | *-*-darwin1.[012])
2800             # Rhapsody C library is in the System framework
2801             deplibs="$deplibs -framework System"
2802             ;;
2803           *-*-netbsd*)
2804             # Don't link with libc until the a.out ld.so is fixed.
2805             ;;
2806           *)
2807             # Add libc to deplibs on all other systems if necessary.
2808             if test $build_libtool_need_lc = "yes"; then
2809               deplibs="$deplibs -lc"
2810             fi
2811             ;;
2812           esac
2813         fi
2814
2815         # Transform deplibs into only deplibs that can be linked in shared.
2816         name_save=$name
2817         libname_save=$libname
2818         release_save=$release
2819         versuffix_save=$versuffix
2820         major_save=$major
2821         # I'm not sure if I'm treating the release correctly.  I think
2822         # release should show up in the -l (ie -lgmp5) so we don't want to
2823         # add it in twice.  Is that correct?
2824         release=""
2825         versuffix=""
2826         major=""
2827         newdeplibs=
2828         droppeddeps=no
2829         case $deplibs_check_method in
2830         pass_all)
2831           # Don't check for shared/static.  Everything works.
2832           # This might be a little naive.  We might want to check
2833           # whether the library exists or not.  But this is on
2834           # osf3 & osf4 and I'm not really sure... Just
2835           # implementing what was already the behaviour.
2836           newdeplibs=$deplibs
2837           ;;
2838         test_compile)
2839           # This code stresses the "libraries are programs" paradigm to its
2840           # limits. Maybe even breaks it.  We compile a program, linking it
2841           # against the deplibs as a proxy for the library.  Then we can check
2842           # whether they linked in statically or dynamically with ldd.
2843           $rm conftest.c
2844           cat > conftest.c <<EOF
2845           int main() { return 0; }
2846 EOF
2847           $rm conftest
2848           $LTCC -o conftest conftest.c $deplibs
2849           if test $? -eq 0 ; then
2850             ldd_output=`ldd conftest`
2851             for i in $deplibs; do
2852               name="`expr $i : '-l\(.*\)'`"
2853               # If $name is empty we are operating on a -L argument.
2854               if test -n "$name" && test "$name" != "0"; then
2855                 libname=`eval \\$echo \"$libname_spec\"`
2856                 deplib_matches=`eval \\$echo \"$library_names_spec\"`
2857                 set dummy $deplib_matches
2858                 deplib_match=$2
2859                 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2860                   newdeplibs="$newdeplibs $i"
2861                 else
2862                   droppeddeps=yes
2863                   echo
2864                   echo "*** Warning: This library needs some functionality provided by $i."
2865                   echo "*** I have the capability to make that library automatically link in when"
2866                   echo "*** you link to this library.  But I can only do this if you have a"
2867                   echo "*** shared version of the library, which you do not appear to have."
2868                 fi
2869               else
2870                 newdeplibs="$newdeplibs $i"
2871               fi
2872             done
2873           else
2874             # Error occured in the first compile.  Let's try to salvage the situation:
2875             # Compile a seperate program for each library.
2876             for i in $deplibs; do
2877               name="`expr $i : '-l\(.*\)'`"
2878              # If $name is empty we are operating on a -L argument.
2879               if test -n "$name" && test "$name" != "0"; then
2880                 $rm conftest
2881                 $LTCC -o conftest conftest.c $i
2882                 # Did it work?
2883                 if test $? -eq 0 ; then
2884                   ldd_output=`ldd conftest`
2885                   libname=`eval \\$echo \"$libname_spec\"`
2886                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
2887                   set dummy $deplib_matches
2888                   deplib_match=$2
2889                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2890                     newdeplibs="$newdeplibs $i"
2891                   else
2892                     droppeddeps=yes
2893                     echo
2894                     echo "*** Warning: This library needs some functionality provided by $i."
2895                     echo "*** I have the capability to make that library automatically link in when"
2896                     echo "*** you link to this library.  But I can only do this if you have a"
2897                     echo "*** shared version of the library, which you do not appear to have."
2898                   fi
2899                 else
2900                   droppeddeps=yes
2901                   echo
2902                   echo "*** Warning!  Library $i is needed by this library but I was not able to"
2903                   echo "***  make it link in!  You will probably need to install it or some"
2904                   echo "*** library that it depends on before this library will be fully"
2905                   echo "*** functional.  Installing it before continuing would be even better."
2906                 fi
2907               else
2908                 newdeplibs="$newdeplibs $i"
2909               fi
2910             done
2911           fi
2912           ;;
2913         file_magic*)
2914           set dummy $deplibs_check_method
2915           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2916           for a_deplib in $deplibs; do
2917             name="`expr $a_deplib : '-l\(.*\)'`"
2918             # If $name is empty we are operating on a -L argument.
2919             if test -n "$name" && test "$name" != "0"; then
2920               libname=`eval \\$echo \"$libname_spec\"`
2921               for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2922                     potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2923                     for potent_lib in $potential_libs; do
2924                       # Follow soft links.
2925                       if ls -lLd "$potent_lib" 2>/dev/null \
2926                          | grep " -> " >/dev/null; then
2927                         continue
2928                       fi
2929                       # The statement above tries to avoid entering an
2930                       # endless loop below, in case of cyclic links.
2931                       # We might still enter an endless loop, since a link
2932                       # loop can be closed while we follow links,
2933                       # but so what?
2934                       potlib="$potent_lib"
2935                       while test -h "$potlib" 2>/dev/null; do
2936                         potliblink=`ls -ld $potlib | sed 's/.* -> //'`
2937                         case $potliblink in
2938                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
2939                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
2940                         esac
2941                       done
2942                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
2943                          | sed 10q \
2944                          | egrep "$file_magic_regex" > /dev/null; then
2945                         newdeplibs="$newdeplibs $a_deplib"
2946                         a_deplib=""
2947                         break 2
2948                       fi
2949                     done
2950               done
2951               if test -n "$a_deplib" ; then
2952                 droppeddeps=yes
2953                 echo
2954                 echo "*** Warning: This library needs some functionality provided by $a_deplib."
2955                 echo "*** I have the capability to make that library automatically link in when"
2956                 echo "*** you link to this library.  But I can only do this if you have a"
2957                 echo "*** shared version of the library, which you do not appear to have."
2958               fi
2959             else
2960               # Add a -L argument.
2961               newdeplibs="$newdeplibs $a_deplib"
2962             fi
2963           done # Gone through all deplibs.
2964           ;;
2965         match_pattern*)
2966           set dummy $deplibs_check_method
2967           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2968           for a_deplib in $deplibs; do
2969             name="`expr $a_deplib : '-l\(.*\)'`"
2970             # If $name is empty we are operating on a -L argument.
2971             if test -n "$name" && test "$name" != "0"; then
2972               libname=`eval \\$echo \"$libname_spec\"`
2973               for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2974                 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2975                 for potent_lib in $potential_libs; do
2976                   if eval echo \"$potent_lib\" 2>/dev/null \
2977                       | sed 10q \
2978                       | egrep "$match_pattern_regex" > /dev/null; then
2979                     newdeplibs="$newdeplibs $a_deplib"
2980                     a_deplib=""
2981                     break 2
2982                   fi
2983                 done
2984               done
2985               if test -n "$a_deplib" ; then
2986                 droppeddeps=yes
2987                 echo
2988                 echo "*** Warning: This library needs some functionality provided by $a_deplib."
2989                 echo "*** I have the capability to make that library automatically link in when"
2990                 echo "*** you link to this library.  But I can only do this if you have a"
2991                 echo "*** shared version of the library, which you do not appear to have."
2992               fi
2993             else
2994               # Add a -L argument.
2995               newdeplibs="$newdeplibs $a_deplib"
2996             fi
2997           done # Gone through all deplibs.
2998           ;;
2999         none | unknown | *)
3000           newdeplibs=""
3001           if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3002                -e 's/ -[LR][^ ]*//g' -e 's/[    ]//g' |
3003              grep . >/dev/null; then
3004             echo
3005             if test "X$deplibs_check_method" = "Xnone"; then
3006               echo "*** Warning: inter-library dependencies are not supported in this platform."
3007             else
3008               echo "*** Warning: inter-library dependencies are not known to be supported."
3009             fi
3010             echo "*** All declared inter-library dependencies are being dropped."
3011             droppeddeps=yes
3012           fi
3013           ;;
3014         esac
3015         versuffix=$versuffix_save
3016         major=$major_save
3017         release=$release_save
3018         libname=$libname_save
3019         name=$name_save
3020
3021         case $host in
3022         *-*-rhapsody* | *-*-darwin1.[012])
3023           # On Rhapsody replace the C library is the System framework
3024           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3025           ;;
3026         esac
3027
3028         if test "$droppeddeps" = yes; then
3029           if test "$module" = yes; then
3030             echo
3031             echo "*** Warning: libtool could not satisfy all declared inter-library"
3032             echo "*** dependencies of module $libname.  Therefore, libtool will create"
3033             echo "*** a static module, that should work as long as the dlopening"
3034             echo "*** application is linked with the -dlopen flag."
3035             if test -z "$global_symbol_pipe"; then
3036               echo
3037               echo "*** However, this would only work if libtool was able to extract symbol"
3038               echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3039               echo "*** not find such a program.  So, this module is probably useless."
3040               echo "*** \`nm' from GNU binutils and a full rebuild may help."
3041             fi
3042             if test "$build_old_libs" = no; then
3043               oldlibs="$output_objdir/$libname.$libext"
3044               build_libtool_libs=module
3045               build_old_libs=yes
3046             else
3047               build_libtool_libs=no
3048             fi
3049           else
3050             echo "*** The inter-library dependencies that have been dropped here will be"
3051             echo "*** automatically added whenever a program is linked with this library"
3052             echo "*** or is declared to -dlopen it."
3053
3054             if test $allow_undefined = no; then
3055               echo
3056               echo "*** Since this library must not contain undefined symbols,"
3057               echo "*** because either the platform does not support them or"
3058               echo "*** it was explicitly requested with -no-undefined,"
3059               echo "*** libtool will only create a static version of it."
3060               if test "$build_old_libs" = no; then
3061                 oldlibs="$output_objdir/$libname.$libext"
3062                 build_libtool_libs=module
3063                 build_old_libs=yes
3064               else
3065                 build_libtool_libs=no
3066               fi
3067             fi
3068           fi
3069         fi
3070         # Time to change all our "foo.framework" stuff back to "-framework foo"
3071         case $host in
3072             *-*-darwin*)
3073                 newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).framework% -framework \1%g'`
3074                 dependency_libs=`$echo "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).framework% -framework \1%g'`
3075                 ;;
3076         esac
3077         # Done checking deplibs!
3078         # Done checking deplibs!
3079         deplibs=$newdeplibs
3080       fi
3081
3082       # All the library-specific variables (install_libdir is set above).
3083       library_names=
3084       old_library=
3085       dlname=
3086
3087       # Test again, we may have decided not to build it any more
3088       if test "$build_libtool_libs" = yes; then
3089         if test $hardcode_into_libs = yes; then
3090           # Hardcode the library paths
3091           hardcode_libdirs=
3092           dep_rpath=
3093           rpath="$finalize_rpath"
3094           test "$mode" != relink && rpath="$compile_rpath$rpath"
3095           for libdir in $rpath; do
3096             if test -n "$hardcode_libdir_flag_spec"; then
3097               if test -n "$hardcode_libdir_separator"; then
3098                 if test -z "$hardcode_libdirs"; then
3099                   hardcode_libdirs="$libdir"
3100                 else
3101                   # Just accumulate the unique libdirs.
3102                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3103                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3104                     ;;
3105                   *)
3106                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3107                     ;;
3108                   esac
3109                 fi
3110               else
3111                 eval flag=\"$hardcode_libdir_flag_spec\"
3112                 dep_rpath="$dep_rpath $flag"
3113               fi
3114             elif test -n "$runpath_var"; then
3115               case "$perm_rpath " in
3116               *" $libdir "*) ;;
3117               *) perm_rpath="$perm_rpath $libdir" ;;
3118               esac
3119             fi
3120           done
3121           # Substitute the hardcoded libdirs into the rpath.
3122           if test -n "$hardcode_libdir_separator" &&
3123              test -n "$hardcode_libdirs"; then
3124             libdir="$hardcode_libdirs"
3125             eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3126           fi
3127           if test -n "$runpath_var" && test -n "$perm_rpath"; then
3128             # We should set the runpath_var.
3129             rpath=
3130             for dir in $perm_rpath; do
3131               rpath="$rpath$dir:"
3132             done
3133             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3134           fi
3135           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3136         fi
3137
3138         shlibpath="$finalize_shlibpath"
3139         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3140         if test -n "$shlibpath"; then
3141           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3142         fi
3143
3144         # Get the real and link names of the library.
3145         eval library_names=\"$library_names_spec\"
3146         eval shared_ext=\"$shrext\"
3147         set dummy $library_names
3148         realname="$2"
3149         shift; shift
3150
3151         if test -n "$soname_spec"; then
3152           eval soname=\"$soname_spec\"
3153         else
3154           soname="$realname"
3155         fi
3156         test -z "$dlname" && dlname=$soname
3157
3158         lib="$output_objdir/$realname"
3159         for link
3160         do
3161           linknames="$linknames $link"
3162         done
3163
3164 #       # Ensure that we have .o objects for linkers which dislike .lo
3165 #       # (e.g. aix) in case we are running --disable-static
3166 #       for obj in $libobjs; do
3167 #         xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
3168 #         if test "X$xdir" = "X$obj"; then
3169 #           xdir="."
3170 #         else
3171 #           xdir="$xdir"
3172 #         fi
3173 #         baseobj=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
3174 #         oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
3175 #         if test ! -f $xdir/$oldobj && test "$baseobj" != "$oldobj"; then
3176 #           $show "(cd $xdir && ${LN_S} $baseobj $oldobj)"
3177 #           $run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?
3178 #         fi
3179 #       done
3180
3181         # Use standard objects if they are pic
3182         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3183
3184         # Prepare the list of exported symbols
3185         if test -z "$export_symbols"; then
3186           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3187             $show "generating symbol list for \`$libname.la'"
3188             export_symbols="$output_objdir/$libname.exp"
3189             $run $rm $export_symbols
3190             eval cmds=\"$export_symbols_cmds\"
3191             IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
3192             for cmd in $cmds; do
3193               IFS="$save_ifs"
3194               $show "$cmd"
3195               $run eval "$cmd" || exit $?
3196             done
3197             IFS="$save_ifs"
3198             if test -n "$export_symbols_regex"; then
3199               $show "egrep -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3200               $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3201               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3202               $run eval '$mv "${export_symbols}T" "$export_symbols"'
3203             fi
3204           fi
3205         fi
3206
3207         if test -n "$export_symbols" && test -n "$include_expsyms"; then
3208           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3209         fi
3210
3211         if test -n "$convenience"; then
3212           if test -n "$whole_archive_flag_spec"; then
3213             save_libobjs=$libobjs
3214             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3215           else
3216             gentop="$output_objdir/${outputname}x"
3217             $show "${rm}r $gentop"
3218             $run ${rm}r "$gentop"
3219             $show "$mkdir $gentop"
3220             $run $mkdir "$gentop"
3221             status=$?
3222             if test $status -ne 0 && test ! -d "$gentop"; then
3223               exit $status
3224             fi
3225             generated="$generated $gentop"
3226
3227             for xlib in $convenience; do
3228               # Extract the objects.
3229               case $xlib in
3230               [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3231               *) xabs=`pwd`"/$xlib" ;;
3232               esac
3233               xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3234               xdir="$gentop/$xlib"
3235
3236               $show "${rm}r $xdir"
3237               $run ${rm}r "$xdir"
3238               $show "$mkdir $xdir"
3239               $run $mkdir "$xdir"
3240               status=$?
3241               if test $status -ne 0 && test ! -d "$xdir"; then
3242                 exit $status
3243               fi
3244               $show "(cd $xdir && $AR x $xabs)"
3245               $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3246
3247               libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3248             done
3249           fi
3250         fi
3251
3252         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3253           eval flag=\"$thread_safe_flag_spec\"
3254           linker_flags="$linker_flags $flag"
3255         fi
3256
3257         # Make a backup of the uninstalled library when relinking
3258         if test "$mode" = relink; then
3259           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3260         fi
3261
3262         # Do each of the archive commands.
3263         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3264           eval test_cmds=\"$archive_expsym_cmds\"
3265           cmds=$archive_expsym_cmds
3266         else
3267           eval test_cmds=\"$archive_cmds\"
3268           cmds=$archive_cmds
3269         fi
3270         if len=`expr "X$test_cmds" : ".*"` &&
3271            test $len -le $max_cmd_len; then
3272           :
3273         else
3274           # The command line is too long to link in one step, link piecewise.
3275           $echo "creating reloadable object files..."
3276
3277           # Save the value of $output and $libobjs because we want to
3278           # use them later.  If we have whole_archive_flag_spec, we
3279           # want to use save_libobjs as it was before
3280           # whole_archive_flag_spec was expanded, because we can't
3281           # assume the linker understands whole_archive_flag_spec.
3282           # This may have to be revisited, in case too many
3283           # convenience libraries get linked in and end up exceeding
3284           # the spec.
3285           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3286             save_libobjs=$libobjs
3287           fi
3288           save_output=$output
3289
3290           # Clear the reloadable object creation command queue and
3291           # initialize k to one.
3292           test_cmds=
3293           concat_cmds=
3294           objlist=
3295           delfiles=
3296           last_robj=
3297           k=1
3298           output=$output_objdir/$save_output-${k}.$objext
3299           # Loop over the list of objects to be linked.
3300           for obj in $save_libobjs
3301           do
3302             eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3303             if test "X$objlist" = X ||
3304                { len=`expr "X$test_cmds" : ".*"` &&
3305                  test $len -le $max_cmd_len; }; then
3306               objlist="$objlist $obj"
3307             else
3308               # The command $test_cmds is almost too long, add a
3309               # command to the queue.
3310               if test $k -eq 1 ; then
3311                 # The first file doesn't have a previous command to add.
3312                 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3313               else
3314                 # All subsequent reloadable object files will link in
3315                 # the last one created.
3316                 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3317               fi
3318               last_robj=$output_objdir/$save_output-${k}.$objext
3319               k=`expr $k + 1`
3320               output=$output_objdir/$save_output-${k}.$objext
3321               objlist=$obj
3322               len=1
3323             fi
3324           done
3325           # Handle the remaining objects by creating one last
3326           # reloadable object file.  All subsequent reloadable object
3327           # files will link in the last one created.
3328           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3329           eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3330
3331           # Set up a command to remove the reloadale object files
3332           # after they are used.
3333           i=0
3334           while test $i -lt $k
3335           do
3336             i=`expr $i + 1`
3337             delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3338           done
3339
3340           $echo "creating a temporary reloadable object file: $output"
3341
3342           # Loop through the commands generated above and execute them.
3343           IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
3344           for cmd in $concat_cmds; do
3345             IFS="$save_ifs"
3346             eval cmd=\"$cmd\"
3347             $show "$cmd"
3348             $run eval "$cmd" || exit $?
3349           done
3350           IFS="$save_ifs"
3351
3352           libobjs=$output
3353           # Restore the value of output.
3354           output=$save_output
3355
3356           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3357             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3358           fi
3359           # Expand the library linking commands again to reset the
3360           # value of $libobjs for piecewise linking.
3361
3362           # Do each of the archive commands.
3363           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3364             cmds=$archive_expsym_cmds
3365           else
3366             cmds=$archive_cmds
3367           fi
3368
3369           # Append the command to remove the reloadable object files
3370           # to the just-reset $cmds.
3371           eval cmds=\"\$cmds~$rm $delfiles\"
3372         fi
3373         IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
3374         for cmd in $cmds; do
3375           IFS="$save_ifs"
3376           eval cmd=\"$cmd\"
3377           $show "$cmd"
3378           $run eval "$cmd" || exit $?
3379         done
3380         IFS="$save_ifs"
3381
3382         # Restore the uninstalled library and exit
3383         if test "$mode" = relink; then
3384           $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
3385           exit 0
3386         fi
3387
3388         # Create links to the real library.
3389         for linkname in $linknames; do
3390           if test "$realname" != "$linkname"; then
3391             $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
3392             $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
3393           fi
3394         done
3395
3396         # If -module or -export-dynamic was specified, set the dlname.
3397         if test "$module" = yes || test "$export_dynamic" = yes; then
3398           # On all known operating systems, these are identical.
3399           dlname="$soname"