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
4149         done
4150       fi
4151
4152       # Now hardcode the library paths
4153       rpath=
4154       hardcode_libdirs=
4155       for libdir in $compile_rpath $finalize_rpath; do
4156         if test -n "$hardcode_libdir_flag_spec"; then
4157           if test -n "$hardcode_libdir_separator"; then
4158             if test -z "$hardcode_libdirs"; then
4159               hardcode_libdirs="$libdir"
4160             else
4161               # Just accumulate the unique libdirs.
4162               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4163               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4164                 ;;
4165               *)
4166                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4167                 ;;
4168               esac
4169             fi
4170           else
4171             eval flag=\"$hardcode_libdir_flag_spec\"
4172             rpath="$rpath $flag"
4173           fi
4174         elif test -n "$runpath_var"; then
4175           case "$perm_rpath " in
4176           *" $libdir "*) ;;
4177           *) perm_rpath="$perm_rpath $libdir" ;;
4178           esac
4179         fi
4180         case $host in
4181         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4182           case :$dllsearchpath: in
4183           *":$libdir:"*) ;;
4184           *) dllsearchpath="$dllsearchpath:$libdir";;
4185           esac
4186           ;;
4187         esac
4188       done
4189       # Substitute the hardcoded libdirs into the rpath.
4190       if test -n "$hardcode_libdir_separator" &&
4191          test -n "$hardcode_libdirs"; then
4192         libdir="$hardcode_libdirs"
4193         eval rpath=\" $hardcode_libdir_flag_spec\"
4194       fi
4195       compile_rpath="$rpath"
4196
4197       rpath=
4198       hardcode_libdirs=
4199       for libdir in $finalize_rpath; do
4200         if test -n "$hardcode_libdir_flag_spec"; then
4201           if test -n "$hardcode_libdir_separator"; then
4202             if test -z "$hardcode_libdirs"; then
4203               hardcode_libdirs="$libdir"
4204             else
4205               # Just accumulate the unique libdirs.
4206               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4207               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4208                 ;;
4209               *)
4210                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4211                 ;;
4212               esac
4213             fi
4214           else
4215             eval flag=\"$hardcode_libdir_flag_spec\"
4216             rpath="$rpath $flag"
4217           fi
4218         elif test -n "$runpath_var"; then
4219           case "$finalize_perm_rpath " in
4220           *" $libdir "*) ;;
4221           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
4222           esac
4223         fi
4224       done
4225       # Substitute the hardcoded libdirs into the rpath.
4226       if test -n "$hardcode_libdir_separator" &&
4227          test -n "$hardcode_libdirs"; then
4228         libdir="$hardcode_libdirs"
4229         eval rpath=\" $hardcode_libdir_flag_spec\"
4230       fi
4231       finalize_rpath="$rpath"
4232
4233       if test -n "$libobjs" && test "$build_old_libs" = yes; then
4234         # Transform all the library objects into standard objects.
4235         compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4236         finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4237       fi
4238
4239       dlsyms=
4240       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4241         if test -n "$NM" && test -n "$global_symbol_pipe"; then
4242           dlsyms="${outputname}S.c"
4243         else
4244           $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4245         fi
4246       fi
4247
4248       if test -n "$dlsyms"; then
4249         case $dlsyms in
4250         "") ;;
4251         *.c)
4252           # Discover the nlist of each of the dlfiles.
4253           nlist="$output_objdir/${outputname}.nm"
4254
4255           $show "$rm $nlist ${nlist}S ${nlist}T"
4256           $run $rm "$nlist" "${nlist}S" "${nlist}T"
4257
4258           # Parse the name list into a source file.
4259           $show "creating $output_objdir/$dlsyms"
4260
4261           test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4262 /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4263 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
4264
4265 #ifdef __cplusplus
4266 extern \"C\" {
4267 #endif
4268
4269 /* Prevent the only kind of declaration conflicts we can make. */
4270 #define lt_preloaded_symbols some_other_symbol
4271
4272 /* External symbol declarations for the compiler. */\
4273 "
4274
4275           if test "$dlself" = yes; then
4276             $show "generating symbol list for \`$output'"
4277
4278             test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4279
4280             # Add our own program objects to the symbol list.
4281             progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4282             for arg in $progfiles; do
4283               $show "extracting global C symbols from \`$arg'"
4284               $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4285             done
4286
4287             if test -n "$exclude_expsyms"; then
4288               $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4289               $run eval '$mv "$nlist"T "$nlist"'
4290             fi
4291
4292             if test -n "$export_symbols_regex"; then
4293               $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4294               $run eval '$mv "$nlist"T "$nlist"'
4295             fi
4296
4297             # Prepare the list of exported symbols
4298             if test -z "$export_symbols"; then
4299               export_symbols="$output_objdir/$output.exp"
4300               $run $rm $export_symbols
4301               $run eval "${SED} -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4302             else
4303               $run eval "${SED} -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
4304               $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
4305               $run eval 'mv "$nlist"T "$nlist"'
4306             fi
4307           fi
4308
4309           for arg in $dlprefiles; do
4310             $show "extracting global C symbols from \`$arg'"
4311             name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4312             $run eval '$echo ": $name " >> "$nlist"'
4313             $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4314           done
4315
4316           if test -z "$run"; then
4317             # Make sure we have at least an empty file.
4318             test -f "$nlist" || : > "$nlist"
4319
4320             if test -n "$exclude_expsyms"; then
4321               $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4322               $mv "$nlist"T "$nlist"
4323             fi
4324
4325             # Try sorting and uniquifying the output.
4326             if grep -v "^: " < "$nlist" |
4327                 if sort -k 3 </dev/null >/dev/null 2>&1; then
4328                   sort -k 3
4329                 else
4330                   sort +2
4331                 fi |
4332                 uniq > "$nlist"S; then
4333               :
4334             else
4335               grep -v "^: " < "$nlist" > "$nlist"S
4336             fi
4337
4338             if test -f "$nlist"S; then
4339               eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4340             else
4341               $echo '/* NONE */' >> "$output_objdir/$dlsyms"
4342             fi
4343
4344             $echo >> "$output_objdir/$dlsyms" "\
4345
4346 #undef lt_preloaded_symbols
4347
4348 #if defined (__STDC__) && __STDC__
4349 # define lt_ptr void *
4350 #else
4351 # define lt_ptr char *
4352 # define const
4353 #endif
4354
4355 /* The mapping between symbol names and symbols. */
4356 const struct {
4357   const char *name;
4358   lt_ptr address;
4359 }
4360 lt_preloaded_symbols[] =
4361 {\
4362 "
4363
4364             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4365
4366             $echo >> "$output_objdir/$dlsyms" "\
4367   {0, (lt_ptr) 0}
4368 };
4369
4370 /* This works around a problem in FreeBSD linker */
4371 #ifdef FREEBSD_WORKAROUND
4372 static const void *lt_preloaded_setup() {
4373   return lt_preloaded_symbols;
4374 }
4375 #endif
4376
4377 #ifdef __cplusplus
4378 }
4379 #endif\
4380 "
4381           fi
4382
4383           pic_flag_for_symtable=
4384           case $host in
4385           # compiling the symbol table file with pic_flag works around
4386           # a FreeBSD bug that causes programs to crash when -lm is
4387           # linked before any other PIC object.  But we must not use
4388           # pic_flag when linking with -static.  The problem exists in
4389           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4390           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4391             case "$compile_command " in
4392             *" -static "*) ;;
4393             *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4394             esac;;
4395           *-*-hpux*)
4396             case "$compile_command " in
4397             *" -static "*) ;;
4398             *) pic_flag_for_symtable=" $pic_flag";;
4399             esac
4400           esac
4401
4402           # Now compile the dynamic symbol file.
4403           $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4404           $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4405
4406           # Clean up the generated files.
4407           $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4408           $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4409
4410           # Transform the symbol file into the correct name.
4411           compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4412           finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4413           ;;
4414         *)
4415           $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4416           exit $EXIT_FAILURE
4417           ;;
4418         esac
4419       else
4420         # We keep going just in case the user didn't refer to
4421         # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
4422         # really was required.
4423
4424         # Nullify the symbol file.
4425         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
4426         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
4427       fi
4428
4429       if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
4430         # Replace the output file specification.
4431         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4432         link_command="$compile_command$compile_rpath"
4433
4434         # We have no uninstalled library dependencies, so finalize right now.
4435         $show "$link_command"
4436         $run eval "$link_command"
4437         status=$?
4438
4439         # Delete the generated files.
4440         if test -n "$dlsyms"; then
4441           $show "$rm $output_objdir/${outputname}S.${objext}"
4442           $run $rm "$output_objdir/${outputname}S.${objext}"
4443         fi
4444
4445         exit $status
4446       fi
4447
4448       if test -n "$shlibpath_var"; then
4449         # We should set the shlibpath_var
4450         rpath=
4451         for dir in $temp_rpath; do
4452           case $dir in
4453           [\\/]* | [A-Za-z]:[\\/]*)
4454             # Absolute path.
4455             rpath="$rpath$dir:"
4456             ;;
4457           *)
4458             # Relative path: add a thisdir entry.
4459             rpath="$rpath\$thisdir/$dir:"
4460             ;;
4461           esac
4462         done
4463         temp_rpath="$rpath"
4464       fi
4465
4466       if test -n "$compile_shlibpath$finalize_shlibpath"; then
4467         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
4468       fi
4469       if test -n "$finalize_shlibpath"; then
4470         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
4471       fi
4472
4473       compile_var=
4474       finalize_var=
4475       if test -n "$runpath_var"; then
4476         if test -n "$perm_rpath"; then
4477           # We should set the runpath_var.
4478           rpath=
4479           for dir in $perm_rpath; do
4480             rpath="$rpath$dir:"
4481           done
4482           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
4483         fi
4484         if test -n "$finalize_perm_rpath"; then
4485           # We should set the runpath_var.
4486           rpath=
4487           for dir in $finalize_perm_rpath; do
4488             rpath="$rpath$dir:"
4489           done
4490           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
4491         fi
4492       fi
4493
4494       if test "$no_install" = yes; then
4495         # We don't need to create a wrapper script.
4496         link_command="$compile_var$compile_command$compile_rpath"
4497         # Replace the output file specification.
4498         link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4499         # Delete the old output file.
4500         $run $rm $output
4501         # Link the executable and exit
4502         $show "$link_command"
4503         $run eval "$link_command" || exit $?
4504         exit $EXIT_SUCCESS
4505       fi
4506
4507       if test "$hardcode_action" = relink; then
4508         # Fast installation is not supported
4509         link_command="$compile_var$compile_command$compile_rpath"
4510         relink_command="$finalize_var$finalize_command$finalize_rpath"
4511
4512         $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
4513         $echo "$modename: \`$output' will be relinked during installation" 1>&2
4514       else
4515         if test "$fast_install" != no; then
4516           link_command="$finalize_var$compile_command$finalize_rpath"
4517           if test "$fast_install" = yes; then
4518             relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
4519           else
4520             # fast_install is set to needless
4521             relink_command=
4522           fi
4523         else
4524           link_command="$compile_var$compile_command$compile_rpath"
4525           relink_command="$finalize_var$finalize_command$finalize_rpath"
4526         fi
4527       fi
4528
4529       # Replace the output file specification.
4530       link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4531
4532       # Delete the old output files.
4533       $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
4534
4535       $show "$link_command"
4536       $run eval "$link_command" || exit $?
4537
4538       # Now create the wrapper script.
4539       $show "creating $output"
4540
4541       # Quote the relink command for shipping.
4542       if test -n "$relink_command"; then
4543         # Preserve any variables that may affect compiler behavior
4544         for var in $variables_saved_for_relink; do
4545           if eval test -z \"\${$var+set}\"; then
4546             relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
4547           elif eval var_value=\$$var; test -z "$var_value"; then
4548             relink_command="$var=; export $var; $relink_command"
4549           else
4550             var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4551             relink_command="$var=\"$var_value\"; export $var; $relink_command"
4552           fi
4553         done
4554         relink_command="(cd `pwd`; $relink_command)"
4555         relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4556       fi
4557
4558       # Quote $echo for shipping.
4559       if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
4560         case $progpath in
4561         [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4562         *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4563         esac
4564         qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
4565       else
4566         qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
4567       fi
4568
4569       # Only actually do things if our run command is non-null.
4570       if test -z "$run"; then
4571         # win32 will think the script is a binary if it has
4572         # a .exe suffix, so we strip it off here.
4573         case $output in
4574           *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
4575         esac
4576         # test for cygwin because mv fails w/o .exe extensions
4577         case $host in
4578           *cygwin*)
4579             exeext=.exe
4580             outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
4581           *) exeext= ;;
4582         esac
4583         case $host in
4584           *cygwin* | *mingw* )
4585             cwrappersource=`$echo ${objdir}/lt-${output}.c`
4586             cwrapper=`$echo ${output}.exe`
4587             $rm $cwrappersource $cwrapper
4588             trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4589
4590             cat > $cwrappersource <<EOF
4591
4592 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4593    Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4594
4595    The $output program cannot be directly executed until all the libtool
4596    libraries that it depends on are installed.
4597
4598    This wrapper executable should never be moved out of the build directory.
4599    If it is, it will not operate correctly.
4600
4601    Currently, it simply execs the wrapper *script* "/bin/sh $output",
4602    but could eventually absorb all of the scripts functionality and
4603    exec $objdir/$outputname directly.
4604 */
4605 EOF
4606             cat >> $cwrappersource<<"EOF"
4607 #include <stdio.h>
4608 #include <stdlib.h>
4609 #include <unistd.h>
4610 #include <malloc.h>
4611 #include <stdarg.h>
4612 #include <assert.h>
4613
4614 #if defined(PATH_MAX)
4615 # define LT_PATHMAX PATH_MAX
4616 #elif defined(MAXPATHLEN)
4617 # define LT_PATHMAX MAXPATHLEN
4618 #else
4619 # define LT_PATHMAX 1024
4620 #endif
4621
4622 #ifndef DIR_SEPARATOR
4623 #define DIR_SEPARATOR '/'
4624 #endif
4625
4626 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4627   defined (__OS2__)
4628 #define HAVE_DOS_BASED_FILE_SYSTEM
4629 #ifndef DIR_SEPARATOR_2
4630 #define DIR_SEPARATOR_2 '\\'
4631 #endif
4632 #endif
4633
4634 #ifndef DIR_SEPARATOR_2
4635 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4636 #else /* DIR_SEPARATOR_2 */
4637 # define IS_DIR_SEPARATOR(ch) \
4638         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4639 #endif /* DIR_SEPARATOR_2 */
4640
4641 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
4642 #define XFREE(stale) do { \
4643   if (stale) { free ((void *) stale); stale = 0; } \
4644 } while (0)
4645
4646 const char *program_name = NULL;
4647
4648 void * xmalloc (size_t num);
4649 char * xstrdup (const char *string);
4650 char * basename (const char *name);
4651 char * fnqualify(const char *path);
4652 char * strendzap(char *str, const char *pat);
4653 void lt_fatal (const char *message, ...);
4654
4655 int
4656 main (int argc, char *argv[])
4657 {
4658   char **newargz;
4659   int i;
4660
4661   program_name = (char *) xstrdup ((char *) basename (argv[0]));
4662   newargz = XMALLOC(char *, argc+2);
4663 EOF
4664
4665             cat >> $cwrappersource <<EOF
4666   newargz[0] = "$SHELL";
4667 EOF
4668
4669             cat >> $cwrappersource <<"EOF"
4670   newargz[1] = fnqualify(argv[0]);
4671   /* we know the script has the same name, without the .exe */
4672   /* so make sure newargz[1] doesn't end in .exe */
4673   strendzap(newargz[1],".exe");
4674   for (i = 1; i < argc; i++)
4675     newargz[i+1] = xstrdup(argv[i]);
4676   newargz[argc+1] = NULL;
4677 EOF
4678
4679             cat >> $cwrappersource <<EOF
4680   execv("$SHELL",newargz);
4681 EOF
4682
4683             cat >> $cwrappersource <<"EOF"
4684 }
4685
4686 void *
4687 xmalloc (size_t num)
4688 {
4689   void * p = (void *) malloc (num);
4690   if (!p)
4691     lt_fatal ("Memory exhausted");
4692
4693   return p;
4694 }
4695
4696 char *
4697 xstrdup (const char *string)
4698 {
4699   return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
4700 ;
4701 }
4702
4703 char *
4704 basename (const char *name)
4705 {
4706   const char *base;
4707
4708 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4709   /* Skip over the disk name in MSDOS pathnames. */
4710   if (isalpha (name[0]) && name[1] == ':')
4711     name += 2;
4712 #endif
4713
4714   for (base = name; *name; name++)
4715     if (IS_DIR_SEPARATOR (*name))
4716       base = name + 1;
4717   return (char *) base;
4718 }
4719
4720 char *
4721 fnqualify(const char *path)
4722 {
4723   size_t size;
4724   char *p;
4725   char tmp[LT_PATHMAX + 1];
4726
4727   assert(path != NULL);
4728
4729   /* Is it qualified already? */
4730 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4731   if (isalpha (path[0]) && path[1] == ':')
4732     return xstrdup (path);
4733 #endif
4734   if (IS_DIR_SEPARATOR (path[0]))
4735     return xstrdup (path);
4736
4737   /* prepend the current directory */
4738   /* doesn't handle '~' */
4739   if (getcwd (tmp, LT_PATHMAX) == NULL)
4740     lt_fatal ("getcwd failed");
4741   size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '\0' */
4742   p = XMALLOC(char, size);
4743   sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path);
4744   return p;
4745 }
4746
4747 char *
4748 strendzap(char *str, const char *pat)
4749 {
4750   size_t len, patlen;
4751
4752   assert(str != NULL);
4753   assert(pat != NULL);
4754
4755   len = strlen(str);
4756   patlen = strlen(pat);
4757
4758   if (patlen <= len)
4759   {
4760     str += len - patlen;
4761     if (strcmp(str, pat) == 0)
4762       *str = '\0';
4763   }
4764   return str;
4765 }
4766
4767 static void
4768 lt_error_core (int exit_status, const char * mode,
4769           const char * message, va_list ap)
4770 {
4771   fprintf (stderr, "%s: %s: ", program_name, mode);
4772   vfprintf (stderr, message, ap);
4773   fprintf (stderr, ".\n");
4774
4775   if (exit_status >= 0)
4776     exit (exit_status);
4777 }
4778
4779 void
4780 lt_fatal (const char *message, ...)
4781 {
4782   va_list ap;
4783   va_start (ap, message);
4784   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4785   va_end (ap);
4786 }
4787 EOF
4788           # we should really use a build-platform specific compiler
4789           # here, but OTOH, the wrappers (shell script and this C one)
4790           # are only useful if you want to execute the "real" binary.
4791           # Since the "real" binary is built for $host, then this
4792           # wrapper might as well be built for $host, too.
4793           $run $LTCC -s -o $cwrapper $cwrappersource
4794           ;;
4795         esac
4796         $rm $output
4797         trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
4798
4799         $echo > $output "\
4800 #! $SHELL
4801
4802 # $output - temporary wrapper script for $objdir/$outputname
4803 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4804 #
4805 # The $output program cannot be directly executed until all the libtool
4806 # libraries that it depends on are installed.
4807 #
4808 # This wrapper script should never be moved out of the build directory.
4809 # If it is, it will not operate correctly.
4810
4811 # Sed substitution that helps us do robust quoting.  It backslashifies
4812 # metacharacters that are still active within double-quoted strings.
4813 Xsed='${SED} -e 1s/^X//'
4814 sed_quote_subst='$sed_quote_subst'
4815
4816 # The HP-UX ksh and POSIX shell print the target directory to stdout
4817 # if CDPATH is set.
4818 if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
4819
4820 relink_command=\"$relink_command\"
4821
4822 # This environment variable determines our operation mode.
4823 if test \"\$libtool_install_magic\" = \"$magic\"; then
4824   # install mode needs the following variable:
4825   notinst_deplibs='$notinst_deplibs'
4826 else
4827   # When we are sourced in execute mode, \$file and \$echo are already set.
4828   if test \"\$libtool_execute_magic\" != \"$magic\"; then
4829     echo=\"$qecho\"
4830     file=\"\$0\"
4831     # Make sure echo works.
4832     if test \"X\$1\" = X--no-reexec; then
4833       # Discard the --no-reexec flag, and continue.
4834       shift
4835     elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
4836       # Yippee, \$echo works!
4837       :
4838     else
4839       # Restart under the correct shell, and then maybe \$echo will work.
4840       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
4841     fi
4842   fi\
4843 "
4844         $echo >> $output "\
4845
4846   # Find the directory that this script lives in.
4847   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
4848   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4849
4850   # Follow symbolic links until we get to the real thisdir.
4851   file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
4852   while test -n \"\$file\"; do
4853     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
4854
4855     # If there was a directory component, then change thisdir.
4856     if test \"x\$destdir\" != \"x\$file\"; then
4857       case \"\$destdir\" in
4858       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4859       *) thisdir=\"\$thisdir/\$destdir\" ;;
4860       esac
4861     fi
4862
4863     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
4864     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
4865   done
4866
4867   # Try to get the absolute directory name.
4868   absdir=\`cd \"\$thisdir\" && pwd\`
4869   test -n \"\$absdir\" && thisdir=\"\$absdir\"
4870 "
4871
4872         if test "$fast_install" = yes; then
4873           $echo >> $output "\
4874   program=lt-'$outputname'$exeext
4875   progdir=\"\$thisdir/$objdir\"
4876
4877   if test ! -f \"\$progdir/\$program\" || \\
4878      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4879        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4880
4881     file=\"\$\$-\$program\"
4882
4883     if test ! -d \"\$progdir\"; then
4884       $mkdir \"\$progdir\"
4885     else
4886       $rm \"\$progdir/\$file\"
4887     fi"
4888
4889           $echo >> $output "\
4890
4891     # relink executable if necessary
4892     if test -n \"\$relink_command\"; then
4893       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4894       else
4895         $echo \"\$relink_command_output\" >&2
4896         $rm \"\$progdir/\$file\"
4897         exit $EXIT_FAILURE
4898       fi
4899     fi
4900
4901     $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4902     { $rm \"\$progdir/\$program\";
4903       $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4904     $rm \"\$progdir/\$file\"
4905   fi"
4906         else
4907           $echo >> $output "\
4908   program='$outputname'
4909   progdir=\"\$thisdir/$objdir\"
4910 "
4911         fi
4912
4913         $echo >> $output "\
4914
4915   if test -f \"\$progdir/\$program\"; then"
4916
4917         # Export our shlibpath_var if we have one.
4918         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4919           $echo >> $output "\
4920     # Add our own library path to $shlibpath_var
4921     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4922
4923     # Some systems cannot cope with colon-terminated $shlibpath_var
4924     # The second colon is a workaround for a bug in BeOS R4 sed
4925     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
4926
4927     export $shlibpath_var
4928 "
4929         fi
4930
4931         # fixup the dll searchpath if we need to.
4932         if test -n "$dllsearchpath"; then
4933           $echo >> $output "\
4934     # Add the dll search path components to the executable PATH
4935     PATH=$dllsearchpath:\$PATH
4936 "
4937         fi
4938
4939         $echo >> $output "\
4940     if test \"\$libtool_execute_magic\" != \"$magic\"; then
4941       # Run the actual program with our arguments.
4942 "
4943         case $host in
4944         # Backslashes separate directories on plain windows
4945         *-*-mingw | *-*-os2*)
4946           $echo >> $output "\
4947       exec \$progdir\\\\\$program \${1+\"\$@\"}
4948 "
4949           ;;
4950
4951         *)
4952           $echo >> $output "\
4953       exec \$progdir/\$program \${1+\"\$@\"}
4954 "
4955           ;;
4956         esac
4957         $echo >> $output "\
4958       \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
4959       exit $EXIT_FAILURE
4960     fi
4961   else
4962     # The program doesn't exist.
4963     \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
4964     \$echo \"This script is just a wrapper for \$program.\" 1>&2
4965     $echo \"See the $PACKAGE documentation for more information.\" 1>&2
4966     exit $EXIT_FAILURE
4967   fi
4968 fi\
4969 "
4970         chmod +x $output
4971       fi
4972       exit $EXIT_SUCCESS
4973       ;;
4974     esac
4975
4976     # See if we need to build an old-fashioned archive.
4977     for oldlib in $oldlibs; do
4978
4979       if test "$build_libtool_libs" = convenience; then
4980         oldobjs="$libobjs_save"
4981         addlibs="$convenience"
4982         build_libtool_libs=no
4983       else
4984         if test "$build_libtool_libs" = module; then
4985           oldobjs="$libobjs_save"
4986           build_libtool_libs=no
4987         else
4988           oldobjs="$old_deplibs $non_pic_objects"
4989         fi
4990         addlibs="$old_convenience"
4991       fi
4992
4993       if test -n "$addlibs"; then
4994         gentop="$output_objdir/${outputname}x"
4995         $show "${rm}r $gentop"
4996         $run ${rm}r "$gentop"
4997         $show "$mkdir $gentop"
4998         $run $mkdir "$gentop"
4999         status=$?
5000         if test "$status" -ne 0 && test ! -d "$gentop"; then
5001           exit $status
5002         fi
5003         generated="$generated $gentop"
5004
5005         # Add in members from convenience archives.
5006         for xlib in $addlibs; do
5007           # Extract the objects.
5008           case $xlib in
5009           [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
5010           *) xabs=`pwd`"/$xlib" ;;
5011           esac
5012           xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
5013           xdir="$gentop/$xlib"
5014
5015           $show "${rm}r $xdir"
5016           $run ${rm}r "$xdir"
5017           $show "$mkdir $xdir"
5018           $run $mkdir "$xdir"
5019           status=$?
5020           if test "$status" -ne 0 && test ! -d "$xdir"; then
5021             exit $status
5022           fi
5023           # We will extract separately just the conflicting names and we will no
5024           # longer touch any unique names. It is faster to leave these extract
5025           # automatically by $AR in one run.
5026           $show "(cd $xdir && $AR x $xabs)"
5027           $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
5028           if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
5029             :
5030           else
5031             $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
5032             $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
5033             $AR t "$xabs" | sort | uniq -cd | while read -r count name
5034             do
5035               i=1
5036               while test "$i" -le "$count"
5037               do
5038                # Put our $i before any first dot (extension)
5039                # Never overwrite any file
5040                name_to="$name"
5041                while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
5042                do
5043                  name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
5044                done
5045                $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
5046                $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
5047                i=`expr $i + 1`
5048               done
5049             done
5050           fi
5051
5052           oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP`
5053         done
5054       fi
5055
5056       # Do each command in the archive commands.
5057       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
5058        cmds=$old_archive_from_new_cmds
5059       else
5060         eval cmds=\"$old_archive_cmds\"
5061
5062         if len=`expr "X$cmds" : ".*"` &&
5063              test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
5064           cmds=$old_archive_cmds
5065         else
5066           # the command line is too long to link in one step, link in parts
5067           $echo "using piecewise archive linking..."
5068           save_RANLIB=$RANLIB
5069           RANLIB=:
5070           objlist=
5071           concat_cmds=
5072           save_oldobjs=$oldobjs
5073           # GNU ar 2.10+ was changed to match POSIX; thus no paths are
5074           # encoded into archives.  This makes 'ar r' malfunction in
5075           # this piecewise linking case whenever conflicting object
5076           # names appear in distinct ar calls; check, warn and compensate.
5077             if (for obj in $save_oldobjs
5078             do
5079               $echo "X$obj" | $Xsed -e 's%^.*/%%'
5080             done | sort | sort -uc >/dev/null 2>&1); then
5081             :
5082           else
5083             $echo "$modename: warning: object name conflicts; overriding AR_FLAGS to 'cq'" 1>&2
5084             $echo "$modename: warning: to ensure that POSIX-compatible ar will work" 1>&2
5085             AR_FLAGS=cq
5086           fi
5087           # Is there a better way of finding the last object in the list?
5088           for obj in $save_oldobjs
5089           do
5090             last_oldobj=$obj
5091           done
5092           for obj in $save_oldobjs
5093           do
5094             oldobjs="$objlist $obj"
5095             objlist="$objlist $obj"
5096             eval test_cmds=\"$old_archive_cmds\"
5097             if len=`expr "X$test_cmds" : ".*"` &&
5098                test "$len" -le "$max_cmd_len"; then
5099               :
5100             else
5101               # the above command should be used before it gets too long
5102               oldobjs=$objlist
5103               if test "$obj" = "$last_oldobj" ; then
5104                 RANLIB=$save_RANLIB
5105               fi
5106               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
5107               eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
5108               objlist=
5109             fi
5110           done
5111           RANLIB=$save_RANLIB
5112           oldobjs=$objlist
5113           if test "X$oldobjs" = "X" ; then
5114             eval cmds=\"\$concat_cmds\"
5115           else
5116             eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
5117           fi
5118         fi
5119       fi
5120       save_ifs="$IFS"; IFS='~'
5121       for cmd in $cmds; do
5122         eval cmd=\"$cmd\"
5123         IFS="$save_ifs"
5124         $show "$cmd"
5125         $run eval "$cmd" || exit $?
5126       done
5127       IFS="$save_ifs"
5128     done
5129
5130     if test -n "$generated"; then
5131       $show "${rm}r$generated"
5132       $run ${rm}r$generated
5133     fi
5134
5135     # Now create the libtool archive.
5136     case $output in
5137     *.la)
5138       old_library=
5139       test "$build_old_libs" = yes && old_library="$libname.$libext"
5140       $show "creating $output"
5141
5142       # Preserve any variables that may affect compiler behavior
5143       for var in $variables_saved_for_relink; do
5144         if eval test -z \"\${$var+set}\"; then
5145           relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
5146         elif eval var_value=\$$var; test -z "$var_value"; then
5147           relink_command="$var=; export $var; $relink_command"
5148         else
5149           var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
5150           relink_command="$var=\"$var_value\"; export $var; $relink_command"
5151         fi
5152       done
5153       # Quote the link command for shipping.
5154       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
5155       relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
5156       if test "$hardcode_automatic" = yes ; then
5157         relink_command=
5158       fi
5159
5160
5161       # Only create the output if not a dry run.
5162       if test -z "$run"; then
5163         for installed in no yes; do
5164           if test "$installed" = yes; then
5165             if test -z "$install_libdir"; then
5166               break
5167             fi
5168             output="$output_objdir/$outputname"i
5169             # Replace all uninstalled libtool libraries with the installed ones
5170             newdependency_libs=
5171             for deplib in $dependency_libs; do
5172               case $deplib in
5173               *.la)
5174                 name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
5175                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5176                 if test -z "$libdir"; then
5177                   $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
5178                   exit $EXIT_FAILURE
5179                 fi
5180                 newdependency_libs="$newdependency_libs $libdir/$name"
5181                 ;;
5182               *) newdependency_libs="$newdependency_libs $deplib" ;;
5183               esac
5184             done
5185             dependency_libs="$newdependency_libs"
5186             newdlfiles=
5187             for lib in $dlfiles; do
5188               name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5189               eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5190               if test -z "$libdir"; then
5191                 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5192                 exit $EXIT_FAILURE
5193               fi
5194               newdlfiles="$newdlfiles $libdir/$name"
5195             done
5196             dlfiles="$newdlfiles"
5197             newdlprefiles=
5198             for lib in $dlprefiles; do
5199               name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5200               eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5201               if test -z "$libdir"; then
5202                 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5203                 exit $EXIT_FAILURE
5204               fi
5205               newdlprefiles="$newdlprefiles $libdir/$name"
5206             done
5207             dlprefiles="$newdlprefiles"
5208           else
5209             newdlfiles=
5210             for lib in $dlfiles; do
5211               case $lib in
5212                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5213                 *) abs=`pwd`"/$lib" ;;
5214               esac
5215               newdlfiles="$newdlfiles $abs"
5216             done
5217             dlfiles="$newdlfiles"
5218             newdlprefiles=
5219             for lib in $dlprefiles; do
5220               case $lib in
5221                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5222                 *) abs=`pwd`"/$lib" ;;
5223               esac
5224               newdlprefiles="$newdlprefiles $abs"
5225             done
5226             dlprefiles="$newdlprefiles"
5227           fi
5228           $rm $output
5229           # place dlname in correct position for cygwin
5230           tdlname=$dlname
5231           case $host,$output,$installed,$module,$dlname in
5232             *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
5233           esac
5234           $echo > $output "\
5235 # $outputname - a libtool library file
5236 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5237 #
5238 # Please DO NOT delete this file!
5239 # It is necessary for linking the library.
5240
5241 # The name that we can dlopen(3).
5242 dlname='$tdlname'
5243
5244 # Names of this library.
5245 library_names='$library_names'
5246
5247 # The name of the static archive.
5248 old_library='$old_library'
5249
5250 # Libraries that this one depends upon.
5251 dependency_libs='$dependency_libs'
5252
5253 # Version information for $libname.
5254 current=$current
5255 age=$age
5256 revision=$revision
5257
5258 # Is this an already installed library?
5259 installed=$installed
5260
5261 # Should we warn about portability when linking against -modules?
5262 shouldnotlink=$module
5263
5264 # Files to dlopen/dlpreopen
5265 dlopen='$dlfiles'
5266 dlpreopen='$dlprefiles'
5267
5268 # Directory that this library needs to be installed in:
5269 libdir='$install_libdir'"
5270           if test "$installed" = no && test "$need_relink" = yes; then
5271             $echo >> $output "\
5272 relink_command=\"$relink_command\""
5273           fi
5274         done
5275       fi
5276
5277       # Do a symbolic link so that the libtool archive can be found in
5278       # LD_LIBRARY_PATH before the program is installed.
5279       $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5280       $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5281       ;;
5282     esac
5283     exit $EXIT_SUCCESS
5284     ;;
5285
5286   # libtool install mode
5287   install)
5288     modename="$modename: install"
5289
5290     # There may be an optional sh(1) argument at the beginning of
5291     # install_prog (especially on Windows NT).
5292     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5293        # Allow the use of GNU shtool's install command.
5294        $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
5295       # Aesthetically quote it.
5296       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5297       case $arg in
5298       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
5299         arg="\"$arg\""
5300         ;;
5301       esac
5302       install_prog="$arg "
5303       arg="$1"
5304       shift
5305     else
5306       install_prog=
5307       arg="$nonopt"
5308     fi
5309
5310     # The real first argument should be the name of the installation program.
5311     # Aesthetically quote it.
5312     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5313     case $arg in
5314     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
5315       arg="\"$arg\""
5316       ;;
5317     esac
5318     install_prog="$install_prog$arg"
5319
5320     # We need to accept at least all the BSD install flags.
5321     dest=
5322     files=
5323     opts=
5324     prev=
5325     install_type=
5326     isdir=no
5327     stripme=
5328     for arg
5329     do
5330       if test -n "$dest"; then
5331         files="$files $dest"
5332         dest="$arg"
5333         continue
5334       fi
5335
5336       case $arg in
5337       -d) isdir=yes ;;
5338       -f) prev="-f" ;;
5339       -g) prev="-g" ;;
5340       -m) prev="-m" ;;
5341       -o) prev="-o" ;;
5342       -s)
5343         stripme=" -s"
5344         continue
5345         ;;
5346       -*) ;;
5347
5348       *)
5349         # If the previous option needed an argument, then skip it.
5350         if test -n "$prev"; then
5351           prev=
5352         else
5353           dest="$arg"
5354           continue
5355         fi
5356         ;;
5357       esac
5358
5359       # Aesthetically quote the argument.
5360       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5361       case $arg in
5362       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
5363         arg="\"$arg\""
5364         ;;
5365       esac
5366       install_prog="$install_prog $arg"
5367     done
5368
5369     if test -z "$install_prog"; then
5370       $echo "$modename: you must specify an install program" 1>&2
5371       $echo "$help" 1>&2
5372       exit $EXIT_FAILURE
5373     fi
5374
5375     if test -n "$prev"; then
5376       $echo "$modename: the \`$prev' option requires an argument" 1>&2
5377       $echo "$help" 1>&2
5378       exit $EXIT_FAILURE
5379     fi
5380
5381     if test -z "$files"; then
5382       if test -z "$dest"; then
5383         $echo "$modename: no file or destination specified" 1>&2
5384       else
5385         $echo "$modename: you must specify a destination" 1>&2
5386       fi
5387       $echo "$help" 1>&2
5388       exit $EXIT_FAILURE
5389     fi
5390
5391     # Strip any trailing slash from the destination.
5392     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5393
5394     # Check to see that the destination is a directory.
5395     test -d "$dest" && isdir=yes
5396     if test "$isdir" = yes; then
5397       destdir="$dest"
5398       destname=
5399     else
5400       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5401       test "X$destdir" = "X$dest" && destdir=.
5402       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5403
5404       # Not a directory, so check to see that there is only one file specified.
5405       set dummy $files
5406       if test "$#" -gt 2; then
5407         $echo "$modename: \`$dest' is not a directory" 1>&2
5408         $echo "$help" 1>&2
5409         exit $EXIT_FAILURE
5410       fi
5411     fi
5412     case $destdir in
5413     [\\/]* | [A-Za-z]:[\\/]*) ;;
5414     *)
5415       for file in $files; do
5416         case $file in
5417         *.lo) ;;
5418         *)
5419           $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5420           $echo "$help" 1>&2
5421           exit $EXIT_FAILURE
5422           ;;
5423         esac
5424       done
5425       ;;
5426     esac
5427
5428     # This variable tells wrapper scripts just to set variables rather
5429     # than running their programs.
5430     libtool_install_magic="$magic"
5431
5432     staticlibs=
5433     future_libdirs=
5434     current_libdirs=
5435     for file in $files; do
5436
5437       # Do each installation.
5438       case $file in
5439       *.$libext)
5440         # Do the static libraries later.
5441         staticlibs="$staticlibs $file"
5442         ;;
5443
5444       *.la)
5445         # Check to see that this really is a libtool archive.
5446         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5447         else
5448           $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5449           $echo "$help" 1>&2
5450           exit $EXIT_FAILURE
5451         fi
5452
5453         library_names=
5454         old_library=
5455         relink_command=
5456         # If there is no directory component, then add one.
5457         case $file in
5458         */* | *\\*) . $file ;;
5459         *) . ./$file ;;
5460         esac
5461
5462         # Add the libdir to current_libdirs if it is the destination.
5463         if test "X$destdir" = "X$libdir"; then
5464           case "$current_libdirs " in
5465           *" $libdir "*) ;;
5466           *) current_libdirs="$current_libdirs $libdir" ;;
5467           esac
5468         else
5469           # Note the libdir as a future libdir.
5470           case "$future_libdirs " in
5471           *" $libdir "*) ;;
5472           *) future_libdirs="$future_libdirs $libdir" ;;
5473           esac
5474         fi
5475
5476         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5477         test "X$dir" = "X$file/" && dir=
5478         dir="$dir$objdir"
5479
5480         if test -n "$relink_command"; then
5481           # Determine the prefix the user has applied to our future dir.
5482           inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5483
5484           # Don't allow the user to place us outside of our expected
5485           # location b/c this prevents finding dependent libraries that
5486           # are installed to the same prefix.
5487           # At present, this check doesn't affect windows .dll's that
5488           # are installed into $libdir/../bin (currently, that works fine)
5489           # but it's something to keep an eye on.
5490           if test "$inst_prefix_dir" = "$destdir"; then
5491             $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5492             exit $EXIT_FAILURE
5493           fi
5494
5495           if test -n "$inst_prefix_dir"; then
5496             # Stick the inst_prefix_dir data into the link command.
5497             relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
5498           else
5499             relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
5500           fi
5501
5502           $echo "$modename: warning: relinking \`$file'" 1>&2
5503           $show "$relink_command"
5504           if $run eval "$relink_command"; then :
5505           else
5506             $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5507             exit $EXIT_FAILURE
5508           fi
5509         fi
5510
5511         # See the names of the shared library.
5512         set dummy $library_names
5513         if test -n "$2"; then
5514           realname="$2"
5515           shift
5516           shift
5517
5518           srcname="$realname"
5519           test -n "$relink_command" && srcname="$realname"T
5520
5521           # Install the shared library and build the symlinks.
5522           $show "$install_prog $dir/$srcname $destdir/$realname"
5523           $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
5524           if test -n "$stripme" && test -n "$striplib"; then
5525             $show "$striplib $destdir/$realname"
5526             $run eval "$striplib $destdir/$realname" || exit $?
5527           fi
5528
5529           if test "$#" -gt 0; then
5530             # Delete the old symlinks, and create new ones.
5531             for linkname
5532             do
5533               if test "$linkname" != "$realname"; then
5534                 $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
5535                 $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
5536               fi
5537             done
5538           fi
5539
5540           # Do each command in the postinstall commands.
5541           lib="$destdir/$realname"
5542           cmds=$postinstall_cmds
5543           save_ifs="$IFS"; IFS='~'
5544           for cmd in $cmds; do
5545             IFS="$save_ifs"
5546             eval cmd=\"$cmd\"
5547             $show "$cmd"
5548             $run eval "$cmd" || exit $?
5549           done
5550           IFS="$save_ifs"
5551         fi
5552
5553         # Install the pseudo-library for information purposes.
5554         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5555         instname="$dir/$name"i
5556         $show "$install_prog $instname $destdir/$name"
5557         $run eval "$install_prog $instname $destdir/$name" || exit $?
5558
5559         # Maybe install the static library, too.
5560         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
5561         ;;
5562
5563       *.lo)
5564         # Install (i.e. copy) a libtool object.
5565
5566         # Figure out destination file name, if it wasn't already specified.
5567         if test -n "$destname"; then
5568           destfile="$destdir/$destname"
5569         else
5570           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5571           destfile="$destdir/$destfile"
5572         fi
5573
5574         # Deduce the name of the destination old-style object file.
5575         case $destfile in
5576         *.lo)
5577           staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
5578           ;;
5579         *.$objext)
5580           staticdest="$destfile"
5581           destfile=
5582           ;;
5583         *)
5584           $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
5585           $echo "$help" 1>&2
5586           exit $EXIT_FAILURE
5587           ;;
5588         esac
5589
5590         # Install the libtool object if requested.
5591         if test -n "$destfile"; then
5592           $show "$install_prog $file $destfile"
5593           $run eval "$install_prog $file $destfile" || exit $?
5594         fi
5595
5596         # Install the old object if enabled.
5597         if test "$build_old_libs" = yes; then
5598           # Deduce the name of the old-style object file.
5599           staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
5600
5601           $show "$install_prog $staticobj $staticdest"
5602           $run eval "$install_prog \$staticobj \$staticdest" || exit $?
5603         fi
5604         exit $EXIT_SUCCESS
5605         ;;
5606
5607       *)
5608         # Figure out destination file name, if it wasn't already specified.
5609         if test -n "$destname"; then
5610           destfile="$destdir/$destname"
5611         else
5612           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5613           destfile="$destdir/$destfile"
5614         fi
5615
5616         # If the file is missing, and there is a .exe on the end, strip it
5617         # because it is most likely a libtool script we actually want to
5618         # install
5619         stripped_ext=""
5620         case $file in
5621           *.exe)
5622             if test ! -f "$file"; then
5623               file=`$echo $file|${SED} 's,.exe$,,'`
5624               stripped_ext=".exe"
5625             fi
5626             ;;
5627         esac
5628
5629         # Do a test to see if this is really a libtool program.
5630         case $host in
5631         *cygwin*|*mingw*)
5632             wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
5633             ;;
5634         *)
5635             wrapper=$file
5636             ;;
5637         esac
5638         if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
5639           notinst_deplibs=
5640           relink_command=
5641
5642           # To insure that "foo" is sourced, and not "foo.exe",
5643           # finese the cygwin/MSYS system by explicitly sourcing "foo."
5644           # which disallows the automatic-append-.exe behavior.
5645           case $build in
5646           *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
5647           *) wrapperdot=${wrapper} ;;
5648           esac
5649           # If there is no directory component, then add one.
5650           case $file in
5651           */* | *\\*) . ${wrapperdot} ;;
5652           *) . ./${wrapperdot} ;;
5653           esac
5654
5655           # Check the variables that should have been set.
5656           if test -z "$notinst_deplibs"; then
5657             $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
5658             exit $EXIT_FAILURE
5659           fi
5660
5661           finalize=yes
5662           for lib in $notinst_deplibs; do
5663             # Check to see that each library is installed.
5664             libdir=
5665             if test -f "$lib"; then
5666               # If there is no directory component, then add one.
5667               case $lib in
5668               */* | *\\*) . $lib ;;
5669               *) . ./$lib ;;
5670               esac
5671             fi
5672             libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
5673             if test -n "$libdir" && test ! -f "$libfile"; then
5674               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
5675               finalize=no
5676             fi
5677           done
5678
5679           relink_command=
5680           # To insure that "foo" is sourced, and not "foo.exe",
5681           # finese the cygwin/MSYS system by explicitly sourcing "foo."
5682           # which disallows the automatic-append-.exe behavior.
5683           case $build in
5684           *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
5685           *) wrapperdot=${wrapper} ;;
5686           esac
5687           # If there is no directory component, then add one.
5688           case $file in
5689           */* | *\\*) . ${wrapperdot} ;;
5690           *) . ./${wrapperdot} ;;
5691           esac
5692
5693           outputname=
5694           if test "$fast_install" = no && test -n "$relink_command"; then
5695             if test "$finalize" = yes && test -z "$run"; then
5696               tmpdir="/tmp"
5697               test -n "$TMPDIR" && tmpdir="$TMPDIR"
5698               tmpdir="$tmpdir/libtool-$$"
5699               save_umask=`umask`
5700               umask 0077
5701               if $mkdir "$tmpdir"; then
5702                 umask $save_umask
5703               else
5704                 umask $save_umask
5705                 $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
5706                 continue
5707               fi
5708               file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
5709               outputname="$tmpdir/$file"
5710               # Replace the output file specification.
5711               relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
5712
5713               $show "$relink_command"
5714               if $run eval "$relink_command"; then :
5715               else
5716                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5717                 ${rm}r "$tmpdir"
5718                 continue
5719               fi
5720               file="$outputname"
5721             else
5722               $echo "$modename: warning: cannot relink \`$file'" 1>&2
5723             fi
5724           else
5725             # Install the binary that we compiled earlier.
5726             file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
5727           fi
5728         fi
5729
5730         # remove .exe since cygwin /usr/bin/install will append another
5731         # one anyways
5732         case $install_prog,$host in
5733         */usr/bin/install*,*cygwin*)
5734           case $file:$destfile in
5735           *.exe:*.exe)
5736             # this is ok
5737             ;;
5738           *.exe:*)
5739             destfile=$destfile.exe
5740             ;;
5741           *:*.exe)
5742             destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
5743             ;;
5744           esac
5745           ;;
5746         esac
5747         $show "$install_prog$stripme $file $destfile"
5748         $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
5749         test -n "$outputname" && ${rm}r "$tmpdir"
5750         ;;
5751       esac
5752     done
5753
5754     for file in $staticlibs; do
5755       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5756
5757       # Set up the ranlib parameters.
5758       oldlib="$destdir/$name"
5759
5760       $show "$install_prog $file $oldlib"
5761       $run eval "$install_prog \$file \$oldlib" || exit $?
5762
5763       if test -n "$stripme" && test -n "$old_striplib"; then
5764         $show "$old_striplib $oldlib"
5765         $run eval "$old_striplib $oldlib" || exit $?
5766       fi
5767
5768       # Do each command in the postinstall commands.
5769       cmds=$old_postinstall_cmds
5770       save_ifs="$IFS"; IFS='~'
5771       for cmd in $cmds; do
5772         IFS="$save_ifs"
5773         eval cmd=\"$cmd\"
5774         $show "$cmd"
5775         $run eval "$cmd" || exit $?
5776       done
5777       IFS="$save_ifs"
5778     done
5779
5780     if test -n "$future_libdirs"; then
5781       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
5782     fi
5783
5784     if test -n "$current_libdirs"; then
5785       # Maybe just do a dry run.
5786       test -n "$run" && current_libdirs=" -n$current_libdirs"
5787       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
5788     else
5789       exit $EXIT_SUCCESS
5790     fi
5791     ;;
5792
5793   # libtool finish mode
5794   finish)
5795     modename="$modename: finish"
5796     libdirs="$nonopt"
5797     admincmds=
5798
5799     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
5800       for dir
5801       do
5802         libdirs="$libdirs $dir"
5803       done
5804
5805       for libdir in $libdirs; do
5806         if test -n "$finish_cmds"; then
5807           # Do each command in the finish commands.
5808           cmds=$finish_cmds
5809           save_ifs="$IFS"; IFS='~'
5810           for cmd in $cmds; do
5811             IFS="$save_ifs"
5812             eval cmd=\"$cmd\"
5813             $show "$cmd"
5814             $run eval "$cmd" || admincmds="$admincmds
5815        $cmd"
5816           done
5817           IFS="$save_ifs"
5818         fi
5819         if test -n "$finish_eval"; then
5820           # Do the single finish_eval.
5821           eval cmds=\"$finish_eval\"
5822           $run eval "$cmds" || admincmds="$admincmds
5823        $cmds"
5824         fi
5825       done
5826     fi
5827
5828     # Exit here if they wanted silent mode.
5829     test "$show" = : && exit $EXIT_SUCCESS
5830
5831     $echo "----------------------------------------------------------------------"
5832     $echo "Libraries have been installed in:"
5833     for libdir in $libdirs; do
5834       $echo "   $libdir"
5835     done
5836     $echo
5837     $echo "If you ever happen to want to link against installed libraries"
5838     $echo "in a given directory, LIBDIR, you must either use libtool, and"
5839     $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
5840     $echo "flag during linking and do at least one of the following:"
5841     if test -n "$shlibpath_var"; then
5842       $echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
5843       $echo "     during execution"
5844     fi
5845     if test -n "$runpath_var"; then
5846       $echo "   - add LIBDIR to the \`$runpath_var' environment variable"
5847       $echo "     during linking"
5848     fi
5849     if test -n "$hardcode_libdir_flag_spec"; then
5850       libdir=LIBDIR
5851       eval flag=\"$hardcode_libdir_flag_spec\"
5852
5853       $echo "   - use the \`$flag' linker flag"
5854     fi
5855     if test -n "$admincmds"; then
5856       $echo "   - have your system administrator run these commands:$admincmds"
5857     fi
5858     if test -f /etc/ld.so.conf; then
5859       $echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
5860     fi
5861     $echo
5862     $echo "See any operating system documentation about shared libraries for"
5863     $echo "more information, such as the ld(1) and ld.so(8) manual pages."
5864     $echo "----------------------------------------------------------------------"
5865     exit $EXIT_SUCCESS
5866     ;;
5867
5868   # libtool execute mode
5869   execute)
5870     modename="$modename: execute"
5871
5872     # The first argument is the command name.
5873     cmd="$nonopt"
5874     if test -z "$cmd"; then
5875       $echo "$modename: you must specify a COMMAND" 1>&2
5876       $echo "$help"
5877       exit $EXIT_FAILURE
5878     fi
5879
5880     # Handle -dlopen flags immediately.
5881     for file in $execute_dlfiles; do
5882       if test ! -f "$file"; then
5883         $echo "$modename: \`$file' is not a file" 1>&2
5884         $echo "$help" 1>&2
5885         exit $EXIT_FAILURE
5886       fi
5887
5888       dir=
5889       case $file in
5890       *.la)
5891         # Check to see that this really is a libtool archive.
5892         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5893         else
5894           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5895           $echo "$help" 1>&2
5896           exit $EXIT_FAILURE
5897         fi
5898
5899         # Read the libtool library.
5900         dlname=
5901         library_names=
5902
5903         # If there is no directory component, then add one.
5904         case $file in
5905         */* | *\\*) . $file ;;
5906         *) . ./$file ;;
5907         esac
5908
5909         # Skip this library if it cannot be dlopened.
5910         if test -z "$dlname"; then
5911           # Warn if it was a shared library.
5912           test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
5913           continue
5914         fi
5915
5916         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5917         test "X$dir" = "X$file" && dir=.
5918
5919         if test -f "$dir/$objdir/$dlname"; then
5920           dir="$dir/$objdir"
5921         else
5922           $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
5923           exit $EXIT_FAILURE
5924         fi
5925         ;;
5926
5927       *.lo)
5928         # Just add the directory containing the .lo file.
5929         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5930         test "X$dir" = "X$file" && dir=.
5931         ;;
5932
5933       *)
5934         $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
5935         continue
5936         ;;
5937       esac
5938
5939       # Get the absolute pathname.
5940       absdir=`cd "$dir" && pwd`
5941       test -n "$absdir" && dir="$absdir"
5942
5943       # Now add the directory to shlibpath_var.
5944       if eval "test -z \"\$$shlibpath_var\""; then
5945         eval "$shlibpath_var=\"\$dir\""
5946       else
5947         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
5948       fi
5949     done
5950
5951     # This variable tells wrapper scripts just to set shlibpath_var
5952     # rather than running their programs.
5953     libtool_execute_magic="$magic"
5954
5955     # Check if any of the arguments is a wrapper script.
5956     args=
5957     for file
5958     do
5959       case $file in
5960       -*) ;;
5961       *)
5962         # Do a test to see if this is really a libtool program.
5963         if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5964           # If there is no directory component, then add one.
5965           case $file in
5966           */* | *\\*) . $file ;;
5967           *) . ./$file ;;
5968           esac
5969
5970           # Transform arg to wrapped name.
5971           file="$progdir/$program"
5972         fi
5973         ;;
5974       esac
5975       # Quote arguments (to preserve shell metacharacters).
5976       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
5977       args="$args \"$file\""
5978     done
5979
5980     if test -z "$run"; then
5981       if test -n "$shlibpath_var"; then
5982         # Export the shlibpath_var.
5983         eval "export $shlibpath_var"
5984       fi
5985
5986       # Restore saved environment variables
5987       if test "${save_LC_ALL+set}" = set; then
5988         LC_ALL="$save_LC_ALL"; export LC_ALL
5989       fi
5990       if test "${save_LANG+set}" = set; then
5991         LANG="$save_LANG"; export LANG
5992       fi
5993
5994       # Now prepare to actually exec the command.
5995       exec_cmd="\$cmd$args"
5996     else
5997       # Display what would be done.
5998       if test -n "$shlibpath_var"; then
5999         eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
6000         $echo "export $shlibpath_var"
6001       fi
6002       $echo "$cmd$args"
6003       exit $EXIT_SUCCESS
6004     fi
6005     ;;
6006
6007   # libtool clean and uninstall mode
6008   clean | uninstall)
6009     modename="$modename: $mode"
6010     rm="$nonopt"
6011     files=
6012     rmforce=
6013     exit_status=0
6014
6015     # This variable tells wrapper scripts just to set variables rather
6016     # than running their programs.
6017     libtool_install_magic="$magic"
6018
6019     for arg
6020     do
6021       case $arg in
6022       -f) rm="$rm $arg"; rmforce=yes ;;
6023       -*) rm="$rm $arg" ;;
6024       *) files="$files $arg" ;;
6025       esac
6026     done
6027
6028     if test -z "$rm"; then
6029       $echo "$modename: you must specify an RM program" 1>&2
6030       $echo "$help" 1>&2
6031       exit $EXIT_FAILURE
6032     fi
6033
6034     rmdirs=
6035
6036     origobjdir="$objdir"
6037     for file in $files; do
6038       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6039       if test "X$dir" = "X$file"; then
6040         dir=.
6041         objdir="$origobjdir"
6042       else
6043         objdir="$dir/$origobjdir"
6044       fi
6045       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6046       test "$mode" = uninstall && objdir="$dir"
6047
6048       # Remember objdir for removal later, being careful to avoid duplicates
6049       if test "$mode" = clean; then
6050         case " $rmdirs " in
6051           *" $objdir "*) ;;
6052           *) rmdirs="$rmdirs $objdir" ;;
6053         esac
6054       fi
6055
6056       # Don't error if the file doesn't exist and rm -f was used.
6057       if (test -L "$file") >/dev/null 2>&1 \
6058         || (test -h "$file") >/dev/null 2>&1 \
6059         || test -f "$file"; then
6060         :
6061       elif test -d "$file"; then
6062         exit_status=1
6063         continue
6064       elif test "$rmforce" = yes; then
6065         continue
6066       fi
6067
6068       rmfiles="$file"
6069
6070       case $name in
6071       *.la)
6072         # Possibly a libtool archive, so verify it.
6073         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6074           . $dir/$name
6075
6076           # Delete the libtool libraries and symlinks.
6077           for n in $library_names; do
6078             rmfiles="$rmfiles $objdir/$n"
6079           done
6080           test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
6081           test "$mode" = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
6082
6083           if test "$mode" = uninstall; then
6084             if test -n "$library_names"; then
6085               # Do each command in the postuninstall commands.
6086               cmds=$postuninstall_cmds
6087               save_ifs="$IFS"; IFS='~'
6088               for cmd in $cmds; do
6089                 IFS="$save_ifs"
6090                 eval cmd=\"$cmd\"
6091                 $show "$cmd"
6092                 $run eval "$cmd"
6093                 if test "$?" -ne 0 && test "$rmforce" != yes; then
6094                   exit_status=1
6095                 fi
6096               done
6097               IFS="$save_ifs"
6098             fi
6099
6100             if test -n "$old_library"; then
6101               # Do each command in the old_postuninstall commands.
6102               cmds=$old_postuninstall_cmds
6103               save_ifs="$IFS"; IFS='~'
6104               for cmd in $cmds; do
6105                 IFS="$save_ifs"
6106                 eval cmd=\"$cmd\"
6107                 $show "$cmd"
6108                 $run eval "$cmd"
6109                 if test "$?" -ne 0 && test "$rmforce" != yes; then
6110                   exit_status=1
6111                 fi
6112               done
6113               IFS="$save_ifs"
6114             fi
6115             # FIXME: should reinstall the best remaining shared library.
6116           fi
6117         fi
6118         ;;
6119
6120       *.lo)
6121         # Possibly a libtool object, so verify it.
6122         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6123
6124           # Read the .lo file
6125           . $dir/$name
6126
6127           # Add PIC object to the list of files to remove.
6128           if test -n "$pic_object" \
6129              && test "$pic_object" != none; then
6130             rmfiles="$rmfiles $dir/$pic_object"
6131           fi
6132
6133           # Add non-PIC object to the list of files to remove.
6134           if test -n "$non_pic_object" \
6135              && test "$non_pic_object" != none; then
6136             rmfiles="$rmfiles $dir/$non_pic_object"
6137           fi
6138         fi
6139         ;;
6140
6141       *)
6142         if test "$mode" = clean ; then
6143           noexename=$name
6144           case $file in
6145           *.exe)
6146             file=`$echo $file|${SED} 's,.exe$,,'`
6147             noexename=`$echo $name|${SED} 's,.exe$,,'`
6148             # $file with .exe has already been added to rmfiles,
6149             # add $file without .exe
6150             rmfiles="$rmfiles $file"
6151             ;;
6152           esac
6153           # Do a test to see if this is a libtool program.
6154           if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6155             relink_command=
6156             . $dir/$noexename
6157
6158             # note $name still contains .exe if it was in $file originally
6159             # as does the version of $file that was added into $rmfiles
6160             rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
6161             if test "$fast_install" = yes && test -n "$relink_command"; then
6162               rmfiles="$rmfiles $objdir/lt-$name"
6163             fi
6164             if test "X$noexename" != "X$name" ; then
6165               rmfiles="$rmfiles $objdir/lt-${noexename}.c"
6166             fi
6167           fi
6168         fi
6169         ;;
6170       esac
6171       $show "$rm $rmfiles"
6172       $run $rm $rmfiles || exit_status=1
6173     done
6174     objdir="$origobjdir"
6175
6176     # Try to remove the ${objdir}s in the directories where we deleted files
6177     for dir in $rmdirs; do
6178       if test -d "$dir"; then
6179         $show "rmdir $dir"
6180         $run rmdir $dir >/dev/null 2>&1
6181       fi
6182     done
6183
6184     exit $exit_status
6185     ;;
6186
6187   "")
6188     $echo "$modename: you must specify a MODE" 1>&2
6189     $echo "$generic_help" 1>&2
6190     exit $EXIT_FAILURE
6191     ;;
6192   esac
6193
6194   if test -z "$exec_cmd"; then
6195     $echo "$modename: invalid operation mode \`$mode'" 1>&2
6196     $echo "$generic_help" 1>&2
6197     exit $EXIT_FAILURE
6198   fi
6199 fi # test -z "$show_help"
6200
6201 if test -n "$exec_cmd"; then
6202   eval exec $exec_cmd
6203   exit $EXIT_FAILURE
6204 fi
6205
6206 # We need to display help for each of the modes.
6207 case $mode in
6208 "") $echo \
6209 "Usage: $modename [OPTION]... [MODE-ARG]...
6210
6211 Provide generalized library-building support services.
6212
6213     --config          show all configuration variables
6214     --debug           enable verbose shell tracing
6215 -n, --dry-run         display commands without modifying any files
6216     --features        display basic configuration information and exit
6217     --finish          same as \`--mode=finish'
6218     --help            display this help message and exit
6219     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
6220     --quiet           same as \`--silent'
6221     --silent          don't print informational messages
6222     --tag=TAG         use configuration variables from tag TAG
6223     --version         print version information
6224
6225 MODE must be one of the following:
6226
6227       clean           remove files from the build directory
6228       compile         compile a source file into a libtool object
6229       execute         automatically set library path, then run a program
6230       finish          complete the installation of libtool libraries
6231       install         install libraries or executables
6232       link            create a library or an executable
6233       uninstall       remove libraries from an installed directory
6234
6235 MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
6236 a more detailed description of MODE.
6237
6238 Report bugs to <bug-libtool@gnu.org>."
6239   exit $EXIT_SUCCESS
6240   ;;
6241
6242 clean)
6243   $echo \
6244 "Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
6245
6246 Remove files from the build directory.
6247
6248 RM is the name of the program to use to delete files associated with each FILE
6249 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6250 to RM.
6251
6252 If FILE is a libtool library, object or program, all the files associated
6253 with it are deleted. Otherwise, only FILE itself is deleted using RM."
6254   ;;
6255
6256 compile)
6257   $echo \
6258 "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
6259
6260 Compile a source file into a libtool library object.
6261
6262 This mode accepts the following additional options:
6263
6264   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
6265   -prefer-pic       try to building PIC objects only
6266   -prefer-non-pic   try to building non-PIC objects only
6267   -static           always build a \`.o' file suitable for static linking
6268
6269 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
6270 from the given SOURCEFILE.
6271
6272 The output file name is determined by removing the directory component from
6273 SOURCEFILE, then substituting the C source code suffix \`.c' with the
6274 library object suffix, \`.lo'."
6275   ;;
6276
6277 execute)
6278   $echo \
6279 "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
6280
6281 Automatically set library path, then run a program.
6282
6283 This mode accepts the following additional options:
6284
6285   -dlopen FILE      add the directory containing FILE to the library path
6286
6287 This mode sets the library path environment variable according to \`-dlopen'
6288 flags.
6289
6290 If any of the ARGS are libtool executable wrappers, then they are translated
6291 into their corresponding uninstalled binary, and any of their required library
6292 directories are added to the library path.
6293
6294 Then, COMMAND is executed, with ARGS as arguments."
6295   ;;
6296
6297 finish)
6298   $echo \
6299 "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
6300
6301 Complete the installation of libtool libraries.
6302
6303 Each LIBDIR is a directory that contains libtool libraries.
6304
6305 The commands that this mode executes may require superuser privileges.  Use
6306 the \`--dry-run' option if you just want to see what would be executed."
6307   ;;
6308
6309 install)
6310   $echo \
6311 "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
6312
6313 Install executables or libraries.
6314
6315 INSTALL-COMMAND is the installation command.  The first component should be
6316 either the \`install' or \`cp' program.
6317
6318 The rest of the components are interpreted as arguments to that command (only
6319 BSD-compatible install options are recognized)."
6320   ;;
6321
6322 link)
6323   $echo \
6324 "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
6325
6326 Link object files or libraries together to form another library, or to
6327 create an executable program.
6328
6329 LINK-COMMAND is a command using the C compiler that you would use to create
6330 a program from several object files.
6331
6332 The following components of LINK-COMMAND are treated specially:
6333
6334   -all-static       do not do any dynamic linking at all
6335   -avoid-version    do not add a version suffix if possible
6336   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
6337   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
6338   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
6339   -export-symbols SYMFILE
6340                     try to export only the symbols listed in SYMFILE
6341   -export-symbols-regex REGEX
6342                     try to export only the symbols matching REGEX
6343   -LLIBDIR          search LIBDIR for required installed libraries
6344   -lNAME            OUTPUT-FILE requires the installed library libNAME
6345   -module           build a library that can dlopened
6346   -no-fast-install  disable the fast-install mode
6347   -no-install       link a not-installable executable
6348   -no-undefined     declare that a library does not refer to external symbols
6349   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
6350   -objectlist FILE  Use a list of object files found in FILE to specify objects
6351   -precious-files-regex REGEX
6352                     don't remove output files matching REGEX
6353   -release RELEASE  specify package release information
6354   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
6355   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
6356   -static           do not do any dynamic linking of libtool libraries
6357   -version-info CURRENT[:REVISION[:AGE]]
6358                     specify library version info [each variable defaults to 0]
6359
6360 All other options (arguments beginning with \`-') are ignored.
6361
6362 Every other argument is treated as a filename.  Files ending in \`.la' are
6363 treated as uninstalled libtool libraries, other files are standard or library
6364 object files.
6365
6366 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
6367 only library objects (\`.lo' files) may be specified, and \`-rpath' is
6368 required, except when creating a convenience library.
6369
6370 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
6371 using \`ar' and \`ranlib', or on Windows using \`lib'.
6372
6373 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
6374 is created, otherwise an executable program is created."
6375   ;;
6376
6377 uninstall)
6378   $echo \
6379 "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
6380
6381 Remove libraries from an installation directory.
6382
6383 RM is the name of the program to use to delete files associated with each FILE
6384 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6385 to RM.
6386
6387 If FILE is a libtool library, all the files associated with it are deleted.
6388 Otherwise, only FILE itself is deleted using RM."
6389   ;;
6390
6391 *)
6392   $echo "$modename: invalid operation mode \`$mode'" 1>&2
6393   $echo "$help" 1>&2
6394   exit $EXIT_FAILURE
6395   ;;
6396 esac
6397
6398 $echo
6399 $echo "Try \`$modename --help' for more information about other modes."
6400
6401 exit $EXIT_SUCCESS
6402
6403 # The TAGs below are defined such that we never get into a situation
6404 # in which we disable both kinds of libraries.  Given conflicting
6405 # choices, we go for a static library, that is the most portable,
6406 # since we can't tell whether shared libraries were disabled because
6407 # the user asked for that or because the platform doesn't support
6408 # them.  This is particularly important on AIX, because we don't
6409 # support having both static and shared libraries enabled at the same
6410 # time on that platform, so we default to a shared-only configuration.
6411 # If a disable-shared tag is given, we'll fallback to a static-only
6412 # configuration.  But we'll never go from static-only to shared-only.
6413
6414 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
6415 build_libtool_libs=no
6416 build_old_libs=yes
6417 # ### END LIBTOOL TAG CONFIG: disable-shared
6418
6419 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
6420 build_old_libs=`case $build_libtool_libs in yes) $echo no;; *) $echo yes;; esac`
6421 # ### END LIBTOOL TAG CONFIG: disable-static
6422
6423 # Local Variables:
6424 # mode:shell-script
6425 # sh-indentation:2
6426 # End: