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