ltmain.sh

   1 # ltmain.sh - Provide generalized library-building support services.
   2 # NOTE: Changing this file will not affect anything until you rerun configure.
   3 #
   4 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003
   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.5.2
  59 TIMESTAMP=" (1.1220.2.60 2004/01/25 12:25:08) Debian$Rev: 192 $"
  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 # test EBCDIC or ASCII
  73 case `echo A|tr A '\301'` in
  74  A) # EBCDIC based system
  75   SP2NL="tr '\100' '\n'"
  76   NL2SP="tr '\r\n' '\100\100'"
  77   ;;
  78  *) # Assume ASCII based system
  79   SP2NL="tr '\040' '\012'"
  80   NL2SP="tr '\015\012' '\040\040'"
  81   ;;
  82 esac
  83
  84 # NLS nuisances.
  85 # Only set LANG and LC_ALL to C if already set.
  86 # These must not be set unconditionally because not all systems understand
  87 # e.g. LANG=C (notably SCO).
  88 # We save the old values to restore during execute mode.
  89 if test "${LC_ALL+set}" = set; then
  90   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
  91 fi
  92 if test "${LANG+set}" = set; then
  93   save_LANG="$LANG"; LANG=C; export LANG
  94 fi
  95
  96 # Make sure IFS has a sensible default
  97 : ${IFS="
  98 "}
  99
 100 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
 101   $echo "$modename: not configured to build any kind of library" 1>&2
 102   $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
 103   exit 1
 104 fi
 105
 106 # Global variables.
 107 mode=$default_mode
 108 nonopt=
 109 prev=
 110 prevopt=
 111 run=
 112 show="$echo"
 113 show_help=
 114 execute_dlfiles=
 115 lo2o="s/\\.lo\$/.${objext}/"
 116 o2lo="s/\\.${objext}\$/.lo/"
 117
 118 #####################################
 119 # Shell function definitions:
 120 # This seems to be the best place for them
 121
 122 # Need a lot of goo to handle *both* DLLs and import libs
 123 # Has to be a shell function in order to 'eat' the argument
 124 # that is supplied when $file_magic_command is called.
 125 win32_libid () {
 126   win32_libid_type="unknown"
 127   win32_fileres=`file -L $1 2>/dev/null`
 128   case $win32_fileres in
 129   *ar\ archive\ import\ library*) # definitely import
 130     win32_libid_type="x86 archive import"
 131     ;;
 132   *ar\ archive*) # could be an import, or static
 133     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
 134       grep -E 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
 135       win32_nmres=`eval $NM -f posix -A $1 | \
 136         sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`
 137       if test "X$win32_nmres" = "Ximport" ; then
 138         win32_libid_type="x86 archive import"
 139       else
 140         win32_libid_type="x86 archive static"
 141       fi
 142     fi
 143     ;;
 144   *DLL*)
 145     win32_libid_type="x86 DLL"
 146     ;;
 147   *executable*) # but shell scripts are "executable" too...
 148     case $win32_fileres in
 149     *MS\ Windows\ PE\ Intel*)
 150       win32_libid_type="x86 DLL"
 151       ;;
 152     esac
 153     ;;
 154   esac
 155   $echo $win32_libid_type
 156 }
 157
 158 # End of Shell function definitions
 159 #####################################
 160
 161 # Parse our command line options once, thoroughly.
 162 while test "$#" -gt 0
 163 do
 164   arg="$1"
 165   shift
 166
 167   case $arg in
 168   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
 169   *) optarg= ;;
 170   esac
 171
 172   # If the previous option needs an argument, assign it.
 173   if test -n "$prev"; then
 174     case $prev in
 175     execute_dlfiles)
 176       execute_dlfiles="$execute_dlfiles $arg"
 177       ;;
 178     tag)
 179       tagname="$arg"
 180       preserve_args="${preserve_args}=$arg"
 181
 182       # Check whether tagname contains only valid characters
 183       case $tagname in
 184       *[!-_A-Za-z0-9,/]*)
 185         $echo "$progname: invalid tag name: $tagname" 1>&2
 186         exit 1
 187         ;;
 188       esac
 189
 190       case $tagname in
 191       CC)
 192         # Don't test for the "default" C tag, as we know, it's there, but
 193         # not specially marked.
 194         ;;
 195       *)
 196         if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$0" > /dev/null; then
 197           taglist="$taglist $tagname"
 198           # Evaluate the configuration.
 199           eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $0`"
 200         else
 201           $echo "$progname: ignoring unknown tag $tagname" 1>&2
 202         fi
 203         ;;
 204       esac
 205       ;;
 206     *)
 207       eval "$prev=\$arg"
 208       ;;
 209     esac
 210
 211     prev=
 212     prevopt=
 213     continue
 214   fi
 215
 216   # Have we seen a non-optional argument yet?
 217   case $arg in
 218   --help)
 219     show_help=yes
 220     ;;
 221
 222   --version)
 223     $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
 224     $echo
 225     $echo "Copyright (C) 2003  Free Software Foundation, Inc."
 226     $echo "This is free software; see the source for copying conditions.  There is NO"
 227     $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
 228     exit 0
 229     ;;
 230
 231   --config)
 232     ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $0
 233     # Now print the configurations for the tags.
 234     for tagname in $taglist; do
 235       ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$0"
 236     done
 237     exit 0
 238     ;;
 239
 240   --debug)
 241     $echo "$progname: enabling shell trace mode"
 242     set -x
 243     preserve_args="$preserve_args $arg"
 244     ;;
 245
 246   --dry-run | -n)
 247     run=:
 248     ;;
 249
 250   --features)
 251     $echo "host: $host"
 252     if test "$build_libtool_libs" = yes; then
 253       $echo "enable shared libraries"
 254     else
 255       $echo "disable shared libraries"
 256     fi
 257     if test "$build_old_libs" = yes; then
 258       $echo "enable static libraries"
 259     else
 260       $echo "disable static libraries"
 261     fi
 262     exit 0
 263     ;;
 264
 265   --finish) mode="finish" ;;
 266
 267   --mode) prevopt="--mode" prev=mode ;;
 268   --mode=*) mode="$optarg" ;;
 269
 270   --preserve-dup-deps) duplicate_deps="yes" ;;
 271
 272   --quiet | --silent)
 273     show=:
 274     preserve_args="$preserve_args $arg"
 275     ;;
 276
 277   --tag) prevopt="--tag" prev=tag ;;
 278   --tag=*)
 279     set tag "$optarg" ${1+"$@"}
 280     shift
 281     prev=tag
 282     preserve_args="$preserve_args --tag"
 283     ;;
 284
 285   -dlopen)
 286     prevopt="-dlopen"
 287     prev=execute_dlfiles
 288     ;;
 289
 290   -*)
 291     $echo "$modename: unrecognized option \`$arg'" 1>&2
 292     $echo "$help" 1>&2
 293     exit 1
 294     ;;
 295
 296   *)
 297     nonopt="$arg"
 298     break
 299     ;;
 300   esac
 301 done
 302
 303 if test -n "$prevopt"; then
 304   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
 305   $echo "$help" 1>&2
 306   exit 1
 307 fi
 308
 309 # If this variable is set in any of the actions, the command in it
 310 # will be execed at the end.  This prevents here-documents from being
 311 # left over by shells.
 312 exec_cmd=
 313
 314 if test -z "$show_help"; then
 315
 316   # Infer the operation mode.
 317   if test -z "$mode"; then
 318     $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
 319     $echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2
 320     case $nonopt in
 321     *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
 322       mode=link
 323       for arg
 324       do
 325         case $arg in
 326         -c)
 327            mode=compile
 328            break
 329            ;;
 330         esac
 331       done
 332       ;;
 333     *db | *dbx | *strace | *truss)
 334       mode=execute
 335       ;;
 336     *install*|cp|mv)
 337       mode=install
 338       ;;
 339     *rm)
 340       mode=uninstall
 341       ;;
 342     *)
 343       # If we have no mode, but dlfiles were specified, then do execute mode.
 344       test -n "$execute_dlfiles" && mode=execute
 345
 346       # Just use the default operation mode.
 347       if test -z "$mode"; then
 348         if test -n "$nonopt"; then
 349           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
 350         else
 351           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
 352         fi
 353       fi
 354       ;;
 355     esac
 356   fi
 357
 358   # Only execute mode is allowed to have -dlopen flags.
 359   if test -n "$execute_dlfiles" && test "$mode" != execute; then
 360     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
 361     $echo "$help" 1>&2
 362     exit 1
 363   fi
 364
 365   # Change the help message to a mode-specific one.
 366   generic_help="$help"
 367   help="Try \`$modename --help --mode=$mode' for more information."
 368
 369   # These modes are in order of execution frequency so that they run quickly.
 370   case $mode in
 371   # libtool compile mode
 372   compile)
 373     modename="$modename: compile"
 374     # Get the compilation command and the source file.
 375     base_compile=
 376     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
 377     suppress_opt=yes
 378     suppress_output=
 379     arg_mode=normal
 380     libobj=
 381     later=
 382
 383     for arg
 384     do
 385       case "$arg_mode" in
 386       arg  )
 387         # do not "continue".  Instead, add this to base_compile
 388         lastarg="$arg"
 389         arg_mode=normal
 390         ;;
 391
 392       target )
 393         libobj="$arg"
 394         arg_mode=normal
 395         continue
 396         ;;
 397
 398       normal )
 399         # Accept any command-line options.
 400         case $arg in
 401         -o)
 402           if test -n "$libobj" ; then
 403             $echo "$modename: you cannot specify \`-o' more than once" 1>&2
 404             exit 1
 405           fi
 406           arg_mode=target
 407           continue
 408           ;;
 409
 410         -static | -prefer-pic | -prefer-non-pic)
 411           later="$later $arg"
 412           continue
 413           ;;
 414
 415         -no-suppress)
 416           suppress_opt=no
 417           continue
 418           ;;
 419
 420         -Xcompiler)
 421           arg_mode=arg  #  the next one goes into the "base_compile" arg list
 422           continue      #  The current "srcfile" will either be retained or
 423           ;;            #  replaced later.  I would guess that would be a bug.
 424
 425         -Wc,*)
 426           args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
 427           lastarg=
 428           save_ifs="$IFS"; IFS=','
 429           for arg in $args; do
 430             IFS="$save_ifs"
 431
 432             # Double-quote args containing other shell metacharacters.
 433             # Many Bourne shells cannot handle close brackets correctly
 434             # in scan sets, so we specify it separately.
 435             case $arg in
 436               *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 437               arg="\"$arg\""
 438               ;;
 439             esac
 440             lastarg="$lastarg $arg"
 441           done
 442           IFS="$save_ifs"
 443           lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
 444
 445           # Add the arguments to base_compile.
 446           base_compile="$base_compile $lastarg"
 447           continue
 448           ;;
 449
 450         * )
 451           # Accept the current argument as the source file.
 452           # The previous "srcfile" becomes the current argument.
 453           #
 454           lastarg="$srcfile"
 455           srcfile="$arg"
 456           ;;
 457         esac  #  case $arg
 458         ;;
 459       esac    #  case $arg_mode
 460
 461       # Aesthetically quote the previous argument.
 462       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
 463
 464       case $lastarg in
 465       # Double-quote args containing other shell metacharacters.
 466       # Many Bourne shells cannot handle close brackets correctly
 467       # in scan sets, so we specify it separately.
 468       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 469         lastarg="\"$lastarg\""
 470         ;;
 471       esac
 472
 473       base_compile="$base_compile $lastarg"
 474     done # for arg
 475
 476     case $arg_mode in
 477     arg)
 478       $echo "$modename: you must specify an argument for -Xcompile"
 479       exit 1
 480       ;;
 481     target)
 482       $echo "$modename: you must specify a target with \`-o'" 1>&2
 483       exit 1
 484       ;;
 485     *)
 486       # Get the name of the library object.
 487       [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
 488       ;;
 489     esac
 490
 491     # Recognize several different file suffixes.
 492     # If the user specifies -o file.o, it is replaced with file.lo
 493     xform='[cCFSifmso]'
 494     case $libobj in
 495     *.ada) xform=ada ;;
 496     *.adb) xform=adb ;;
 497     *.ads) xform=ads ;;
 498     *.asm) xform=asm ;;
 499     *.c++) xform=c++ ;;
 500     *.cc) xform=cc ;;
 501     *.ii) xform=ii ;;
 502     *.class) xform=class ;;
 503     *.cpp) xform=cpp ;;
 504     *.cxx) xform=cxx ;;
 505     *.f90) xform=f90 ;;
 506     *.for) xform=for ;;
 507     *.java) xform=java ;;
 508     esac
 509
 510     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
 511
 512     case $libobj in
 513     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
 514     *)
 515       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
 516       exit 1
 517       ;;
 518     esac
 519
 520     # Infer tagged configuration to use if any are available and
 521     # if one wasn't chosen via the "--tag" command line option.
 522     # Only attempt this if the compiler in the base compile
 523     # command doesn't match the default compiler.
 524     if test -n "$available_tags" && test -z "$tagname"; then
 525       case $base_compile in
 526       # Blanks in the command may have been stripped by the calling shell,
 527       # but not from the CC environment variable when configure was run.
 528       " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "*) ;;
 529       # Blanks at the start of $base_compile will cause this to fail
 530       # if we don't check for them as well.
 531       *)
 532         for z in $available_tags; do
 533           if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
 534             # Evaluate the configuration.
 535             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
 536             case "$base_compile " in
 537             "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*)
 538               # The compiler in the base compile command matches
 539               # the one in the tagged configuration.
 540               # Assume this is the tagged configuration we want.
 541               tagname=$z
 542               break
 543               ;;
 544             esac
 545           fi
 546         done
 547         # If $tagname still isn't set, then no tagged configuration
 548         # was found and let the user know that the "--tag" command
 549         # line option must be used.
 550         if test -z "$tagname"; then
 551           $echo "$modename: unable to infer tagged configuration"
 552           $echo "$modename: specify a tag with \`--tag'" 1>&2
 553           exit 1
 554 #        else
 555 #          $echo "$modename: using $tagname tagged configuration"
 556         fi
 557         ;;
 558       esac
 559     fi
 560
 561     for arg in $later; do
 562       case $arg in
 563       -static)
 564         build_old_libs=yes
 565         continue
 566         ;;
 567
 568       -prefer-pic)
 569         pic_mode=yes
 570         continue
 571         ;;
 572
 573       -prefer-non-pic)
 574         pic_mode=no
 575         continue
 576         ;;
 577       esac
 578     done
 579
 580     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
 581     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
 582     if test "X$xdir" = "X$obj"; then
 583       xdir=
 584     else
 585       xdir=$xdir/
 586     fi
 587     lobj=${xdir}$objdir/$objname
 588
 589     if test -z "$base_compile"; then
 590       $echo "$modename: you must specify a compilation command" 1>&2
 591       $echo "$help" 1>&2
 592       exit 1
 593     fi
 594
 595     # Delete any leftover library objects.
 596     if test "$build_old_libs" = yes; then
 597       removelist="$obj $lobj $libobj ${libobj}T"
 598     else
 599       removelist="$lobj $libobj ${libobj}T"
 600     fi
 601
 602     $run $rm $removelist
 603     trap "$run $rm $removelist; exit 1" 1 2 15
 604
 605     # On Cygwin there's no "real" PIC flag so we must build both object types
 606     case $host_os in
 607     cygwin* | mingw* | pw32* | os2*)
 608       pic_mode=default
 609       ;;
 610     esac
 611     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
 612       # non-PIC code in shared libraries is not supported
 613       pic_mode=default
 614     fi
 615
 616     # Calculate the filename of the output object if compiler does
 617     # not support -o with -c
 618     if test "$compiler_c_o" = no; then
 619       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
 620       lockfile="$output_obj.lock"
 621       removelist="$removelist $output_obj $lockfile"
 622       trap "$run $rm $removelist; exit 1" 1 2 15
 623     else
 624       output_obj=
 625       need_locks=no
 626       lockfile=
 627     fi
 628
 629     # Lock this critical section if it is needed
 630     # We use this script file to make the link, it avoids creating a new file
 631     if test "$need_locks" = yes; then
 632       until $run ln "$0" "$lockfile" 2>/dev/null; do
 633         $show "Waiting for $lockfile to be removed"
 634         sleep 2
 635       done
 636     elif test "$need_locks" = warn; then
 637       if test -f "$lockfile"; then
 638         $echo "\
 639 *** ERROR, $lockfile exists and contains:
 640 `cat $lockfile 2>/dev/null`
 641
 642 This indicates that another process is trying to use the same
 643 temporary object file, and libtool could not work around it because
 644 your compiler does not support \`-c' and \`-o' together.  If you
 645 repeat this compilation, it may succeed, by chance, but you had better
 646 avoid parallel builds (make -j) in this platform, or get a better
 647 compiler."
 648
 649         $run $rm $removelist
 650         exit 1
 651       fi
 652       $echo $srcfile > "$lockfile"
 653     fi
 654
 655     if test -n "$fix_srcfile_path"; then
 656       eval srcfile=\"$fix_srcfile_path\"
 657     fi
 658
 659     $run $rm "$libobj" "${libobj}T"
 660
 661     # Create a libtool object file (analogous to a ".la" file),
 662     # but don't create it if we're doing a dry run.
 663     test -z "$run" && cat > ${libobj}T <<EOF
 664 # $libobj - a libtool object file
 665 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 666 #
 667 # Please DO NOT delete this file!
 668 # It is necessary for linking the library.
 669
 670 # Name of the PIC object.
 671 EOF
 672
 673     # Only build a PIC object if we are building libtool libraries.
 674     if test "$build_libtool_libs" = yes; then
 675       # Without this assignment, base_compile gets emptied.
 676       fbsd_hideous_sh_bug=$base_compile
 677
 678       if test "$pic_mode" != no; then
 679         command="$base_compile $srcfile $pic_flag"
 680       else
 681         # Don't build PIC code
 682         command="$base_compile $srcfile"
 683       fi
 684
 685       if test ! -d "${xdir}$objdir"; then
 686         $show "$mkdir ${xdir}$objdir"
 687         $run $mkdir ${xdir}$objdir
 688         status=$?
 689         if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then
 690           exit $status
 691         fi
 692       fi
 693
 694       if test -z "$output_obj"; then
 695         # Place PIC objects in $objdir
 696         command="$command -o $lobj"
 697       fi
 698
 699       $run $rm "$lobj" "$output_obj"
 700
 701       $show "$command"
 702       if $run eval "$command"; then :
 703       else
 704         test -n "$output_obj" && $run $rm $removelist
 705         exit 1
 706       fi
 707
 708       if test "$need_locks" = warn &&
 709          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 710         $echo "\
 711 *** ERROR, $lockfile contains:
 712 `cat $lockfile 2>/dev/null`
 713
 714 but it should contain:
 715 $srcfile
 716
 717 This indicates that another process is trying to use the same
 718 temporary object file, and libtool could not work around it because
 719 your compiler does not support \`-c' and \`-o' together.  If you
 720 repeat this compilation, it may succeed, by chance, but you had better
 721 avoid parallel builds (make -j) in this platform, or get a better
 722 compiler."
 723
 724         $run $rm $removelist
 725         exit 1
 726       fi
 727
 728       # Just move the object if needed, then go on to compile the next one
 729       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
 730         $show "$mv $output_obj $lobj"
 731         if $run $mv $output_obj $lobj; then :
 732         else
 733           error=$?
 734           $run $rm $removelist
 735           exit $error
 736         fi
 737       fi
 738
 739       # Append the name of the PIC object to the libtool object file.
 740       test -z "$run" && cat >> ${libobj}T <<EOF
 741 pic_object='$objdir/$objname'
 742
 743 EOF
 744
 745       # Allow error messages only from the first compilation.
 746       if test "$suppress_opt" = yes; then
 747         suppress_output=' >/dev/null 2>&1'
 748       fi
 749     else
 750       # No PIC object so indicate it doesn't exist in the libtool
 751       # object file.
 752       test -z "$run" && cat >> ${libobj}T <<EOF
 753 pic_object=none
 754
 755 EOF
 756     fi
 757
 758     # Only build a position-dependent object if we build old libraries.
 759     if test "$build_old_libs" = yes; then
 760       if test "$pic_mode" != yes; then
 761         # Don't build PIC code
 762         command="$base_compile $srcfile"
 763       else
 764         command="$base_compile $srcfile $pic_flag"
 765       fi
 766       if test "$compiler_c_o" = yes; then
 767         command="$command -o $obj"
 768       fi
 769
 770       # Suppress compiler output if we already did a PIC compilation.
 771       command="$command$suppress_output"
 772       $run $rm "$obj" "$output_obj"
 773       $show "$command"
 774       if $run eval "$command"; then :
 775       else
 776         $run $rm $removelist
 777         exit 1
 778       fi
 779
 780       if test "$need_locks" = warn &&
 781          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 782         $echo "\
 783 *** ERROR, $lockfile contains:
 784 `cat $lockfile 2>/dev/null`
 785
 786 but it should contain:
 787 $srcfile
 788
 789 This indicates that another process is trying to use the same
 790 temporary object file, and libtool could not work around it because
 791 your compiler does not support \`-c' and \`-o' together.  If you
 792 repeat this compilation, it may succeed, by chance, but you had better
 793 avoid parallel builds (make -j) in this platform, or get a better
 794 compiler."
 795
 796         $run $rm $removelist
 797         exit 1
 798       fi
 799
 800       # Just move the object if needed
 801       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
 802         $show "$mv $output_obj $obj"
 803         if $run $mv $output_obj $obj; then :
 804         else
 805           error=$?
 806           $run $rm $removelist
 807           exit $error
 808         fi
 809       fi
 810
 811       # Append the name of the non-PIC object the libtool object file.
 812       # Only append if the libtool object file exists.
 813       test -z "$run" && cat >> ${libobj}T <<EOF
 814 # Name of the non-PIC object.
 815 non_pic_object='$objname'
 816
 817 EOF
 818     else
 819       # Append the name of the non-PIC object the libtool object file.
 820       # Only append if the libtool object file exists.
 821       test -z "$run" && cat >> ${libobj}T <<EOF
 822 # Name of the non-PIC object.
 823 non_pic_object=none
 824
 825 EOF
 826     fi
 827
 828     $run $mv "${libobj}T" "${libobj}"
 829
 830     # Unlock the critical section if it was locked
 831     if test "$need_locks" != no; then
 832       $run $rm "$lockfile"
 833     fi
 834
 835     exit 0
 836     ;;
 837
 838   # libtool link mode
 839   link | relink)
 840     modename="$modename: link"
 841     case $host in
 842     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 843       # It is impossible to link a dll without this setting, and
 844       # we shouldn't force the makefile maintainer to figure out
 845       # which system we are compiling for in order to pass an extra
 846       # flag for every libtool invocation.
 847       # allow_undefined=no
 848
 849       # FIXME: Unfortunately, there are problems with the above when trying
 850       # to make a dll which has undefined symbols, in which case not
 851       # even a static library is built.  For now, we need to specify
 852       # -no-undefined on the libtool link line when we can be certain
 853       # that all symbols are satisfied, otherwise we get a static library.
 854       allow_undefined=yes
 855       ;;
 856     *)
 857       allow_undefined=yes
 858       ;;
 859     esac
 860     libtool_args="$nonopt"
 861     base_compile="$nonopt $@"
 862     compile_command="$nonopt"
 863     finalize_command="$nonopt"
 864
 865     compile_rpath=
 866     finalize_rpath=
 867     compile_shlibpath=
 868     finalize_shlibpath=
 869     convenience=
 870     old_convenience=
 871     deplibs=
 872     old_deplibs=
 873     compiler_flags=
 874     linker_flags=
 875     dllsearchpath=
 876     lib_search_path=`pwd`
 877     inst_prefix_dir=
 878
 879     avoid_version=no
 880     dlfiles=
 881     dlprefiles=
 882     dlself=no
 883     export_dynamic=no
 884     export_symbols=
 885     export_symbols_regex=
 886     generated=
 887     libobjs=
 888     ltlibs=
 889     module=no
 890     no_install=no
 891     objs=
 892     non_pic_objects=
 893     precious_files_regex=
 894     prefer_static_libs=no
 895     preload=no
 896     prev=
 897     prevarg=
 898     release=
 899     rpath=
 900     xrpath=
 901     perm_rpath=
 902     temp_rpath=
 903     thread_safe=no
 904     vinfo=
 905     vinfo_number=no
 906
 907     # Infer tagged configuration to use if any are available and
 908     # if one wasn't chosen via the "--tag" command line option.
 909     # Only attempt this if the compiler in the base link
 910     # command doesn't match the default compiler.
 911     if test -n "$available_tags" && test -z "$tagname"; then
 912       case $base_compile in
 913       # Blanks in the command may have been stripped by the calling shell,
 914       # but not from the CC environment variable when configure was run.
 915       "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*) ;;
 916       # Blanks at the start of $base_compile will cause this to fail
 917       # if we don't check for them as well.
 918       *)
 919         for z in $available_tags; do
 920           if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
 921             # Evaluate the configuration.
 922             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
 923             case $base_compile in
 924             "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*)
 925               # The compiler in $compile_command matches
 926               # the one in the tagged configuration.
 927               # Assume this is the tagged configuration we want.
 928               tagname=$z
 929               break
 930               ;;
 931             esac
 932           fi
 933         done
 934         # If $tagname still isn't set, then no tagged configuration
 935         # was found and let the user know that the "--tag" command
 936         # line option must be used.
 937         if test -z "$tagname"; then
 938           $echo "$modename: unable to infer tagged configuration"
 939           $echo "$modename: specify a tag with \`--tag'" 1>&2
 940           exit 1
 941 #       else
 942 #         $echo "$modename: using $tagname tagged configuration"
 943         fi
 944         ;;
 945       esac
 946     fi
 947
 948     # We need to know -static, to get the right output filenames.
 949     for arg
 950     do
 951       case $arg in
 952       -all-static | -static)
 953         if test "X$arg" = "X-all-static"; then
 954           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
 955             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
 956           fi
 957           if test -n "$link_static_flag"; then
 958             dlopen_self=$dlopen_self_static
 959           fi
 960         else
 961           if test -z "$pic_flag" && test -n "$link_static_flag"; then
 962             dlopen_self=$dlopen_self_static
 963           fi
 964         fi
 965         build_libtool_libs=no
 966         build_old_libs=yes
 967         prefer_static_libs=yes
 968         break
 969         ;;
 970       esac
 971     done
 972
 973     # See if our shared archives depend on static archives.
 974     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
 975
 976     # Go through the arguments, transforming them on the way.
 977     while test "$#" -gt 0; do
 978       arg="$1"
 979       shift
 980       case $arg in
 981       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 982         qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
 983         ;;
 984       *) qarg=$arg ;;
 985       esac
 986       libtool_args="$libtool_args $qarg"
 987
 988       # If the previous option needs an argument, assign it.
 989       if test -n "$prev"; then
 990         case $prev in
 991         output)
 992           compile_command="$compile_command @OUTPUT@"
 993           finalize_command="$finalize_command @OUTPUT@"
 994           ;;
 995         esac
 996
 997         case $prev in
 998         dlfiles|dlprefiles)
 999           if test "$preload" = no; then
1000             # Add the symbol object into the linking commands.
1001             compile_command="$compile_command @SYMFILE@"
1002             finalize_command="$finalize_command @SYMFILE@"
1003             preload=yes
1004           fi
1005           case $arg in
1006           *.la | *.lo) ;;  # We handle these cases below.
1007           force)
1008             if test "$dlself" = no; then
1009               dlself=needless
1010               export_dynamic=yes
1011             fi
1012             prev=
1013             continue
1014             ;;
1015           self)
1016             if test "$prev" = dlprefiles; then
1017               dlself=yes
1018             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
1019               dlself=yes
1020             else
1021               dlself=needless
1022               export_dynamic=yes
1023             fi
1024             prev=
1025             continue
1026             ;;
1027           *)
1028             if test "$prev" = dlfiles; then
1029               dlfiles="$dlfiles $arg"
1030             else
1031               dlprefiles="$dlprefiles $arg"
1032             fi
1033             prev=
1034             continue
1035             ;;
1036           esac
1037           ;;
1038         expsyms)
1039           export_symbols="$arg"
1040           if test ! -f "$arg"; then
1041             $echo "$modename: symbol file \`$arg' does not exist"
1042             exit 1
1043           fi
1044           prev=
1045           continue
1046           ;;
1047         expsyms_regex)
1048           export_symbols_regex="$arg"
1049           prev=
1050           continue
1051           ;;
1052         inst_prefix)
1053           inst_prefix_dir="$arg"
1054           prev=
1055           continue
1056           ;;
1057         precious_regex)
1058           precious_files_regex="$arg"
1059           prev=
1060           continue
1061           ;;
1062         release)
1063           release="-$arg"
1064           prev=
1065           continue
1066           ;;
1067         objectlist)
1068           if test -f "$arg"; then
1069             save_arg=$arg
1070             moreargs=
1071             for fil in `cat $save_arg`
1072             do
1073 #             moreargs="$moreargs $fil"
1074               arg=$fil
1075               # A libtool-controlled object.
1076
1077               # Check to see that this really is a libtool object.
1078               if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1079                 pic_object=
1080                 non_pic_object=
1081
1082                 # Read the .lo file
1083                 # If there is no directory component, then add one.
1084                 case $arg in
1085                 */* | *\\*) . $arg ;;
1086                 *) . ./$arg ;;
1087                 esac
1088
1089                 if test -z "$pic_object" || \
1090                    test -z "$non_pic_object" ||
1091                    test "$pic_object" = none && \
1092                    test "$non_pic_object" = none; then
1093                   $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1094                   exit 1
1095                 fi
1096
1097                 # Extract subdirectory from the argument.
1098                 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1099                 if test "X$xdir" = "X$arg"; then
1100                   xdir=
1101                 else
1102                   xdir="$xdir/"
1103                 fi
1104
1105                 if test "$pic_object" != none; then
1106                   # Prepend the subdirectory the object is found in.
1107                   pic_object="$xdir$pic_object"
1108
1109                   if test "$prev" = dlfiles; then
1110                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1111                       dlfiles="$dlfiles $pic_object"
1112                       prev=
1113                       continue
1114                     else
1115                       # If libtool objects are unsupported, then we need to preload.
1116                       prev=dlprefiles
1117                     fi
1118                   fi
1119
1120                   # CHECK ME:  I think I busted this.  -Ossama
1121                   if test "$prev" = dlprefiles; then
1122                     # Preload the old-style object.
1123                     dlprefiles="$dlprefiles $pic_object"
1124                     prev=
1125                   fi
1126
1127                   # A PIC object.
1128                   libobjs="$libobjs $pic_object"
1129                   arg="$pic_object"
1130                 fi
1131
1132                 # Non-PIC object.
1133                 if test "$non_pic_object" != none; then
1134                   # Prepend the subdirectory the object is found in.
1135                   non_pic_object="$xdir$non_pic_object"
1136
1137                   # A standard non-PIC object
1138                   non_pic_objects="$non_pic_objects $non_pic_object"
1139                   if test -z "$pic_object" || test "$pic_object" = none ; then
1140                     arg="$non_pic_object"
1141                   fi
1142                 fi
1143               else
1144                 # Only an error if not doing a dry-run.
1145                 if test -z "$run"; then
1146                   $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1147                   exit 1
1148                 else
1149                   # Dry-run case.
1150
1151                   # Extract subdirectory from the argument.
1152                   xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1153                   if test "X$xdir" = "X$arg"; then
1154                     xdir=
1155                   else
1156                     xdir="$xdir/"
1157                   fi
1158
1159                   pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1160                   non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1161                   libobjs="$libobjs $pic_object"
1162                   non_pic_objects="$non_pic_objects $non_pic_object"
1163                 fi
1164               fi
1165             done
1166           else
1167             $echo "$modename: link input file \`$save_arg' does not exist"
1168             exit 1
1169           fi
1170           arg=$save_arg
1171           prev=
1172           continue
1173           ;;
1174         rpath | xrpath)
1175           # We need an absolute path.
1176           case $arg in
1177           [\\/]* | [A-Za-z]:[\\/]*) ;;
1178           *)
1179             $echo "$modename: only absolute run-paths are allowed" 1>&2
1180             exit 1
1181             ;;
1182           esac
1183           if test "$prev" = rpath; then
1184             case "$rpath " in
1185             *" $arg "*) ;;
1186             *) rpath="$rpath $arg" ;;
1187             esac
1188           else
1189             case "$xrpath " in
1190             *" $arg "*) ;;
1191             *) xrpath="$xrpath $arg" ;;
1192             esac
1193           fi
1194           prev=
1195           continue
1196           ;;
1197         xcompiler)
1198           compiler_flags="$compiler_flags $qarg"
1199           prev=
1200           compile_command="$compile_command $qarg"
1201           finalize_command="$finalize_command $qarg"
1202           continue
1203           ;;
1204         xlinker)
1205           linker_flags="$linker_flags $qarg"
1206           compiler_flags="$compiler_flags $wl$qarg"
1207           prev=
1208           compile_command="$compile_command $wl$qarg"
1209           finalize_command="$finalize_command $wl$qarg"
1210           continue
1211           ;;
1212         xcclinker)
1213           linker_flags="$linker_flags $qarg"
1214           compiler_flags="$compiler_flags $qarg"
1215           prev=
1216           compile_command="$compile_command $qarg"
1217           finalize_command="$finalize_command $qarg"
1218           continue
1219           ;;
1220         *)
1221           eval "$prev=\"\$arg\""
1222           prev=
1223           continue
1224           ;;
1225         esac
1226       fi # test -n "$prev"
1227
1228       prevarg="$arg"
1229
1230       case $arg in
1231       -all-static)
1232         if test -n "$link_static_flag"; then
1233           compile_command="$compile_command $link_static_flag"
1234           finalize_command="$finalize_command $link_static_flag"
1235         fi
1236         continue
1237         ;;
1238
1239       -allow-undefined)
1240         # FIXME: remove this flag sometime in the future.
1241         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1242         continue
1243         ;;
1244
1245       -avoid-version)
1246         avoid_version=yes
1247         continue
1248         ;;
1249
1250       -dlopen)
1251         prev=dlfiles
1252         continue
1253         ;;
1254
1255       -dlpreopen)
1256         prev=dlprefiles
1257         continue
1258         ;;
1259
1260       -export-dynamic)
1261         export_dynamic=yes
1262         continue
1263         ;;
1264
1265       -export-symbols | -export-symbols-regex)
1266         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1267           $echo "$modename: more than one -exported-symbols argument is not allowed"
1268           exit 1
1269         fi
1270         if test "X$arg" = "X-export-symbols"; then
1271           prev=expsyms
1272         else
1273           prev=expsyms_regex
1274         fi
1275         continue
1276         ;;
1277
1278       -inst-prefix-dir)
1279         prev=inst_prefix
1280         continue
1281         ;;
1282
1283       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1284       # so, if we see these flags be careful not to treat them like -L
1285       -L[A-Z][A-Z]*:*)
1286         case $with_gcc/$host in
1287         no/*-*-irix* | /*-*-irix*)
1288           compile_command="$compile_command $arg"
1289           finalize_command="$finalize_command $arg"
1290           ;;
1291         esac
1292         continue
1293         ;;
1294
1295       -L*)
1296         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1297         # We need an absolute path.
1298         case $dir in
1299         [\\/]* | [A-Za-z]:[\\/]*) ;;
1300         *)
1301           absdir=`cd "$dir" && pwd`
1302           if test -z "$absdir"; then
1303             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1304             exit 1
1305           fi
1306           dir="$absdir"
1307           ;;
1308         esac
1309         case "$deplibs " in
1310         *" -L$dir "*) ;;
1311         *)
1312           deplibs="$deplibs -L$dir"
1313           lib_search_path="$lib_search_path $dir"
1314           ;;
1315         esac
1316         case $host in
1317         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1318           case :$dllsearchpath: in
1319           *":$dir:"*) ;;
1320           *) dllsearchpath="$dllsearchpath:$dir";;
1321           esac
1322           ;;
1323         esac
1324         continue
1325         ;;
1326
1327       -l*)
1328         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1329           case $host in
1330           *-*-cygwin* | *-*-pw32* | *-*-beos*)
1331             # These systems don't actually have a C or math library (as such)
1332             continue
1333             ;;
1334           *-*-mingw* | *-*-os2*)
1335             # These systems don't actually have a C library (as such)
1336             test "X$arg" = "X-lc" && continue
1337             ;;
1338           *-*-openbsd* | *-*-freebsd*)
1339             # Do not include libc due to us having libc/libc_r.
1340             test "X$arg" = "X-lc" && continue
1341             ;;
1342           *-*-rhapsody* | *-*-darwin1.[012])
1343             # Rhapsody C and math libraries are in the System framework
1344             deplibs="$deplibs -framework System"
1345             continue
1346           esac
1347         elif test "X$arg" = "X-lc_r"; then
1348          case $host in
1349          *-*-openbsd* | *-*-freebsd*)
1350            # Do not include libc_r directly, use -pthread flag.
1351            continue
1352            ;;
1353          esac
1354         fi
1355         deplibs="$deplibs $arg"
1356         continue
1357         ;;
1358
1359      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1360         deplibs="$deplibs $arg"
1361         continue
1362         ;;
1363
1364       -module)
1365         module=yes
1366         continue
1367         ;;
1368
1369       # gcc -m* arguments should be passed to the linker via $compiler_flags
1370       # in order to pass architecture information to the linker
1371       # (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo
1372       # but this is not reliable with gcc because gcc may use -mfoo to
1373       # select a different linker, different libraries, etc, while
1374       # -Wl,-mfoo simply passes -mfoo to the linker.
1375       -m*)
1376         # Unknown arguments in both finalize_command and compile_command need
1377         # to be aesthetically quoted because they are evaled later.
1378         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1379         case $arg in
1380         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1381           arg="\"$arg\""
1382           ;;
1383         esac
1384         compile_command="$compile_command $arg"
1385         finalize_command="$finalize_command $arg"
1386         if test "$with_gcc" = "yes" ; then
1387           compiler_flags="$compiler_flags $arg"
1388         fi
1389         continue
1390         ;;
1391
1392       -shrext)
1393         prev=shrext
1394         continue
1395         ;;
1396
1397       -no-fast-install)
1398         fast_install=no
1399         continue
1400         ;;
1401
1402       -no-install)
1403         case $host in
1404         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1405           # The PATH hackery in wrapper scripts is required on Windows
1406           # in order for the loader to find any dlls it needs.
1407           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1408           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1409           fast_install=no
1410           ;;
1411         *) no_install=yes ;;
1412         esac
1413         continue
1414         ;;
1415
1416       -no-undefined)
1417         allow_undefined=no
1418         continue
1419         ;;
1420
1421       -objectlist)
1422         prev=objectlist
1423         continue
1424         ;;
1425
1426       -o) prev=output ;;
1427
1428       -precious-files-regex)
1429         prev=precious_regex
1430         continue
1431         ;;
1432
1433       -release)
1434         prev=release
1435         continue
1436         ;;
1437
1438       -rpath)
1439         prev=rpath
1440         continue
1441         ;;
1442
1443       -R)
1444         prev=xrpath
1445         continue
1446         ;;
1447
1448       -R*)
1449         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1450         # We need an absolute path.
1451         case $dir in
1452         [\\/]* | [A-Za-z]:[\\/]*) ;;
1453         *)
1454           $echo "$modename: only absolute run-paths are allowed" 1>&2
1455           exit 1
1456           ;;
1457         esac
1458         case "$xrpath " in
1459         *" $dir "*) ;;
1460         *) xrpath="$xrpath $dir" ;;
1461         esac
1462         continue
1463         ;;
1464
1465       -static)
1466         # The effects of -static are defined in a previous loop.
1467         # We used to do the same as -all-static on platforms that
1468         # didn't have a PIC flag, but the assumption that the effects
1469         # would be equivalent was wrong.  It would break on at least
1470         # Digital Unix and AIX.
1471         continue
1472         ;;
1473
1474       -thread-safe)
1475         thread_safe=yes
1476         continue
1477         ;;
1478
1479       -version-info)
1480         prev=vinfo
1481         continue
1482         ;;
1483       -version-number)
1484         prev=vinfo
1485         vinfo_number=yes
1486         continue
1487         ;;
1488
1489       -Wc,*)
1490         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1491         arg=
1492         save_ifs="$IFS"; IFS=','
1493         for flag in $args; do
1494           IFS="$save_ifs"
1495           case $flag in
1496             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1497             flag="\"$flag\""
1498             ;;
1499           esac
1500           arg="$arg $wl$flag"
1501           compiler_flags="$compiler_flags $flag"
1502         done
1503         IFS="$save_ifs"
1504         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1505         ;;
1506
1507       -Wl,*)
1508         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1509         arg=
1510         save_ifs="$IFS"; IFS=','
1511         for flag in $args; do
1512           IFS="$save_ifs"
1513           case $flag in
1514             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1515             flag="\"$flag\""
1516             ;;
1517           esac
1518           arg="$arg $wl$flag"
1519           compiler_flags="$compiler_flags $wl$flag"
1520           linker_flags="$linker_flags $flag"
1521         done
1522         IFS="$save_ifs"
1523         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1524         ;;
1525
1526       -Xcompiler)
1527         prev=xcompiler
1528         continue
1529         ;;
1530
1531       -Xlinker)
1532         prev=xlinker
1533         continue
1534         ;;
1535
1536       -XCClinker)
1537         prev=xcclinker
1538         continue
1539         ;;
1540
1541       # Some other compiler flag.
1542       -* | +*)
1543         # Unknown arguments in both finalize_command and compile_command need
1544         # to be aesthetically quoted because they are evaled later.
1545         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1546         case $arg in
1547         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1548           arg="\"$arg\""
1549           ;;
1550         esac
1551         ;;
1552
1553       *.$objext)
1554         # A standard object.
1555         objs="$objs $arg"
1556         ;;
1557
1558       *.lo)
1559         # A libtool-controlled object.
1560
1561         # Check to see that this really is a libtool object.
1562         if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1563           pic_object=
1564           non_pic_object=
1565
1566           # Read the .lo file
1567           # If there is no directory component, then add one.
1568           case $arg in
1569           */* | *\\*) . $arg ;;
1570           *) . ./$arg ;;
1571           esac
1572
1573           if test -z "$pic_object" || \
1574              test -z "$non_pic_object" ||
1575              test "$pic_object" = none && \
1576              test "$non_pic_object" = none; then
1577             $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1578             exit 1
1579           fi
1580
1581           # Extract subdirectory from the argument.
1582           xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1583           if test "X$xdir" = "X$arg"; then
1584             xdir=
1585           else
1586             xdir="$xdir/"
1587           fi
1588
1589           if test "$pic_object" != none; then
1590             # Prepend the subdirectory the object is found in.
1591             pic_object="$xdir$pic_object"
1592
1593             if test "$prev" = dlfiles; then
1594               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1595                 dlfiles="$dlfiles $pic_object"
1596                 prev=
1597                 continue
1598               else
1599                 # If libtool objects are unsupported, then we need to preload.
1600                 prev=dlprefiles
1601               fi
1602             fi
1603
1604             # CHECK ME:  I think I busted this.  -Ossama
1605             if test "$prev" = dlprefiles; then
1606               # Preload the old-style object.
1607               dlprefiles="$dlprefiles $pic_object"
1608               prev=
1609             fi
1610
1611             # A PIC object.
1612             libobjs="$libobjs $pic_object"
1613             arg="$pic_object"
1614           fi
1615
1616           # Non-PIC object.
1617           if test "$non_pic_object" != none; then
1618             # Prepend the subdirectory the object is found in.
1619             non_pic_object="$xdir$non_pic_object"
1620
1621             # A standard non-PIC object
1622             non_pic_objects="$non_pic_objects $non_pic_object"
1623             if test -z "$pic_object" || test "$pic_object" = none ; then
1624               arg="$non_pic_object"
1625             fi
1626           fi
1627         else
1628           # Only an error if not doing a dry-run.
1629           if test -z "$run"; then
1630             $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1631             exit 1
1632           else
1633             # Dry-run case.
1634
1635             # Extract subdirectory from the argument.
1636             xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1637             if test "X$xdir" = "X$arg"; then
1638               xdir=
1639             else
1640               xdir="$xdir/"
1641             fi
1642
1643             pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1644             non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1645             libobjs="$libobjs $pic_object"
1646             non_pic_objects="$non_pic_objects $non_pic_object"
1647           fi
1648         fi
1649         ;;
1650
1651       *.$libext)
1652         # An archive.
1653         deplibs="$deplibs $arg"
1654         old_deplibs="$old_deplibs $arg"
1655         continue
1656         ;;
1657
1658       *.la)
1659         # A libtool-controlled library.
1660
1661         if test "$prev" = dlfiles; then
1662           # This library was specified with -dlopen.
1663           dlfiles="$dlfiles $arg"
1664           prev=
1665         elif test "$prev" = dlprefiles; then
1666           # The library was specified with -dlpreopen.
1667           dlprefiles="$dlprefiles $arg"
1668           prev=
1669         else
1670           deplibs="$deplibs $arg"
1671         fi
1672         continue
1673         ;;
1674
1675       # Some other compiler argument.
1676       *)
1677         # Unknown arguments in both finalize_command and compile_command need
1678         # to be aesthetically quoted because they are evaled later.
1679         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1680         case $arg in
1681         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1682           arg="\"$arg\""
1683           ;;
1684         esac
1685         ;;
1686       esac # arg
1687
1688       # Now actually substitute the argument into the commands.
1689       if test -n "$arg"; then
1690         compile_command="$compile_command $arg"
1691         finalize_command="$finalize_command $arg"
1692       fi
1693     done # argument parsing loop
1694
1695     if test -n "$prev"; then
1696       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1697       $echo "$help" 1>&2
1698       exit 1
1699     fi
1700
1701     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1702       eval arg=\"$export_dynamic_flag_spec\"
1703       compile_command="$compile_command $arg"
1704       finalize_command="$finalize_command $arg"
1705     fi
1706
1707     oldlibs=
1708     # calculate the name of the file, without its directory
1709     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1710     libobjs_save="$libobjs"
1711
1712     if test -n "$shlibpath_var"; then
1713       # get the directories listed in $shlibpath_var
1714       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1715     else
1716       shlib_search_path=
1717     fi
1718     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1719     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1720
1721     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1722     if test "X$output_objdir" = "X$output"; then
1723       output_objdir="$objdir"
1724     else
1725       output_objdir="$output_objdir/$objdir"
1726     fi
1727     # Create the object directory.
1728     if test ! -d "$output_objdir"; then
1729       $show "$mkdir $output_objdir"
1730       $run $mkdir $output_objdir
1731       status=$?
1732       if test "$status" -ne 0 && test ! -d "$output_objdir"; then
1733         exit $status
1734       fi
1735     fi
1736
1737     # Determine the type of output
1738     case $output in
1739     "")
1740       $echo "$modename: you must specify an output file" 1>&2
1741       $echo "$help" 1>&2
1742       exit 1
1743       ;;
1744     *.$libext) linkmode=oldlib ;;
1745     *.lo | *.$objext) linkmode=obj ;;
1746     *.la) linkmode=lib ;;
1747     *) linkmode=prog ;; # Anything else should be a program.
1748     esac
1749
1750     case $host in
1751     *cygwin* | *mingw* | *pw32*)
1752       # don't eliminate duplcations in $postdeps and $predeps
1753       duplicate_compiler_generated_deps=yes
1754       ;;
1755     *)
1756       duplicate_compiler_generated_deps=$duplicate_deps
1757       ;;
1758     esac
1759     specialdeplibs=
1760
1761     libs=
1762     # Find all interdependent deplibs by searching for libraries
1763     # that are linked more than once (e.g. -la -lb -la)
1764     for deplib in $deplibs; do
1765       if test "X$duplicate_deps" = "Xyes" ; then
1766         case "$libs " in
1767         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1768         esac
1769       fi
1770       libs="$libs $deplib"
1771     done
1772
1773     if test "$linkmode" = lib; then
1774       libs="$predeps $libs $compiler_lib_search_path $postdeps"
1775
1776       # Compute libraries that are listed more than once in $predeps
1777       # $postdeps and mark them as special (i.e., whose duplicates are
1778       # not to be eliminated).
1779       pre_post_deps=
1780       if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
1781         for pre_post_dep in $predeps $postdeps; do
1782           case "$pre_post_deps " in
1783           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1784           esac
1785           pre_post_deps="$pre_post_deps $pre_post_dep"
1786         done
1787       fi
1788       pre_post_deps=
1789     fi
1790
1791     deplibs=
1792     newdependency_libs=
1793     newlib_search_path=
1794     need_relink=no # whether we're linking any uninstalled libtool libraries
1795     notinst_deplibs= # not-installed libtool libraries
1796     notinst_path= # paths that contain not-installed libtool libraries
1797     case $linkmode in
1798     lib)
1799         passes="conv link"
1800         for file in $dlfiles $dlprefiles; do
1801           case $file in
1802           *.la) ;;
1803           *)
1804             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1805             exit 1
1806             ;;
1807           esac
1808         done
1809         ;;
1810     prog)
1811         compile_deplibs=
1812         finalize_deplibs=
1813         alldeplibs=no
1814         newdlfiles=
1815         newdlprefiles=
1816         passes="conv scan dlopen dlpreopen link"
1817         ;;
1818     *)  passes="conv"
1819         ;;
1820     esac
1821     for pass in $passes; do
1822       if test "$linkmode,$pass" = "lib,link" ||
1823          test "$linkmode,$pass" = "prog,scan"; then
1824         libs="$deplibs"
1825         deplibs=
1826       fi
1827       if test "$linkmode" = prog; then
1828         case $pass in
1829         dlopen) libs="$dlfiles" ;;
1830         dlpreopen) libs="$dlprefiles" ;;
1831         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1832         esac
1833       fi
1834       if test "$pass" = dlopen; then
1835         # Collect dlpreopened libraries
1836         save_deplibs="$deplibs"
1837         deplibs=
1838       fi
1839       for deplib in $libs; do
1840         lib=
1841         found=no
1842         case $deplib in
1843         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1844           if test "$linkmode,$pass" = "prog,link"; then
1845             compile_deplibs="$deplib $compile_deplibs"
1846             finalize_deplibs="$deplib $finalize_deplibs"
1847           else
1848             deplibs="$deplib $deplibs"
1849           fi
1850           continue
1851           ;;
1852         -l*)
1853           if test "$linkmode" != lib && test "$linkmode" != prog; then
1854             $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
1855             continue
1856           fi
1857           if test "$pass" = conv; then
1858             deplibs="$deplib $deplibs"
1859             continue
1860           fi
1861           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1862           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1863             for search_ext in .la $shrext .so .a; do
1864               # Search the libtool library
1865               lib="$searchdir/lib${name}${search_ext}"
1866               if test -f "$lib"; then
1867                 if test "$search_ext" = ".la"; then
1868                   found=yes
1869                 else
1870                   found=no
1871                 fi
1872                 break 2
1873               fi
1874             done
1875           done
1876           if test "$found" != yes; then
1877             # deplib doesn't seem to be a libtool library
1878             if test "$linkmode,$pass" = "prog,link"; then
1879               compile_deplibs="$deplib $compile_deplibs"
1880               finalize_deplibs="$deplib $finalize_deplibs"
1881             else
1882               deplibs="$deplib $deplibs"
1883               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1884             fi
1885             continue
1886           else # deplib is a libtool library
1887             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
1888             # We need to do some special things here, and not later.
1889             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
1890               case " $predeps $postdeps " in
1891               *" $deplib "*)
1892                 if (${SED} -e '2q' $lib |
1893                     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1894                   library_names=
1895                   old_library=
1896                   case $lib in
1897                   */* | *\\*) . $lib ;;
1898                   *) . ./$lib ;;
1899                   esac
1900                   for l in $old_library $library_names; do
1901                     ll="$l"
1902                   done
1903                   if test "X$ll" = "X$old_library" ; then # only static version available
1904                     found=no
1905                     ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1906                     test "X$ladir" = "X$lib" && ladir="."
1907                     lib=$ladir/$old_library
1908                     if test "$linkmode,$pass" = "prog,link"; then
1909                       compile_deplibs="$deplib $compile_deplibs"
1910                       finalize_deplibs="$deplib $finalize_deplibs"
1911                     else
1912                       deplibs="$deplib $deplibs"
1913                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1914                     fi
1915                     continue
1916                   fi
1917                 fi
1918                 ;;
1919               *) ;;
1920               esac
1921             fi
1922           fi
1923           ;; # -l
1924         -L*)
1925           case $linkmode in
1926           lib)
1927             deplibs="$deplib $deplibs"
1928             test "$pass" = conv && continue
1929             newdependency_libs="$deplib $newdependency_libs"
1930             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1931             ;;
1932           prog)
1933             if test "$pass" = conv; then
1934               deplibs="$deplib $deplibs"
1935               continue
1936             fi
1937             if test "$pass" = scan; then
1938               deplibs="$deplib $deplibs"
1939               newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1940             else
1941               compile_deplibs="$deplib $compile_deplibs"
1942               finalize_deplibs="$deplib $finalize_deplibs"
1943             fi
1944             ;;
1945           *)
1946             $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
1947             ;;
1948           esac # linkmode
1949           continue
1950           ;; # -L
1951         -R*)
1952           if test "$pass" = link; then
1953             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1954             # Make sure the xrpath contains only unique directories.
1955             case "$xrpath " in
1956             *" $dir "*) ;;
1957             *) xrpath="$xrpath $dir" ;;
1958             esac
1959           fi
1960           deplibs="$deplib $deplibs"
1961           continue
1962           ;;
1963         *.la) lib="$deplib" ;;
1964         *.$libext)
1965           if test "$pass" = conv; then
1966             deplibs="$deplib $deplibs"
1967             continue
1968           fi
1969           case $linkmode in
1970           lib)
1971             if test "$deplibs_check_method" != pass_all; then
1972               $echo
1973               $echo "*** Warning: Trying to link with static lib archive $deplib."
1974               $echo "*** I have the capability to make that library automatically link in when"
1975               $echo "*** you link to this library.  But I can only do this if you have a"
1976               $echo "*** shared version of the library, which you do not appear to have"
1977               $echo "*** because the file extensions .$libext of this argument makes me believe"
1978               $echo "*** that it is just a static archive that I should not used here."
1979             else
1980               $echo
1981               $echo "*** Warning: Linking the shared library $output against the"
1982               $echo "*** static library $deplib is not portable!"
1983               deplibs="$deplib $deplibs"
1984             fi
1985             continue
1986             ;;
1987           prog)
1988             if test "$pass" != link; then
1989               deplibs="$deplib $deplibs"
1990             else
1991               compile_deplibs="$deplib $compile_deplibs"
1992               finalize_deplibs="$deplib $finalize_deplibs"
1993             fi
1994             continue
1995             ;;
1996           esac # linkmode
1997           ;; # *.$libext
1998         *.lo | *.$objext)
1999           if test "$pass" = conv; then
2000             deplibs="$deplib $deplibs"
2001           elif test "$linkmode" = prog; then
2002             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2003               # If there is no dlopen support or we're linking statically,
2004               # we need to preload.
2005               newdlprefiles="$newdlprefiles $deplib"
2006               compile_deplibs="$deplib $compile_deplibs"
2007               finalize_deplibs="$deplib $finalize_deplibs"
2008             else
2009               newdlfiles="$newdlfiles $deplib"
2010             fi
2011           fi
2012           continue
2013           ;;
2014         %DEPLIBS%)
2015           alldeplibs=yes
2016           continue
2017           ;;
2018         esac # case $deplib
2019         if test "$found" = yes || test -f "$lib"; then :
2020         else
2021           $echo "$modename: cannot find the library \`$lib'" 1>&2
2022           exit 1
2023         fi
2024
2025         # Check to see that this really is a libtool archive.
2026         if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2027         else
2028           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2029           exit 1
2030         fi
2031
2032         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2033         test "X$ladir" = "X$lib" && ladir="."
2034
2035         dlname=
2036         dlopen=
2037         dlpreopen=
2038         libdir=
2039         library_names=
2040         old_library=
2041         # If the library was installed with an old release of libtool,
2042         # it will not redefine variables installed, or shouldnotlink
2043         installed=yes
2044         shouldnotlink=no
2045
2046         # Read the .la file
2047         case $lib in
2048         */* | *\\*) . $lib ;;
2049         *) . ./$lib ;;
2050         esac
2051
2052         if test "$linkmode,$pass" = "lib,link" ||
2053            test "$linkmode,$pass" = "prog,scan" ||
2054            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2055           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2056           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2057         fi
2058
2059         if test "$pass" = conv; then
2060           # Only check for convenience libraries
2061           deplibs="$lib $deplibs"
2062           if test -z "$libdir"; then
2063             if test -z "$old_library"; then
2064               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2065               exit 1
2066             fi
2067             # It is a libtool convenience library, so add in its objects.
2068             convenience="$convenience $ladir/$objdir/$old_library"
2069             old_convenience="$old_convenience $ladir/$objdir/$old_library"
2070             tmp_libs=
2071             for deplib in $dependency_libs; do
2072               deplibs="$deplib $deplibs"
2073               if test "X$duplicate_deps" = "Xyes" ; then
2074                 case "$tmp_libs " in
2075                 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2076                 esac
2077               fi
2078               tmp_libs="$tmp_libs $deplib"
2079             done
2080           elif test "$linkmode" != prog && test "$linkmode" != lib; then
2081             $echo "$modename: \`$lib' is not a convenience library" 1>&2
2082             exit 1
2083           fi
2084           continue
2085         fi # $pass = conv
2086
2087
2088         # Get the name of the library we link against.
2089         linklib=
2090         for l in $old_library $library_names; do
2091           linklib="$l"
2092         done
2093         if test -z "$linklib"; then
2094           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2095           exit 1
2096         fi
2097
2098         # This library was specified with -dlopen.
2099         if test "$pass" = dlopen; then
2100           if test -z "$libdir"; then
2101             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2102             exit 1
2103           fi
2104           if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2105             # If there is no dlname, no dlopen support or we're linking
2106             # statically, we need to preload.  We also need to preload any
2107             # dependent libraries so libltdl's deplib preloader doesn't
2108             # bomb out in the load deplibs phase.
2109             dlprefiles="$dlprefiles $lib $dependency_libs"
2110           else
2111             newdlfiles="$newdlfiles $lib"
2112           fi
2113           continue
2114         fi # $pass = dlopen
2115
2116         # We need an absolute path.
2117         case $ladir in
2118         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2119         *)
2120           abs_ladir=`cd "$ladir" && pwd`
2121           if test -z "$abs_ladir"; then
2122             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2123             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2124             abs_ladir="$ladir"
2125           fi
2126           ;;
2127         esac
2128         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2129
2130         # Find the relevant object directory and library name.
2131         if test "X$installed" = Xyes; then
2132           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2133             $echo "$modename: warning: library \`$lib' was moved." 1>&2
2134             dir="$ladir"
2135             absdir="$abs_ladir"
2136             libdir="$abs_ladir"
2137           else
2138             dir="$libdir"
2139             absdir="$libdir"
2140           fi
2141         else
2142           dir="$ladir/$objdir"
2143           absdir="$abs_ladir/$objdir"
2144           # Remove this search path later
2145           notinst_path="$notinst_path $abs_ladir"
2146         fi # $installed = yes
2147         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2148
2149         # This library was specified with -dlpreopen.
2150         if test "$pass" = dlpreopen; then
2151           if test -z "$libdir"; then
2152             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2153             exit 1
2154           fi
2155           # Prefer using a static library (so that no silly _DYNAMIC symbols
2156           # are required to link).
2157           if test -n "$old_library"; then
2158             newdlprefiles="$newdlprefiles $dir/$old_library"
2159           # Otherwise, use the dlname, so that lt_dlopen finds it.
2160           elif test -n "$dlname"; then
2161             newdlprefiles="$newdlprefiles $dir/$dlname"
2162           else
2163             newdlprefiles="$newdlprefiles $dir/$linklib"
2164           fi
2165         fi # $pass = dlpreopen
2166
2167         if test -z "$libdir"; then
2168           # Link the convenience library
2169           if test "$linkmode" = lib; then
2170             deplibs="$dir/$old_library $deplibs"
2171           elif test "$linkmode,$pass" = "prog,link"; then
2172             compile_deplibs="$dir/$old_library $compile_deplibs"
2173             finalize_deplibs="$dir/$old_library $finalize_deplibs"
2174           else
2175             deplibs="$lib $deplibs" # used for prog,scan pass
2176           fi
2177           continue
2178         fi
2179
2180
2181         if test "$linkmode" = prog && test "$pass" != link; then
2182           newlib_search_path="$newlib_search_path $ladir"
2183           deplibs="$lib $deplibs"
2184
2185           linkalldeplibs=no
2186           if test "$link_all_deplibs" != no || test -z "$library_names" ||
2187              test "$build_libtool_libs" = no; then
2188             linkalldeplibs=yes
2189           fi
2190
2191           tmp_libs=
2192           for deplib in $dependency_libs; do
2193             case $deplib in
2194             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2195             esac
2196             # Need to link against all dependency_libs?
2197             if test "$linkalldeplibs" = yes; then
2198               deplibs="$deplib $deplibs"
2199             else
2200               # Need to hardcode shared library paths
2201               # or/and link against static libraries
2202               newdependency_libs="$deplib $newdependency_libs"
2203             fi
2204             if test "X$duplicate_deps" = "Xyes" ; then
2205               case "$tmp_libs " in
2206               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2207               esac
2208             fi
2209             tmp_libs="$tmp_libs $deplib"
2210           done # for deplib
2211           continue
2212         fi # $linkmode = prog...
2213
2214         if test "$linkmode,$pass" = "prog,link"; then
2215           if test -n "$library_names" &&
2216              { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2217             # We need to hardcode the library path
2218             if test -n "$shlibpath_var"; then
2219               # Make sure the rpath contains only unique directories.
2220               case "$temp_rpath " in
2221               *" $dir "*) ;;
2222               *" $absdir "*) ;;
2223               *) temp_rpath="$temp_rpath $dir" ;;
2224               esac
2225             fi
2226
2227             # Hardcode the library path.
2228             # Skip directories that are in the system default run-time
2229             # search path.
2230             case " $sys_lib_dlsearch_path " in
2231             *" $absdir "*) ;;
2232             *)
2233               case "$compile_rpath " in
2234               *" $absdir "*) ;;
2235               *) compile_rpath="$compile_rpath $absdir"
2236               esac
2237               ;;
2238             esac
2239             case " $sys_lib_dlsearch_path " in
2240             *" $libdir "*) ;;
2241             *)
2242               case "$finalize_rpath " in
2243               *" $libdir "*) ;;
2244               *) finalize_rpath="$finalize_rpath $libdir"
2245               esac
2246               ;;
2247             esac
2248           fi # $linkmode,$pass = prog,link...
2249
2250           if test "$alldeplibs" = yes &&
2251              { test "$deplibs_check_method" = pass_all ||
2252                { test "$build_libtool_libs" = yes &&
2253                  test -n "$library_names"; }; }; then
2254             # We only need to search for static libraries
2255             continue
2256           fi
2257         fi
2258
2259         link_static=no # Whether the deplib will be linked statically
2260         if test -n "$library_names" &&
2261            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2262           if test "$installed" = no; then
2263             notinst_deplibs="$notinst_deplibs $lib"
2264             need_relink=yes
2265           fi
2266           # This is a shared library
2267
2268       # Warn about portability, can't link against -module's on some systems (darwin)
2269       if test "$shouldnotlink" = yes && test "$pass" = link ; then
2270             $echo
2271             if test "$linkmode" = prog; then
2272               $echo "*** Warning: Linking the executable $output against the loadable module"
2273             else
2274               $echo "*** Warning: Linking the shared library $output against the loadable module"
2275             fi
2276             $echo "*** $linklib is not portable!"
2277       fi
2278           if test "$linkmode" = lib &&
2279              test "$hardcode_into_libs" = yes; then
2280             # Hardcode the library path.
2281             # Skip directories that are in the system default run-time
2282             # search path.
2283             case " $sys_lib_dlsearch_path " in
2284             *" $absdir "*) ;;
2285             *)
2286               case "$compile_rpath " in
2287               *" $absdir "*) ;;
2288               *) compile_rpath="$compile_rpath $absdir"
2289               esac
2290               ;;
2291             esac
2292             case " $sys_lib_dlsearch_path " in
2293             *" $libdir "*) ;;
2294             *)
2295               case "$finalize_rpath " in
2296               *" $libdir "*) ;;
2297               *) finalize_rpath="$finalize_rpath $libdir"
2298               esac
2299               ;;
2300             esac
2301           fi
2302
2303           if test -n "$old_archive_from_expsyms_cmds"; then
2304             # figure out the soname
2305             set dummy $library_names
2306             realname="$2"
2307             shift; shift
2308             libname=`eval \\$echo \"$libname_spec\"`
2309             # use dlname if we got it. it's perfectly good, no?
2310             if test -n "$dlname"; then
2311               soname="$dlname"
2312             elif test -n "$soname_spec"; then
2313               # bleh windows
2314               case $host in
2315               *cygwin* | mingw*)
2316                 major=`expr $current - $age`
2317                 versuffix="-$major"
2318                 ;;
2319               esac
2320               eval soname=\"$soname_spec\"
2321             else
2322               soname="$realname"
2323             fi
2324
2325             # Make a new name for the extract_expsyms_cmds to use
2326             soroot="$soname"
2327             soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2328             newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2329
2330             # If the library has no export list, then create one now
2331             if test -f "$output_objdir/$soname-def"; then :
2332             else
2333               $show "extracting exported symbol list from \`$soname'"
2334               save_ifs="$IFS"; IFS='~'
2335               cmds=$extract_expsyms_cmds
2336               for cmd in $cmds; do
2337                 IFS="$save_ifs"
2338                 eval cmd=\"$cmd\"
2339                 $show "$cmd"
2340                 $run eval "$cmd" || exit $?
2341               done
2342               IFS="$save_ifs"
2343             fi
2344
2345             # Create $newlib
2346             if test -f "$output_objdir/$newlib"; then :; else
2347               $show "generating import library for \`$soname'"
2348               save_ifs="$IFS"; IFS='~'
2349               cmds=$old_archive_from_expsyms_cmds
2350               for cmd in $cmds; do
2351                 IFS="$save_ifs"
2352                 eval cmd=\"$cmd\"
2353                 $show "$cmd"
2354                 $run eval "$cmd" || exit $?
2355               done
2356               IFS="$save_ifs"
2357             fi
2358             # make sure the library variables are pointing to the new library
2359             dir=$output_objdir
2360             linklib=$newlib
2361           fi # test -n "$old_archive_from_expsyms_cmds"
2362
2363           if test "$linkmode" = prog || test "$mode" != relink; then
2364             add_shlibpath=
2365             add_dir=
2366             add=
2367             lib_linked=yes
2368             case $hardcode_action in
2369             immediate | unsupported)
2370               if test "$hardcode_direct" = no; then
2371                 add="$dir/$linklib"
2372                 case $host in
2373                   *-*-sco3.2v5* ) add_dir="-L$dir" ;;
2374                   *-*-darwin* )
2375                     # if the lib is a module then we can not link against it, someone
2376                     # is ignoring the new warnings I added
2377                     if /usr/bin/file -L $add 2> /dev/null | grep "bundle" >/dev/null ; then
2378                       $echo "** Warning, lib $linklib is a module, not a shared library"
2379                       if test -z "$old_library" ; then
2380                         $echo
2381                         $echo "** And there doesn't seem to be a static archive available"
2382                         $echo "** The link will probably fail, sorry"
2383                       else
2384                         add="$dir/$old_library"
2385                       fi
2386                     fi
2387                 esac
2388               elif test "$hardcode_minus_L" = no; then
2389                 case $host in
2390                 *-*-sunos*) add_shlibpath="$dir" ;;
2391                 esac
2392                 add_dir="-L$dir"
2393                 add="-l$name"
2394               elif test "$hardcode_shlibpath_var" = no; then
2395                 add_shlibpath="$dir"
2396                 add="-l$name"
2397               else
2398                 lib_linked=no
2399               fi
2400               ;;
2401             relink)
2402               if test "$hardcode_direct" = yes; then
2403                 add="$dir/$linklib"
2404               elif test "$hardcode_minus_L" = yes; then
2405                 add_dir="-L$dir"
2406                 # Try looking first in the location we're being installed to.
2407                 if test -n "$inst_prefix_dir"; then
2408                   case "$libdir" in
2409                     [\\/]*)
2410                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
2411                       ;;
2412                   esac
2413                 fi
2414                 add="-l$name"
2415               elif test "$hardcode_shlibpath_var" = yes; then
2416                 add_shlibpath="$dir"
2417                 add="-l$name"
2418               else
2419                 lib_linked=no
2420               fi
2421               ;;
2422             *) lib_linked=no ;;
2423             esac
2424
2425             if test "$lib_linked" != yes; then
2426               $echo "$modename: configuration error: unsupported hardcode properties"
2427               exit 1
2428             fi
2429
2430             if test -n "$add_shlibpath"; then
2431               case :$compile_shlibpath: in
2432               *":$add_shlibpath:"*) ;;
2433               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2434               esac
2435             fi
2436             if test "$linkmode" = prog; then
2437               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2438               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2439             else
2440               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2441               test -n "$add" && deplibs="$add $deplibs"
2442               if test "$hardcode_direct" != yes && \
2443                  test "$hardcode_minus_L" != yes && \
2444                  test "$hardcode_shlibpath_var" = yes; then
2445                 case :$finalize_shlibpath: in
2446                 *":$libdir:"*) ;;
2447                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2448                 esac
2449               fi
2450             fi
2451           fi
2452
2453           if test "$linkmode" = prog || test "$mode" = relink; then
2454             add_shlibpath=
2455             add_dir=
2456             add=
2457             # Finalize command for both is simple: just hardcode it.
2458             if test "$hardcode_direct" = yes; then
2459               add="$libdir/$linklib"
2460             elif test "$hardcode_minus_L" = yes; then
2461               add_dir="-L$libdir"
2462               add="-l$name"
2463             elif test "$hardcode_shlibpath_var" = yes; then
2464               case :$finalize_shlibpath: in
2465               *":$libdir:"*) ;;
2466               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2467               esac
2468               add="-l$name"
2469             elif test "$hardcode_automatic" = yes; then
2470               if test -n "$inst_prefix_dir" && test -f "$inst_prefix_dir$libdir/$linklib" ; then
2471                 add="$inst_prefix_dir$libdir/$linklib"
2472               else
2473                 add="$libdir/$linklib"
2474               fi
2475             else
2476               # We cannot seem to hardcode it, guess we'll fake it.
2477               add_dir="-L$libdir"
2478               # Try looking first in the location we're being installed to.
2479               if test -n "$inst_prefix_dir"; then
2480                 case "$libdir" in
2481                   [\\/]*)
2482                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
2483                     ;;
2484                 esac
2485               fi
2486               add="-l$name"
2487             fi
2488
2489             if test "$linkmode" = prog; then
2490               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2491               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2492             else
2493               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2494               test -n "$add" && deplibs="$add $deplibs"
2495             fi
2496           fi
2497         elif test "$linkmode" = prog; then
2498           # Here we assume that one of hardcode_direct or hardcode_minus_L
2499           # is not unsupported.  This is valid on all known static and
2500           # shared platforms.
2501           if test "$hardcode_direct" != unsupported; then
2502             test -n "$old_library" && linklib="$old_library"
2503             compile_deplibs="$dir/$linklib $compile_deplibs"
2504             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2505           else
2506             compile_deplibs="-l$name -L$dir $compile_deplibs"
2507             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2508           fi
2509         elif test "$build_libtool_libs" = yes; then
2510           # Not a shared library
2511           if test "$deplibs_check_method" != pass_all; then
2512             # We're trying link a shared library against a static one
2513             # but the system doesn't support it.
2514
2515             # Just print a warning and add the library to dependency_libs so
2516             # that the program can be linked against the static library.
2517             $echo
2518             $echo "*** Warning: This system can not link to static lib archive $lib."
2519             $echo "*** I have the capability to make that library automatically link in when"
2520             $echo "*** you link to this library.  But I can only do this if you have a"
2521             $echo "*** shared version of the library, which you do not appear to have."
2522             if test "$module" = yes; then
2523               $echo "*** But as you try to build a module library, libtool will still create "
2524               $echo "*** a static module, that should work as long as the dlopening application"
2525               $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2526               if test -z "$global_symbol_pipe"; then
2527                 $echo
2528                 $echo "*** However, this would only work if libtool was able to extract symbol"
2529                 $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2530                 $echo "*** not find such a program.  So, this module is probably useless."
2531                 $echo "*** \`nm' from GNU binutils and a full rebuild may help."
2532               fi
2533               if test "$build_old_libs" = no; then
2534                 build_libtool_libs=module
2535                 build_old_libs=yes
2536               else
2537                 build_libtool_libs=no
2538               fi
2539             fi
2540           else
2541             convenience="$convenience $dir/$old_library"
2542             old_convenience="$old_convenience $dir/$old_library"
2543             deplibs="$dir/$old_library $deplibs"
2544             link_static=yes
2545           fi
2546         fi # link shared/static library?
2547
2548         if test "$linkmode" = lib; then
2549           if test -n "$dependency_libs" &&
2550              { test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes ||
2551                test "$link_static" = yes; }; then
2552             # Extract -R from dependency_libs
2553             temp_deplibs=
2554             for libdir in $dependency_libs; do
2555               case $libdir in
2556               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2557                    case " $xrpath " in
2558                    *" $temp_xrpath "*) ;;
2559                    *) xrpath="$xrpath $temp_xrpath";;
2560                    esac;;
2561               *) temp_deplibs="$temp_deplibs $libdir";;
2562               esac
2563             done
2564             dependency_libs="$temp_deplibs"
2565           fi
2566
2567           newlib_search_path="$newlib_search_path $absdir"
2568           # Link against this library
2569           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2570           # ... and its dependency_libs
2571           tmp_libs=
2572           for deplib in $dependency_libs; do
2573             newdependency_libs="$deplib $newdependency_libs"
2574             if test "X$duplicate_deps" = "Xyes" ; then
2575               case "$tmp_libs " in
2576               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2577               esac
2578             fi
2579             tmp_libs="$tmp_libs $deplib"
2580           done
2581
2582           if test "$link_all_deplibs" != no; then
2583             # Add the search paths of all dependency libraries
2584             for deplib in $dependency_libs; do
2585               case $deplib in
2586               -L*) path="$deplib" ;;
2587               *.la)
2588                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2589                 test "X$dir" = "X$deplib" && dir="."
2590                 # We need an absolute path.
2591                 case $dir in
2592                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2593                 *)
2594                   absdir=`cd "$dir" && pwd`
2595                   if test -z "$absdir"; then
2596                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2597                     absdir="$dir"
2598                   fi
2599                   ;;
2600                 esac
2601                 if grep "^installed=no" $deplib > /dev/null; then
2602                   path="$absdir/$objdir"
2603                 else
2604                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2605                   if test -z "$libdir"; then
2606                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2607                     exit 1
2608                   fi
2609                   if test "$absdir" != "$libdir"; then
2610                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2611                   fi
2612                   path="$absdir"
2613                 fi
2614                 depdepl=
2615                 case $host in
2616                 *-*-darwin*)
2617                   # we do not want to link against static libs, but need to link against shared
2618                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2619                   if test -n "$deplibrary_names" ; then
2620                     for tmp in $deplibrary_names ; do
2621                       depdepl=$tmp
2622                     done
2623                     if test -f "$path/$depdepl" ; then
2624                       depdepl="$path/$depdepl"
2625                    fi
2626                     # do not add paths which are already there
2627                     case " $newlib_search_path " in
2628                     *" $path "*) ;;
2629                     *) newlib_search_path="$newlib_search_path $path";;
2630                     esac
2631                   fi
2632                   path=""
2633                   ;;
2634                 *)
2635                 path="-L$path"
2636                 ;;
2637                 esac
2638
2639                 ;;
2640                   -l*)
2641                 case $host in
2642                 *-*-darwin*)
2643                  # Again, we only want to link against shared libraries
2644                  eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2645                  for tmp in $newlib_search_path ; do
2646                      if test -f "$tmp/lib$tmp_libs.dylib" ; then
2647                        eval depdepl="$tmp/lib$tmp_libs.dylib"
2648                        break
2649                      fi
2650          done
2651          path=""
2652                   ;;
2653                 *) continue ;;
2654                 esac
2655                 ;;
2656               *) continue ;;
2657               esac
2658               case " $deplibs " in
2659               *" $depdepl "*) ;;
2660               *) deplibs="$deplibs $depdepl" ;;
2661               esac
2662               case " $deplibs " in
2663               *" $path "*) ;;
2664               *) deplibs="$deplibs $path" ;;
2665               esac
2666             done
2667           fi # link_all_deplibs != no
2668         fi # linkmode = lib
2669       done # for deplib in $libs
2670       dependency_libs="$newdependency_libs"
2671       if test "$pass" = dlpreopen; then
2672         # Link the dlpreopened libraries before other libraries
2673         for deplib in $save_deplibs; do
2674           deplibs="$deplib $deplibs"
2675         done
2676       fi
2677       if test "$pass" != dlopen; then
2678         if test "$pass" != conv; then
2679           # Make sure lib_search_path contains only unique directories.
2680           lib_search_path=
2681           for dir in $newlib_search_path; do
2682             case "$lib_search_path " in
2683             *" $dir "*) ;;
2684             *) lib_search_path="$lib_search_path $dir" ;;
2685             esac
2686           done
2687           newlib_search_path=
2688         fi
2689
2690         if test "$linkmode,$pass" != "prog,link"; then
2691           vars="deplibs"
2692         else
2693           vars="compile_deplibs finalize_deplibs"
2694         fi
2695         for var in $vars dependency_libs; do
2696           # Add libraries to $var in reverse order
2697           eval tmp_libs=\"\$$var\"
2698           new_libs=
2699           for deplib in $tmp_libs; do
2700             # FIXME: Pedantically, this is the right thing to do, so
2701             #        that some nasty dependency loop isn't accidentally
2702             #        broken:
2703             #new_libs="$deplib $new_libs"
2704             # Pragmatically, this seems to cause very few problems in
2705             # practice:
2706             case $deplib in
2707             -L*) new_libs="$deplib $new_libs" ;;
2708             -R*) ;;
2709             *)
2710               # And here is the reason: when a library appears more
2711               # than once as an explicit dependence of a library, or
2712               # is implicitly linked in more than once by the
2713               # compiler, it is considered special, and multiple
2714               # occurrences thereof are not removed.  Compare this
2715               # with having the same library being listed as a
2716               # dependency of multiple other libraries: in this case,
2717               # we know (pedantically, we assume) the library does not
2718               # need to be listed more than once, so we keep only the
2719               # last copy.  This is not always right, but it is rare
2720               # enough that we require users that really mean to play
2721               # such unportable linking tricks to link the library
2722               # using -Wl,-lname, so that libtool does not consider it
2723               # for duplicate removal.
2724               case " $specialdeplibs " in
2725               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2726               *)
2727                 case " $new_libs " in
2728                 *" $deplib "*) ;;
2729                 *) new_libs="$deplib $new_libs" ;;
2730                 esac
2731                 ;;
2732               esac
2733               ;;
2734             esac
2735           done
2736           tmp_libs=
2737           for deplib in $new_libs; do
2738             case $deplib in
2739             -L*)
2740               case " $tmp_libs " in
2741               *" $deplib "*) ;;
2742               *) tmp_libs="$tmp_libs $deplib" ;;
2743               esac
2744               ;;
2745             *) tmp_libs="$tmp_libs $deplib" ;;
2746             esac
2747           done
2748           eval $var=\"$tmp_libs\"
2749         done # for var
2750       fi
2751       # Last step: remove runtime libs from dependency_libs (they stay in deplibs)
2752       tmp_libs=
2753       for i in $dependency_libs ; do
2754         case " $predeps $postdeps $compiler_lib_search_path " in
2755         *" $i "*)
2756           i=""
2757           ;;
2758         esac
2759         if test -n "$i" ; then
2760           tmp_libs="$tmp_libs $i"
2761         fi
2762       done
2763       dependency_libs=$tmp_libs
2764     done # for pass
2765     if test "$linkmode" = prog; then
2766       dlfiles="$newdlfiles"
2767       dlprefiles="$newdlprefiles"
2768     fi
2769
2770     case $linkmode in
2771     oldlib)
2772       if test -n "$deplibs"; then
2773         $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
2774       fi
2775
2776       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2777         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2778       fi
2779
2780       if test -n "$rpath"; then
2781         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2782       fi
2783
2784       if test -n "$xrpath"; then
2785         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2786       fi
2787
2788       if test -n "$vinfo"; then
2789         $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
2790       fi
2791
2792       if test -n "$release"; then
2793         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2794       fi
2795
2796       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2797         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2798       fi
2799
2800       # Now set the variables for building old libraries.
2801       build_libtool_libs=no
2802       oldlibs="$output"
2803       objs="$objs$old_deplibs"
2804       ;;
2805
2806     lib)
2807       # Make sure we only generate libraries of the form `libNAME.la'.
2808       case $outputname in
2809       lib*)
2810         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2811         eval shared_ext=\"$shrext\"
2812         eval libname=\"$libname_spec\"
2813         ;;
2814       *)
2815         if test "$module" = no; then
2816           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2817           $echo "$help" 1>&2
2818           exit 1
2819         fi
2820         if test "$need_lib_prefix" != no; then
2821           # Add the "lib" prefix for modules if required
2822           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2823           eval shared_ext=\"$shrext\"
2824           eval libname=\"$libname_spec\"
2825         else
2826           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2827         fi
2828         ;;
2829       esac
2830
2831       if test -n "$objs"; then
2832         if test "$deplibs_check_method" != pass_all; then
2833           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2834           exit 1
2835         else
2836           $echo
2837           $echo "*** Warning: Linking the shared library $output against the non-libtool"
2838           $echo "*** objects $objs is not portable!"
2839           libobjs="$libobjs $objs"
2840         fi
2841       fi
2842
2843       if test "$dlself" != no; then
2844         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2845       fi
2846
2847       set dummy $rpath
2848       if test "$#" -gt 2; then
2849         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2850       fi
2851       install_libdir="$2"
2852
2853       oldlibs=
2854       if test -z "$rpath"; then
2855         if test "$build_libtool_libs" = yes; then
2856           # Building a libtool convenience library.
2857           # Some compilers have problems with a `.al' extension so
2858           # convenience libraries should have the same extension an
2859           # archive normally would.
2860           oldlibs="$output_objdir/$libname.$libext $oldlibs"
2861           build_libtool_libs=convenience
2862           build_old_libs=yes
2863         fi
2864
2865         if test -n "$vinfo"; then
2866           $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
2867         fi
2868
2869         if test -n "$release"; then
2870           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2871         fi
2872       else
2873
2874         # Parse the version information argument.
2875         save_ifs="$IFS"; IFS=':'
2876         set dummy $vinfo 0 0 0
2877         IFS="$save_ifs"
2878
2879         if test -n "$8"; then
2880           $echo "$modename: too many parameters to \`-version-info'" 1>&2
2881           $echo "$help" 1>&2
2882           exit 1
2883         fi
2884
2885         # convert absolute version numbers to libtool ages
2886         # this retains compatibility with .la files and attempts
2887         # to make the code below a bit more comprehensible
2888
2889         case $vinfo_number in
2890         yes)
2891           number_major="$2"
2892           number_minor="$3"
2893           number_revision="$4"
2894           #
2895           # There are really only two kinds -- those that
2896           # use the current revision as the major version
2897           # and those that subtract age and use age as
2898           # a minor version.  But, then there is irix
2899           # which has an extra 1 added just for fun
2900           #
2901           case $version_type in
2902           darwin|linux|osf|windows)
2903             current=`expr $number_major + $number_minor`
2904             age="$number_minor"
2905             revision="$number_revision"
2906             ;;
2907           freebsd-aout|freebsd-elf|sunos)
2908             current="$number_major"
2909             revision="$number_minor"
2910             age="0"
2911             ;;
2912           irix|nonstopux)
2913             current=`expr $number_major + $number_minor - 1`
2914             age="$number_minor"
2915             revision="$number_minor"
2916             ;;
2917           esac
2918           ;;
2919         no)
2920           current="$2"
2921           revision="$3"
2922           age="$4"
2923           ;;
2924         esac
2925
2926         # Check that each of the things are valid numbers.
2927         case $current in
2928         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2929         *)
2930           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2931           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2932           exit 1
2933           ;;
2934         esac
2935
2936         case $revision in
2937         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2938         *)
2939           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2940           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2941           exit 1
2942           ;;
2943         esac
2944
2945         case $age in
2946         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2947         *)
2948           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2949           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2950           exit 1
2951           ;;
2952         esac
2953
2954         if test "$age" -gt "$current"; then
2955           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2956           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2957           exit 1
2958         fi
2959
2960         # Calculate the version variables.
2961         major=
2962         versuffix=
2963         verstring=
2964         case $version_type in
2965         none) ;;
2966
2967         darwin)
2968           # Like Linux, but with the current version available in
2969           # verstring for coding it into the library header
2970           major=.`expr $current - $age`
2971           versuffix="$major.$age.$revision"
2972           # Darwin ld doesn't like 0 for these options...
2973           minor_current=`expr $current + 1`
2974           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2975           ;;
2976
2977         freebsd-aout)
2978           major=".$current"
2979           versuffix=".$current.$revision";
2980           ;;
2981
2982         freebsd-elf)
2983           major=".$current"
2984           versuffix=".$current";
2985           ;;
2986
2987         irix | nonstopux)
2988           major=`expr $current - $age + 1`
2989
2990           case $version_type in
2991             nonstopux) verstring_prefix=nonstopux ;;
2992             *)         verstring_prefix=sgi ;;
2993           esac
2994           verstring="$verstring_prefix$major.$revision"
2995
2996           # Add in all the interfaces that we are compatible with.
2997           loop=$revision
2998           while test "$loop" -ne 0; do
2999             iface=`expr $revision - $loop`
3000             loop=`expr $loop - 1`
3001             verstring="$verstring_prefix$major.$iface:$verstring"
3002           done
3003
3004           # Before this point, $major must not contain `.'.
3005           major=.$major
3006           versuffix="$major.$revision"
3007           ;;
3008
3009         linux)
3010           major=.`expr $current - $age`
3011           versuffix="$major.$age.$revision"
3012           ;;
3013
3014         osf)
3015           major=.`expr $current - $age`
3016           versuffix=".$current.$age.$revision"
3017           verstring="$current.$age.$revision"
3018
3019           # Add in all the interfaces that we are compatible with.
3020           loop=$age
3021           while test "$loop" -ne 0; do
3022             iface=`expr $current - $loop`
3023             loop=`expr $loop - 1`
3024             verstring="$verstring:${iface}.0"
3025           done
3026
3027           # Make executables depend on our current version.
3028           verstring="$verstring:${current}.0"
3029           ;;
3030
3031         sunos)
3032           major=".$current"
3033           versuffix=".$current.$revision"
3034           ;;
3035
3036         windows)
3037           # Use '-' rather than '.', since we only want one
3038           # extension on DOS 8.3 filesystems.
3039           major=`expr $current - $age`
3040           versuffix="-$major"
3041           ;;
3042
3043         *)
3044           $echo "$modename: unknown library version type \`$version_type'" 1>&2
3045           $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3046           exit 1
3047           ;;
3048         esac
3049
3050         # Clear the version info if we defaulted, and they specified a release.
3051         if test -z "$vinfo" && test -n "$release"; then
3052           major=
3053           case $version_type in
3054           darwin)
3055             # we can't check for "0.0" in archive_cmds due to quoting
3056             # problems, so we reset it completely
3057             verstring=
3058             ;;
3059           *)
3060             verstring="0.0"
3061             ;;
3062           esac
3063           if test "$need_version" = no; then
3064             versuffix=
3065           else
3066             versuffix=".0.0"
3067           fi
3068         fi
3069
3070         # Remove version info from name if versioning should be avoided
3071         if test "$avoid_version" = yes && test "$need_version" = no; then
3072           major=
3073           versuffix=
3074           verstring=""
3075         fi
3076
3077         # Check to see if the archive will have undefined symbols.
3078         if test "$allow_undefined" = yes; then
3079           if test "$allow_undefined_flag" = unsupported; then
3080             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3081             build_libtool_libs=no
3082             build_old_libs=yes
3083           fi
3084         else
3085           # Don't allow undefined symbols.
3086           allow_undefined_flag="$no_undefined_flag"
3087         fi
3088       fi
3089
3090       if test "$mode" != relink; then
3091         # Remove our outputs, but don't remove object files since they
3092         # may have been created when compiling PIC objects.
3093         removelist=
3094         tempremovelist=`$echo "$output_objdir/*"`
3095         for p in $tempremovelist; do
3096           case $p in
3097             *.$objext)
3098                ;;
3099             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3100                if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3101                then
3102                  continue
3103                fi
3104                removelist="$removelist $p"
3105                ;;
3106             *) ;;
3107           esac
3108         done
3109         if test -n "$removelist"; then
3110           $show "${rm}r $removelist"
3111           $run ${rm}r $removelist
3112         fi
3113       fi
3114
3115       # Now set the variables for building old libraries.
3116       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3117         oldlibs="$oldlibs $output_objdir/$libname.$libext"
3118
3119         # Transform .lo files to .o files.
3120         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3121       fi
3122
3123       # Eliminate all temporary directories.
3124       for path in $notinst_path; do
3125         lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
3126         deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
3127         dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
3128       done
3129
3130       if test -n "$xrpath"; then
3131         # If the user specified any rpath flags, then add them.
3132         temp_xrpath=
3133         for libdir in $xrpath; do
3134           temp_xrpath="$temp_xrpath -R$libdir"
3135           case "$finalize_rpath " in
3136           *" $libdir "*) ;;
3137           *) finalize_rpath="$finalize_rpath $libdir" ;;
3138           esac
3139         done
3140         if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3141           dependency_libs="$temp_xrpath $dependency_libs"
3142         fi
3143       fi
3144
3145       # Make sure dlfiles contains only unique files that won't be dlpreopened
3146       old_dlfiles="$dlfiles"
3147       dlfiles=
3148       for lib in $old_dlfiles; do
3149         case " $dlprefiles $dlfiles " in
3150         *" $lib "*) ;;
3151         *) dlfiles="$dlfiles $lib" ;;
3152         esac
3153       done
3154
3155       # Make sure dlprefiles contains only unique files
3156       old_dlprefiles="$dlprefiles"
3157       dlprefiles=
3158       for lib in $old_dlprefiles; do
3159         case "$dlprefiles " in
3160         *" $lib "*) ;;
3161         *) dlprefiles="$dlprefiles $lib" ;;
3162         esac
3163       done
3164
3165       if test "$build_libtool_libs" = yes; then
3166         if test -n "$rpath"; then
3167           case $host in
3168           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3169             # these systems don't actually have a c library (as such)!
3170             ;;
3171           *-*-rhapsody* | *-*-darwin1.[012])
3172             # Rhapsody C library is in the System framework
3173             deplibs="$deplibs -framework System"
3174             ;;
3175           *-*-netbsd*)
3176             # Don't link with libc until the a.out ld.so is fixed.
3177             ;;
3178           *-*-openbsd* | *-*-freebsd*)
3179             # Do not include libc due to us having libc/libc_r.
3180             test "X$arg" = "X-lc" && continue
3181             ;;
3182           *)
3183             # Add libc to deplibs on all other systems if necessary.
3184             if test "$build_libtool_need_lc" = "yes"; then
3185               deplibs="$deplibs -lc"
3186             fi
3187             ;;
3188           esac
3189         fi
3190
3191         # Transform deplibs into only deplibs that can be linked in shared.
3192         name_save=$name
3193         libname_save=$libname
3194         release_save=$release
3195         versuffix_save=$versuffix
3196         major_save=$major
3197         # I'm not sure if I'm treating the release correctly.  I think
3198         # release should show up in the -l (ie -lgmp5) so we don't want to
3199         # add it in twice.  Is that correct?
3200         release=""
3201         versuffix=""
3202         major=""
3203         newdeplibs=
3204         droppeddeps=no
3205         case $deplibs_check_method in
3206         pass_all)
3207           # Don't check for shared/static.  Everything works.
3208           # This might be a little naive.  We might want to check
3209           # whether the library exists or not.  But this is on
3210           # osf3 & osf4 and I'm not really sure... Just
3211           # implementing what was already the behavior.
3212           newdeplibs=$deplibs
3213           ;;
3214         test_compile)
3215           # This code stresses the "libraries are programs" paradigm to its
3216           # limits. Maybe even breaks it.  We compile a program, linking it
3217           # against the deplibs as a proxy for the library.  Then we can check
3218           # whether they linked in statically or dynamically with ldd.
3219           $rm conftest.c
3220           cat > conftest.c <<EOF
3221           int main() { return 0; }
3222 EOF
3223           $rm conftest
3224           $LTCC -o conftest conftest.c $deplibs
3225           if test "$?" -eq 0 ; then
3226             ldd_output=`ldd conftest`
3227             for i in $deplibs; do
3228               name="`expr $i : '-l\(.*\)'`"
3229               # If $name is empty we are operating on a -L argument.
3230               if test "$name" != "" && test "$name" -ne "0"; then
3231                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3232                   case " $predeps $postdeps " in
3233                   *" $i "*)
3234                     newdeplibs="$newdeplibs $i"
3235                     i=""
3236                     ;;
3237                   esac
3238                 fi
3239                 if test -n "$i" ; then
3240                   libname=`eval \\$echo \"$libname_spec\"`
3241                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
3242                   set dummy $deplib_matches
3243                   deplib_match=$2
3244                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3245                     newdeplibs="$newdeplibs $i"
3246                   else
3247                     droppeddeps=yes
3248                     $echo
3249                     $echo "*** Warning: dynamic linker does not accept needed library $i."
3250                     $echo "*** I have the capability to make that library automatically link in when"
3251                     $echo "*** you link to this library.  But I can only do this if you have a"
3252                     $echo "*** shared version of the library, which I believe you do not have"
3253                     $echo "*** because a test_compile did reveal that the linker did not use it for"
3254                     $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3255                   fi
3256                 fi
3257               else
3258                 newdeplibs="$newdeplibs $i"
3259               fi
3260             done
3261           else
3262             # Error occurred in the first compile.  Let's try to salvage
3263             # the situation: Compile a separate program for each library.
3264             for i in $deplibs; do
3265               name="`expr $i : '-l\(.*\)'`"
3266               # If $name is empty we are operating on a -L argument.
3267               if test "$name" != "" && test "$name" != "0"; then
3268                 $rm conftest
3269                 $LTCC -o conftest conftest.c $i
3270                 # Did it work?
3271                 if test "$?" -eq 0 ; then
3272                   ldd_output=`ldd conftest`
3273                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3274                     case " $predeps $postdeps " in
3275                     *" $i "*)
3276                       newdeplibs="$newdeplibs $i"
3277                       i=""
3278                       ;;
3279                     esac
3280                   fi
3281                   if test -n "$i" ; then
3282                     libname=`eval \\$echo \"$libname_spec\"`
3283                     deplib_matches=`eval \\$echo \"$library_names_spec\"`
3284                     set dummy $deplib_matches
3285                     deplib_match=$2
3286                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3287                       newdeplibs="$newdeplibs $i"
3288                     else
3289                       droppeddeps=yes
3290                       $echo
3291                       $echo "*** Warning: dynamic linker does not accept needed library $i."
3292                       $echo "*** I have the capability to make that library automatically link in when"
3293                       $echo "*** you link to this library.  But I can only do this if you have a"
3294                       $echo "*** shared version of the library, which you do not appear to have"
3295                       $echo "*** because a test_compile did reveal that the linker did not use this one"
3296                       $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3297                     fi
3298                   fi
3299                 else
3300                   droppeddeps=yes
3301                   $echo
3302                   $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3303                   $echo "***  make it link in!  You will probably need to install it or some"
3304                   $echo "*** library that it depends on before this library will be fully"
3305                   $echo "*** functional.  Installing it before continuing would be even better."
3306                 fi
3307               else
3308                 newdeplibs="$newdeplibs $i"
3309               fi
3310             done
3311           fi
3312           ;;
3313         file_magic*)
3314           set dummy $deplibs_check_method
3315           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3316           for a_deplib in $deplibs; do
3317             name="`expr $a_deplib : '-l\(.*\)'`"
3318             # If $name is empty we are operating on a -L argument.
3319             if test "$name" != "" && test  "$name" != "0"; then
3320               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3321                 case " $predeps $postdeps " in
3322                 *" $a_deplib "*)
3323                   newdeplibs="$newdeplibs $a_deplib"
3324                   a_deplib=""
3325                   ;;
3326                 esac
3327               fi
3328               if test -n "$a_deplib" ; then
3329                 libname=`eval \\$echo \"$libname_spec\"`
3330                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3331                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3332                   for potent_lib in $potential_libs; do
3333                       # Follow soft links.
3334                       if ls -lLd "$potent_lib" 2>/dev/null \
3335                          | grep " -> " >/dev/null; then
3336                         continue
3337                       fi
3338                       # The statement above tries to avoid entering an
3339                       # endless loop below, in case of cyclic links.
3340                       # We might still enter an endless loop, since a link
3341                       # loop can be closed while we follow links,
3342                       # but so what?
3343                       potlib="$potent_lib"
3344                       while test -h "$potlib" 2>/dev/null; do
3345                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3346                         case $potliblink in
3347                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3348                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
3349                         esac
3350                       done
3351                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3352                          | ${SED} 10q \
3353                          | $EGREP "$file_magic_regex" > /dev/null; then
3354                         newdeplibs="$newdeplibs $a_deplib"
3355                         a_deplib=""
3356                         break 2
3357                       fi
3358                   done
3359                 done
3360               fi
3361               if test -n "$a_deplib" ; then
3362                 droppeddeps=yes
3363                 $echo
3364                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3365                 $echo "*** I have the capability to make that library automatically link in when"
3366                 $echo "*** you link to this library.  But I can only do this if you have a"
3367                 $echo "*** shared version of the library, which you do not appear to have"
3368                 $echo "*** because I did check the linker path looking for a file starting"
3369                 if test -z "$potlib" ; then
3370                   $echo "*** with $libname but no candidates were found. (...for file magic test)"
3371                 else
3372                   $echo "*** with $libname and none of the candidates passed a file format test"
3373                   $echo "*** using a file magic. Last file checked: $potlib"
3374                 fi
3375               fi
3376             else
3377               # Add a -L argument.
3378               newdeplibs="$newdeplibs $a_deplib"
3379             fi
3380           done # Gone through all deplibs.
3381           ;;
3382         match_pattern*)
3383           set dummy $deplibs_check_method
3384           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3385           for a_deplib in $deplibs; do
3386             name="`expr $a_deplib : '-l\(.*\)'`"
3387             # If $name is empty we are operating on a -L argument.
3388             if test -n "$name" && test "$name" != "0"; then
3389               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3390                 case " $predeps $postdeps " in
3391                 *" $a_deplib "*)
3392                   newdeplibs="$newdeplibs $a_deplib"
3393                   a_deplib=""
3394                   ;;
3395                 esac
3396               fi
3397               if test -n "$a_deplib" ; then
3398                 libname=`eval \\$echo \"$libname_spec\"`
3399                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3400                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3401                   for potent_lib in $potential_libs; do
3402                     potlib="$potent_lib" # see symlink-check above in file_magic test
3403                     if eval $echo \"$potent_lib\" 2>/dev/null \
3404                         | ${SED} 10q \
3405                         | $EGREP "$match_pattern_regex" > /dev/null; then
3406                       newdeplibs="$newdeplibs $a_deplib"
3407                       a_deplib=""
3408                       break 2
3409                     fi
3410                   done
3411                 done
3412               fi
3413               if test -n "$a_deplib" ; then
3414                 droppeddeps=yes
3415                 $echo
3416                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3417                 $echo "*** I have the capability to make that library automatically link in when"
3418                 $echo "*** you link to this library.  But I can only do this if you have a"
3419                 $echo "*** shared version of the library, which you do not appear to have"
3420                 $echo "*** because I did check the linker path looking for a file starting"
3421                 if test -z "$potlib" ; then
3422                   $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
3423                 else
3424                   $echo "*** with $libname and none of the candidates passed a file format test"
3425                   $echo "*** using a regex pattern. Last file checked: $potlib"
3426                 fi
3427               fi
3428             else
3429               # Add a -L argument.
3430               newdeplibs="$newdeplibs $a_deplib"
3431             fi
3432           done # Gone through all deplibs.
3433           ;;
3434         none | unknown | *)
3435           newdeplibs=""
3436           tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3437             -e 's/ -[LR][^ ]*//g'`
3438           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3439             for i in $predeps $postdeps ; do
3440               # can't use Xsed below, because $i might contain '/'
3441               tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
3442             done
3443           fi
3444           if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
3445             | grep . >/dev/null; then
3446             $echo
3447             if test "X$deplibs_check_method" = "Xnone"; then
3448               $echo "*** Warning: inter-library dependencies are not supported in this platform."
3449             else
3450               $echo "*** Warning: inter-library dependencies are not known to be supported."
3451             fi
3452             $echo "*** All declared inter-library dependencies are being dropped."
3453             droppeddeps=yes
3454           fi
3455           ;;
3456         esac
3457         versuffix=$versuffix_save
3458         major=$major_save
3459         release=$release_save
3460         libname=$libname_save
3461         name=$name_save
3462
3463         case $host in
3464         *-*-rhapsody* | *-*-darwin1.[012])
3465           # On Rhapsody replace the C library is the System framework
3466           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3467           ;;
3468         esac
3469
3470         if test "$droppeddeps" = yes; then
3471           if test "$module" = yes; then
3472             $echo
3473             $echo "*** Warning: libtool could not satisfy all declared inter-library"
3474             $echo "*** dependencies of module $libname.  Therefore, libtool will create"
3475             $echo "*** a static module, that should work as long as the dlopening"
3476             $echo "*** application is linked with the -dlopen flag."
3477             if test -z "$global_symbol_pipe"; then
3478               $echo
3479               $echo "*** However, this would only work if libtool was able to extract symbol"
3480               $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3481               $echo "*** not find such a program.  So, this module is probably useless."
3482               $echo "*** \`nm' from GNU binutils and a full rebuild may help."
3483             fi
3484             if test "$build_old_libs" = no; then
3485               oldlibs="$output_objdir/$libname.$libext"
3486               build_libtool_libs=module
3487               build_old_libs=yes
3488             else
3489               build_libtool_libs=no
3490             fi
3491           else
3492             $echo "*** The inter-library dependencies that have been dropped here will be"
3493             $echo "*** automatically added whenever a program is linked with this library"
3494             $echo "*** or is declared to -dlopen it."
3495
3496             if test "$allow_undefined" = no; then
3497               $echo
3498               $echo "*** Since this library must not contain undefined symbols,"
3499               $echo "*** because either the platform does not support them or"
3500               $echo "*** it was explicitly requested with -no-undefined,"
3501               $echo "*** libtool will only create a static version of it."
3502               if test "$build_old_libs" = no; then
3503                 oldlibs="$output_objdir/$libname.$libext"
3504                 build_libtool_libs=module
3505                 build_old_libs=yes
3506               else
3507                 build_libtool_libs=no
3508               fi
3509             fi
3510           fi
3511         fi
3512         # Done checking deplibs!
3513         deplibs=$newdeplibs
3514       fi
3515
3516       # All the library-specific variables (install_libdir is set above).
3517       library_names=
3518       old_library=
3519       dlname=
3520
3521       # Test again, we may have decided not to build it any more
3522       if test "$build_libtool_libs" = yes; then
3523         if test "$hardcode_into_libs" = yes; then
3524           # Hardcode the library paths
3525           hardcode_libdirs=
3526           dep_rpath=
3527           rpath="$finalize_rpath"
3528           test "$mode" != relink && rpath="$compile_rpath$rpath"
3529           for libdir in $rpath; do
3530             if test -n "$hardcode_libdir_flag_spec"; then
3531               if test -n "$hardcode_libdir_separator"; then
3532                 if test -z "$hardcode_libdirs"; then
3533                   hardcode_libdirs="$libdir"
3534                 else
3535                   # Just accumulate the unique libdirs.
3536                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3537                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3538                     ;;
3539                   *)
3540                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3541                     ;;
3542                   esac
3543                 fi
3544               else
3545                 eval flag=\"$hardcode_libdir_flag_spec\"
3546                 dep_rpath="$dep_rpath $flag"
3547               fi
3548             elif test -n "$runpath_var"; then
3549               case "$perm_rpath " in
3550               *" $libdir "*) ;;
3551               *) perm_rpath="$perm_rpath $libdir" ;;
3552               esac
3553             fi
3554           done
3555           # Substitute the hardcoded libdirs into the rpath.
3556           if test -n "$hardcode_libdir_separator" &&
3557              test -n "$hardcode_libdirs"; then
3558             libdir="$hardcode_libdirs"
3559             if test -n "$hardcode_libdir_flag_spec_ld"; then
3560               eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
3561             else
3562               eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3563             fi
3564           fi
3565           if test -n "$runpath_var" && test -n "$perm_rpath"; then
3566             # We should set the runpath_var.
3567             rpath=
3568             for dir in $perm_rpath; do
3569               rpath="$rpath$dir:"
3570             done
3571             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3572           fi
3573           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3574         fi
3575
3576         shlibpath="$finalize_shlibpath"
3577         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3578         if test -n "$shlibpath"; then
3579           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3580         fi
3581
3582         # Get the real and link names of the library.
3583         eval shared_ext=\"$shrext\"
3584         eval library_names=\"$library_names_spec\"
3585         set dummy $library_names
3586         realname="$2"
3587         shift; shift
3588
3589         if test -n "$soname_spec"; then
3590           eval soname=\"$soname_spec\"
3591         else
3592           soname="$realname"
3593         fi
3594         if test -z "$dlname"; then
3595           dlname=$soname
3596         fi
3597
3598         lib="$output_objdir/$realname"
3599         for link
3600         do
3601           linknames="$linknames $link"
3602         done
3603
3604         # Use standard objects if they are pic
3605         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3606
3607         # Prepare the list of exported symbols
3608         if test -z "$export_symbols"; then
3609           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3610             $show "generating symbol list for \`$libname.la'"
3611             export_symbols="$output_objdir/$libname.exp"
3612             $run $rm $export_symbols
3613             cmds=$export_symbols_cmds
3614             save_ifs="$IFS"; IFS='~'
3615             for cmd in $cmds; do
3616               IFS="$save_ifs"
3617               eval cmd=\"$cmd\"
3618               if len=`expr "X$cmd" : ".*"` &&
3619                test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3620                 $show "$cmd"
3621                 $run eval "$cmd" || exit $?
3622                 skipped_export=false
3623               else
3624                 # The command line is too long to execute in one step.
3625                 $show "using reloadable object file for export list..."
3626                 skipped_export=:
3627               fi
3628             done
3629             IFS="$save_ifs"
3630             if test -n "$export_symbols_regex"; then
3631               $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3632               $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3633               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3634               $run eval '$mv "${export_symbols}T" "$export_symbols"'
3635             fi
3636           fi
3637         fi
3638
3639         if test -n "$export_symbols" && test -n "$include_expsyms"; then
3640           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3641         fi
3642
3643         tmp_deplibs=
3644         for test_deplib in $deplibs; do
3645                 case " $convenience " in
3646                 *" $test_deplib "*) ;;
3647                 *)
3648                         tmp_deplibs="$tmp_deplibs $test_deplib"
3649                         ;;
3650                 esac
3651         done
3652         deplibs="$tmp_deplibs"
3653
3654         if test -n "$convenience"; then
3655           if test -n "$whole_archive_flag_spec"; then
3656             save_libobjs=$libobjs
3657             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3658           else
3659             gentop="$output_objdir/${outputname}x"
3660             $show "${rm}r $gentop"
3661             $run ${rm}r "$gentop"
3662             $show "$mkdir $gentop"
3663             $run $mkdir "$gentop"
3664             status=$?
3665             if test "$status" -ne 0 && test ! -d "$gentop"; then
3666               exit $status
3667             fi
3668             generated="$generated $gentop"
3669
3670             for xlib in $convenience; do
3671               # Extract the objects.
3672               case $xlib in
3673               [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3674               *) xabs=`pwd`"/$xlib" ;;
3675               esac
3676               xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3677               xdir="$gentop/$xlib"
3678
3679               $show "${rm}r $xdir"
3680               $run ${rm}r "$xdir"
3681               $show "$mkdir $xdir"
3682               $run $mkdir "$xdir"
3683               status=$?
3684               if test "$status" -ne 0 && test ! -d "$xdir"; then
3685                 exit $status
3686               fi
3687               # We will extract separately just the conflicting names and we will no
3688               # longer touch any unique names. It is faster to leave these extract
3689               # automatically by $AR in one run.
3690               $show "(cd $xdir && $AR x $xabs)"
3691               $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3692               if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
3693                 :
3694               else
3695                 $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
3696                 $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
3697                 $AR t "$xabs" | sort | uniq -cd | while read -r count name
3698                 do
3699                   i=1
3700                   while test "$i" -le "$count"
3701                   do
3702                    # Put our $i before any first dot (extension)
3703                    # Never overwrite any file
3704                    name_to="$name"
3705                    while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
3706                    do
3707                      name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
3708                    done
3709                    $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
3710                    $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
3711                    i=`expr $i + 1`
3712                   done
3713                 done
3714               fi
3715
3716               libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3717             done
3718           fi
3719         fi
3720
3721         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3722           eval flag=\"$thread_safe_flag_spec\"
3723           linker_flags="$linker_flags $flag"
3724         fi
3725
3726         # Make a backup of the uninstalled library when relinking
3727         if test "$mode" = relink; then
3728           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3729         fi
3730
3731         # Do each of the archive commands.
3732         if test "$module" = yes && test -n "$module_cmds" ; then
3733           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
3734             eval test_cmds=\"$module_expsym_cmds\"
3735             cmds=$module_expsym_cmds
3736           else
3737             eval test_cmds=\"$module_cmds\"
3738             cmds=$module_cmds
3739           fi
3740         else
3741         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3742           eval test_cmds=\"$archive_expsym_cmds\"
3743           cmds=$archive_expsym_cmds
3744         else
3745           eval test_cmds=\"$archive_cmds\"
3746           cmds=$archive_cmds
3747           fi
3748         fi
3749
3750         if test "X$skipped_export" != "X:" && len=`expr "X$test_cmds" : ".*"` &&
3751            test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3752           :
3753         else
3754           # The command line is too long to link in one step, link piecewise.
3755           $echo "creating reloadable object files..."
3756
3757           # Save the value of $output and $libobjs because we want to
3758           # use them later.  If we have whole_archive_flag_spec, we
3759           # want to use save_libobjs as it was before
3760           # whole_archive_flag_spec was expanded, because we can't
3761           # assume the linker understands whole_archive_flag_spec.
3762           # This may have to be revisited, in case too many
3763           # convenience libraries get linked in and end up exceeding
3764           # the spec.
3765           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3766             save_libobjs=$libobjs
3767           fi
3768           save_output=$output
3769
3770           # Clear the reloadable object creation command queue and
3771           # initialize k to one.
3772           test_cmds=
3773           concat_cmds=
3774           objlist=
3775           delfiles=
3776           last_robj=
3777           k=1
3778           output=$output_objdir/$save_output-${k}.$objext
3779           # Loop over the list of objects to be linked.
3780           for obj in $save_libobjs
3781           do
3782             eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3783             if test "X$objlist" = X ||
3784                { len=`expr "X$test_cmds" : ".*"` &&
3785                  test "$len" -le "$max_cmd_len"; }; then
3786               objlist="$objlist $obj"
3787             else
3788               # The command $test_cmds is almost too long, add a
3789               # command to the queue.
3790               if test "$k" -eq 1 ; then
3791                 # The first file doesn't have a previous command to add.
3792                 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3793               else
3794                 # All subsequent reloadable object files will link in
3795                 # the last one created.
3796                 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3797               fi
3798               last_robj=$output_objdir/$save_output-${k}.$objext
3799               k=`expr $k + 1`
3800               output=$output_objdir/$save_output-${k}.$objext
3801               objlist=$obj
3802               len=1
3803             fi
3804           done
3805           # Handle the remaining objects by creating one last
3806           # reloadable object file.  All subsequent reloadable object
3807           # files will link in the last one created.
3808           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3809           eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3810
3811           if ${skipped_export-false}; then
3812             $show "generating symbol list for \`$libname.la'"
3813             export_symbols="$output_objdir/$libname.exp"
3814             $run $rm $export_symbols
3815             libobjs=$output
3816             # Append the command to create the export file.
3817             eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
3818           fi
3819
3820           # Set up a command to remove the reloadale object files
3821           # after they are used.
3822           i=0
3823           while test "$i" -lt "$k"
3824           do
3825             i=`expr $i + 1`
3826             delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3827           done
3828
3829           $echo "creating a temporary reloadable object file: $output"
3830
3831           # Loop through the commands generated above and execute them.
3832           save_ifs="$IFS"; IFS='~'
3833           for cmd in $concat_cmds; do
3834             IFS="$save_ifs"
3835             eval cmd=\"$cmd\"
3836             $show "$cmd"
3837             $run eval "$cmd" || exit $?
3838           done
3839           IFS="$save_ifs"
3840
3841           libobjs=$output
3842           # Restore the value of output.
3843           output=$save_output
3844
3845           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3846             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3847           fi
3848           # Expand the library linking commands again to reset the
3849           # value of $libobjs for piecewise linking.
3850
3851           # Do each of the archive commands.
3852           if test "$module" = yes && test -n "$module_cmds" ; then
3853             if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
3854               cmds=$module_expsym_cmds
3855             else
3856               cmds=$module_cmds
3857             fi
3858           else
3859           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3860             cmds=$archive_expsym_cmds
3861           else
3862             cmds=$archive_cmds
3863             fi
3864           fi
3865
3866           # Append the command to remove the reloadable object files
3867           # to the just-reset $cmds.
3868           eval cmds=\"\$cmds~\$rm $delfiles\"
3869         fi
3870         save_ifs="$IFS"; IFS='~'
3871         for cmd in $cmds; do
3872           IFS="$save_ifs"
3873           eval cmd=\"$cmd\"
3874           $show "$cmd"
3875           $run eval "$cmd" || exit $?
3876         done
3877         IFS="$save_ifs"
3878
3879         # Restore the uninstalled library and exit
3880         if test "$mode" = relink; then
3881           $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
3882           exit 0
3883         fi
3884
3885         # Create links to the real library.
3886         for linkname in $linknames; do
3887           if test "$realname" != "$linkname"; then
3888             $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
3889             $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
3890           fi
3891         done
3892
3893         # If -module or -export-dynamic was specified, set the dlname.
3894         if test "$module" = yes || test "$export_dynamic" = yes; then
3895           # On all known operating systems, these are identical.
3896           dlname="$soname"
3897         fi
3898       fi
3899       ;;
3900
3901     obj)
3902       if test -n "$deplibs"; then
3903         $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
3904       fi
3905
3906       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3907         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
3908       fi
3909
3910       if test -n "$rpath"; then
3911         $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
3912       fi
3913
3914       if test -n "$xrpath"; then
3915         $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
3916       fi
3917
3918       if test -n "$vinfo"; then
3919         $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
3920       fi
3921
3922       if test -n "$release"; then
3923         $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
3924       fi
3925
3926       case $output in
3927       *.lo)
3928         if test -n "$objs$old_deplibs"; then
3929           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
3930           exit 1
3931         fi
3932         libobj="$output"
3933         obj=`$echo "X$output" | $Xsed -e "$lo2o"`
3934         ;;
3935       *)
3936         libobj=
3937         obj="$output"
3938         ;;
3939       esac
3940
3941       # Delete the old objects.
3942       $run $rm $obj $libobj
3943
3944       # Objects from convenience libraries.  This assumes
3945       # single-version convenience libraries.  Whenever we create
3946       # different ones for PIC/non-PIC, this we'll have to duplicate
3947       # the extraction.
3948       reload_conv_objs=
3949       gentop=
3950       # reload_cmds runs $LD directly, so let us get rid of
3951       # -Wl from whole_archive_flag_spec
3952       wl=
3953
3954       if test -n "$convenience"; then
3955         if test -n "$whole_archive_flag_spec"; then
3956           eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
3957         else
3958           gentop="$output_objdir/${obj}x"
3959           $show "${rm}r $gentop"
3960           $run ${rm}r "$gentop"
3961           $show "$mkdir $gentop"
3962           $run $mkdir "$gentop"
3963           status=$?
3964           if test "$status" -ne 0 && test ! -d "$gentop"; then
3965             exit $status
3966           fi
3967           generated="$generated $gentop"
3968
3969           for xlib in $convenience; do
3970             # Extract the objects.
3971             case $xlib in
3972             [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3973             *) xabs=`pwd`"/$xlib" ;;
3974             esac
3975             xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3976             xdir="$gentop/$xlib"
3977
3978             $show "${rm}r $xdir"
3979             $run ${rm}r "$xdir"
3980             $show "$mkdir $xdir"
3981             $run $mkdir "$xdir"
3982             status=$?
3983             if test "$status" -ne 0 && test ! -d "$xdir"; then
3984               exit $status
3985             fi
3986             # We will extract separately just the conflicting names and we will no
3987             # longer touch any unique names. It is faster to leave these extract
3988             # automatically by $AR in one run.
3989             $show "(cd $xdir && $AR x $xabs)"
3990             $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3991             if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
3992               :
3993             else
3994               $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
3995               $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
3996               $AR t "$xabs" | sort | uniq -cd | while read -r count name
3997               do
3998                 i=1
3999                 while test "$i" -le "$count"
4000                 do
4001                  # Put our $i before any first dot (extension)
4002                  # Never overwrite any file
4003                  name_to="$name"
4004                  while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
4005                  do
4006                    name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
4007                  done
4008                  $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
4009                  $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
4010                  i=`expr $i + 1`
4011                 done
4012               done
4013             fi
4014
4015             reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
4016           done
4017         fi
4018       fi
4019
4020       # Create the old-style object.
4021       reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
4022
4023       output="$obj"
4024       cmds=$reload_cmds
4025       save_ifs="$IFS"; IFS='~'
4026       for cmd in $cmds; do
4027         IFS="$save_ifs"
4028         eval cmd=\"$cmd\"
4029         $show "$cmd"
4030         $run eval "$cmd" || exit $?
4031       done
4032       IFS="$save_ifs"
4033
4034       # Exit if we aren't doing a library object file.
4035       if test -z "$libobj"; then
4036         if test -n "$gentop"; then
4037           $show "${rm}r $gentop"
4038           $run ${rm}r $gentop
4039         fi
4040
4041         exit 0
4042       fi
4043
4044       if test "$build_libtool_libs" != yes; then
4045         if test -n "$gentop"; then
4046           $show "${rm}r $gentop"
4047           $run ${rm}r $gentop
4048         fi
4049
4050         # Create an invalid libtool object if no PIC, so that we don't
4051         # accidentally link it into a program.
4052         # $show "echo timestamp > $libobj"
4053         # $run eval "echo timestamp > $libobj" || exit $?
4054         exit 0
4055       fi
4056
4057       if test -n "$pic_flag" || test "$pic_mode" != default; then
4058         # Only do commands if we really have different PIC objects.
4059         reload_objs="$libobjs $reload_conv_objs"
4060         output="$libobj"
4061         cmds=$reload_cmds
4062         save_ifs="$IFS"; IFS='~'
4063         for cmd in $cmds; do
4064           IFS="$save_ifs"
4065           eval cmd=\"$cmd\"
4066           $show "$cmd"
4067           $run eval "$cmd" || exit $?
4068         done
4069         IFS="$save_ifs"
4070       fi
4071
4072       if test -n "$gentop"; then
4073         $show "${rm}r $gentop"
4074         $run ${rm}r $gentop
4075       fi
4076
4077       exit 0
4078       ;;
4079
4080     prog)
4081       case $host in
4082         *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
4083       esac
4084       if test -n "$vinfo"; then
4085         $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4086       fi
4087
4088       if test -n "$release"; then
4089         $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4090       fi
4091
4092       if test "$preload" = yes; then
4093         if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
4094            test "$dlopen_self_static" = unknown; then
4095           $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4096         fi
4097       fi
4098
4099       case $host in
4100       *-*-rhapsody* | *-*-darwin1.[012])
4101         # On Rhapsody replace the C library is the System framework
4102         compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4103         finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4104         ;;
4105       esac
4106
4107       case $host in
4108       *darwin*)
4109         # Don't allow lazy linking, it breaks C++ global constructors
4110         if test "$tagname" = CXX ; then
4111         compile_command="$compile_command ${wl}-bind_at_load"
4112         finalize_command="$finalize_command ${wl}-bind_at_load"
4113         fi
4114         ;;
4115       esac
4116
4117       compile_command="$compile_command $compile_deplibs"
4118       finalize_command="$finalize_command $finalize_deplibs"
4119
4120       if test -n "$rpath$xrpath"; then
4121         # If the user specified any rpath flags, then add them.
4122         for libdir in $rpath $xrpath; do
4123           # This is the magic to use -rpath.
4124           case "$finalize_rpath " in
4125           *" $libdir "*) ;;
4126           *) finalize_rpath="$finalize_rpath $libdir" ;;
4127           esac
4128         done
4129       fi