ltmain.sh 176 KB
Newer Older
unknown's avatar
unknown committed
1
# ltmain.sh - Provide generalized library-building support services.
2
# NOTE: Changing this file will not affect anything until you rerun configure.
unknown's avatar
unknown committed
3
#
4
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003
5
# Free Software Foundation, Inc.
unknown's avatar
unknown committed
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.

# Check that we have a working $echo.
if test "X$1" = X--no-reexec; then
  # Discard the --no-reexec flag, and continue.
  shift
elif test "X$1" = X--fallback-echo; then
  # Avoid inline document here, it may be left over
  :
elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
  # Yippee, $echo works!
  :
else
  # Restart under the correct shell, and then maybe $echo will work.
  exec $SHELL "$0" --no-reexec ${1+"$@"}
fi

if test "X$1" = X--fallback-echo; then
  # used as fallback echo
  shift
  cat <<EOF
$*
EOF
  exit 0
fi

51 52 53
# libtool 1.4.2 workaround
SED=${SED:-sed}

54 55 56
# workaround against unset 'max_cmd_len': assume at least 4 kB
max_cmd_len=${max_cmd_len:-4096}

unknown's avatar
unknown committed
57
# The name of this program.
58
progname=`$echo "$0" | ${SED} 's%^.*/%%'`
unknown's avatar
unknown committed
59 60 61 62 63
modename="$progname"

# Constants.
PROGRAM=ltmain.sh
PACKAGE=libtool
64 65
VERSION=1.5
TIMESTAMP=" (1.1220.2.1 2003/04/14 22:48:00)"
unknown's avatar
unknown committed
66 67 68 69 70 71 72 73 74 75

default_mode=
help="Try \`$progname --help' for more information."
magic="%%%MAGIC variable%%%"
mkdir="mkdir"
mv="mv -f"
rm="rm -f"

# Sed substitution that helps us do robust quoting.  It backslashifies
# metacharacters that are still active within double-quoted strings.
76
Xsed="${SED}"' -e 1s/^X//'
unknown's avatar
unknown committed
77
sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
78 79 80 81 82 83 84 85 86 87 88
# test EBCDIC or ASCII
case `echo A|od -x` in
 *[Cc]1*) # EBCDIC based system
  SP2NL="tr '\100' '\n'"
  NL2SP="tr '\r\n' '\100\100'"
  ;;
 *) # Assume ASCII based system
  SP2NL="tr '\040' '\012'"
  NL2SP="tr '\015\012' '\040\040'"
  ;;
esac
unknown's avatar
unknown committed
89 90 91 92 93 94 95 96 97 98 99 100 101

# NLS nuisances.
# Only set LANG and LC_ALL to C if already set.
# These must not be set unconditionally because not all systems understand
# e.g. LANG=C (notably SCO).
# We save the old values to restore during execute mode.
if test "${LC_ALL+set}" = set; then
  save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
fi
if test "${LANG+set}" = set; then
  save_LANG="$LANG"; LANG=C; export LANG
fi

102 103
# Make sure IFS has a sensible default
: ${IFS=" 	"}
unknown's avatar
unknown committed
104 105

if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
106 107
  $echo "$modename: not configured to build any kind of library" 1>&2
  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
unknown's avatar
unknown committed
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
  exit 1
fi

# Global variables.
mode=$default_mode
nonopt=
prev=
prevopt=
run=
show="$echo"
show_help=
execute_dlfiles=
lo2o="s/\\.lo\$/.${objext}/"
o2lo="s/\\.${objext}\$/.lo/"

123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
#####################################
# Shell function definitions:
# This seems to be the best place for them

# Need a lot of goo to handle *both* DLLs and import libs
# Has to be a shell function in order to 'eat' the argument
# that is supplied when $file_magic_command is called.
win32_libid () {
  win32_libid_type="unknown"
  win32_fileres=`file -L $1 2>/dev/null`
  case $win32_fileres in
  *ar\ archive\ import\ library*) # definitely import
    win32_libid_type="x86 archive import"
    ;;
  *ar\ archive*) # could be an import, or static
    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
      grep -E 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
      win32_nmres=`eval $NM -f posix -A $1 | \
unknown's avatar
unknown committed
141
	$SED -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
      if test "X$win32_nmres" = "Ximport" ; then
        win32_libid_type="x86 archive import"
      else
        win32_libid_type="x86 archive static"
      fi
    fi
    ;;
  *DLL*) 
    win32_libid_type="x86 DLL"
    ;;
  *executable*) # but shell scripts are "executable" too...
    case $win32_fileres in
    *MS\ Windows\ PE\ Intel*)
      win32_libid_type="x86 DLL"
      ;;
    esac
    ;;
  esac
  $echo $win32_libid_type
}

# End of Shell function definitions
#####################################

unknown's avatar
unknown committed
166
# Parse our command line options once, thoroughly.
167
while test "$#" -gt 0
unknown's avatar
unknown committed
168 169 170 171
do
  arg="$1"
  shift

172
  case $arg in
unknown's avatar
unknown committed
173 174 175 176 177 178
  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
  *) optarg= ;;
  esac

  # If the previous option needs an argument, assign it.
  if test -n "$prev"; then
179
    case $prev in
unknown's avatar
unknown committed
180
    execute_dlfiles)
181
      execute_dlfiles="$execute_dlfiles $arg"
unknown's avatar
unknown committed
182
      ;;
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
    tag)
      tagname="$arg"

      # Check whether tagname contains only valid characters
      case $tagname in
      *[!-_A-Za-z0-9,/]*)
	$echo "$progname: invalid tag name: $tagname" 1>&2
	exit 1
	;;
      esac

      case $tagname in
      CC)
	# Don't test for the "default" C tag, as we know, it's there, but
	# not specially marked.
	;;
      *)
	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$0" > /dev/null; then
	  taglist="$taglist $tagname"
	  # Evaluate the configuration.
	  eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $0`"
	else
	  $echo "$progname: ignoring unknown tag $tagname" 1>&2
	fi
	;;
      esac
      ;;
unknown's avatar
unknown committed
210 211 212 213 214 215 216 217 218 219 220
    *)
      eval "$prev=\$arg"
      ;;
    esac

    prev=
    prevopt=
    continue
  fi

  # Have we seen a non-optional argument yet?
221
  case $arg in
unknown's avatar
unknown committed
222 223 224 225 226
  --help)
    show_help=yes
    ;;

  --version)
227 228 229 230 231
    $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
    $echo
    $echo "Copyright (C) 2003  Free Software Foundation, Inc."
    $echo "This is free software; see the source for copying conditions.  There is NO"
    $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
unknown's avatar
unknown committed
232 233 234 235
    exit 0
    ;;

  --config)
236 237 238 239 240
    ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $0
    # Now print the configurations for the tags.
    for tagname in $taglist; do
      ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$0"
    done
unknown's avatar
unknown committed
241 242 243 244
    exit 0
    ;;

  --debug)
245
    $echo "$progname: enabling shell trace mode"
unknown's avatar
unknown committed
246 247 248 249 250 251 252 253
    set -x
    ;;

  --dry-run | -n)
    run=:
    ;;

  --features)
254
    $echo "host: $host"
unknown's avatar
unknown committed
255
    if test "$build_libtool_libs" = yes; then
256
      $echo "enable shared libraries"
unknown's avatar
unknown committed
257
    else
258
      $echo "disable shared libraries"
unknown's avatar
unknown committed
259 260
    fi
    if test "$build_old_libs" = yes; then
261
      $echo "enable static libraries"
unknown's avatar
unknown committed
262
    else
263
      $echo "disable static libraries"
unknown's avatar
unknown committed
264 265 266 267 268 269 270 271 272
    fi
    exit 0
    ;;

  --finish) mode="finish" ;;

  --mode) prevopt="--mode" prev=mode ;;
  --mode=*) mode="$optarg" ;;

273 274
  --preserve-dup-deps) duplicate_deps="yes" ;;

unknown's avatar
unknown committed
275 276 277 278
  --quiet | --silent)
    show=:
    ;;

279 280 281 282 283 284 285
  --tag) prevopt="--tag" prev=tag ;;
  --tag=*)
    set tag "$optarg" ${1+"$@"}
    shift
    prev=tag
    ;;

unknown's avatar
unknown committed
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
  -dlopen)
    prevopt="-dlopen"
    prev=execute_dlfiles
    ;;

  -*)
    $echo "$modename: unrecognized option \`$arg'" 1>&2
    $echo "$help" 1>&2
    exit 1
    ;;

  *)
    nonopt="$arg"
    break
    ;;
  esac
done

if test -n "$prevopt"; then
  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
  $echo "$help" 1>&2
  exit 1
fi

310 311 312 313 314
# If this variable is set in any of the actions, the command in it
# will be execed at the end.  This prevents here-documents from being
# left over by shells.
exec_cmd=

unknown's avatar
unknown committed
315 316 317 318
if test -z "$show_help"; then

  # Infer the operation mode.
  if test -z "$mode"; then
319 320
    $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
    $echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2
321
    case $nonopt in
322
    *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
unknown's avatar
unknown committed
323 324 325
      mode=link
      for arg
      do
326
	case $arg in
unknown's avatar
unknown committed
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
	-c)
	   mode=compile
	   break
	   ;;
	esac
      done
      ;;
    *db | *dbx | *strace | *truss)
      mode=execute
      ;;
    *install*|cp|mv)
      mode=install
      ;;
    *rm)
      mode=uninstall
      ;;
    *)
      # If we have no mode, but dlfiles were specified, then do execute mode.
      test -n "$execute_dlfiles" && mode=execute

      # Just use the default operation mode.
      if test -z "$mode"; then
	if test -n "$nonopt"; then
	  $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
	else
	  $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
	fi
      fi
      ;;
    esac
  fi

  # Only execute mode is allowed to have -dlopen flags.
  if test -n "$execute_dlfiles" && test "$mode" != execute; then
    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
    $echo "$help" 1>&2
    exit 1
  fi

  # Change the help message to a mode-specific one.
  generic_help="$help"
  help="Try \`$modename --help --mode=$mode' for more information."

  # These modes are in order of execution frequency so that they run quickly.
371
  case $mode in
unknown's avatar
unknown committed
372 373 374 375 376
  # libtool compile mode
  compile)
    modename="$modename: compile"
    # Get the compilation command and the source file.
    base_compile=
377
    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
unknown's avatar
unknown committed
378
    suppress_output=
379 380
    arg_mode=normal
    libobj=
unknown's avatar
unknown committed
381 382 383

    for arg
    do
384 385 386 387 388 389
      case "$arg_mode" in
      arg  )
	# do not "continue".  Instead, add this to base_compile
	lastarg="$arg"
	arg_mode=normal
	;;
390

391 392 393
      target )
	libobj="$arg"
	arg_mode=normal
394 395 396
	continue
	;;

397 398 399 400 401 402 403 404 405 406 407
      normal )
	# Accept any command-line options.
	case $arg in
	-o)
	  if test -n "$libobj" ; then
	    $echo "$modename: you cannot specify \`-o' more than once" 1>&2
	    exit 1
	  fi
	  arg_mode=target
	  continue
	  ;;
unknown's avatar
unknown committed
408

409 410 411 412
	-static)
	  build_old_libs=yes
	  continue
	  ;;
413

414 415 416 417
	-prefer-pic)
	  pic_mode=yes
	  continue
	  ;;
418

419 420 421 422
	-prefer-non-pic)
	  pic_mode=no
	  continue
	  ;;
423

424 425 426 427
	-Xcompiler)
	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
	  continue      #  The current "srcfile" will either be retained or
	  ;;            #  replaced later.  I would guess that would be a bug.
428

429 430 431 432 433 434
	-Wc,*)
	  args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
	  lastarg=
	  save_ifs="$IFS"; IFS=','
	  for arg in $args; do
	    IFS="$save_ifs"
435

436 437 438 439 440 441 442 443 444 445 446 447
	    # Double-quote args containing other shell metacharacters.
	    # Many Bourne shells cannot handle close brackets correctly
	    # in scan sets, so we specify it separately.
	    case $arg in
	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
	      arg="\"$arg\""
	      ;;
	    esac
	    lastarg="$lastarg $arg"
	  done
	  IFS="$save_ifs"
	  lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
448

449
	  # Add the arguments to base_compile.
450
	  base_compile="$base_compile $lastarg"
451 452
	  continue
	  ;;
unknown's avatar
unknown committed
453

454 455 456 457 458 459 460 461
	* )
	  # Accept the current argument as the source file.
	  # The previous "srcfile" becomes the current argument.
	  #
	  lastarg="$srcfile"
	  srcfile="$arg"
	  ;;
	esac  #  case $arg
unknown's avatar
unknown committed
462
	;;
463
      esac    #  case $arg_mode
unknown's avatar
unknown committed
464 465 466 467

      # Aesthetically quote the previous argument.
      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`

468
      case $lastarg in
unknown's avatar
unknown committed
469
      # Double-quote args containing other shell metacharacters.
470 471 472
      # Many Bourne shells cannot handle close brackets correctly
      # in scan sets, so we specify it separately.
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
unknown's avatar
unknown committed
473 474 475 476
	lastarg="\"$lastarg\""
	;;
      esac

477 478
      base_compile="$base_compile $lastarg"
    done # for arg
unknown's avatar
unknown committed
479

480 481 482 483
    case $arg_mode in
    arg)
      $echo "$modename: you must specify an argument for -Xcompile"
      exit 1
unknown's avatar
unknown committed
484
      ;;
485
    target)
unknown's avatar
unknown committed
486 487 488
      $echo "$modename: you must specify a target with \`-o'" 1>&2
      exit 1
      ;;
489 490 491 492
    *)
      # Get the name of the library object.
      [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
      ;;
unknown's avatar
unknown committed
493 494 495 496
    esac

    # Recognize several different file suffixes.
    # If the user specifies -o file.o, it is replaced with file.lo
497
    xform='[cCFSifmso]'
498
    case $libobj in
unknown's avatar
unknown committed
499 500 501 502 503 504
    *.ada) xform=ada ;;
    *.adb) xform=adb ;;
    *.ads) xform=ads ;;
    *.asm) xform=asm ;;
    *.c++) xform=c++ ;;
    *.cc) xform=cc ;;
505 506
    *.ii) xform=ii ;;
    *.class) xform=class ;;
unknown's avatar
unknown committed
507 508 509 510
    *.cpp) xform=cpp ;;
    *.cxx) xform=cxx ;;
    *.f90) xform=f90 ;;
    *.for) xform=for ;;
511
    *.java) xform=java ;;
unknown's avatar
unknown committed
512 513 514 515
    esac

    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`

516
    case $libobj in
unknown's avatar
unknown committed
517 518 519 520 521 522 523
    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
    *)
      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
      exit 1
      ;;
    esac

524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
    # Infer tagged configuration to use if any are available and
    # if one wasn't chosen via the "--tag" command line option.
    # Only attempt this if the compiler in the base compile
    # command doesn't match the default compiler.
    if test -n "$available_tags" && test -z "$tagname"; then
      case $base_compile in
      # Blanks in the command may have been stripped by the calling shell,
      # but not from the CC environment variable when configure was run.
      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "*) ;;
      # Blanks at the start of $base_compile will cause this to fail
      # if we don't check for them as well.
      *)
	for z in $available_tags; do
	  if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
	    # Evaluate the configuration.
	    eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
	    case "$base_compile " in
	    "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*)
	      # The compiler in the base compile command matches
	      # the one in the tagged configuration.
	      # Assume this is the tagged configuration we want.
	      tagname=$z
	      break
	      ;;
	    esac
	  fi
	done
	# If $tagname still isn't set, then no tagged configuration
	# was found and let the user know that the "--tag" command
	# line option must be used.
	if test -z "$tagname"; then
	  $echo "$modename: unable to infer tagged configuration"
	  $echo "$modename: specify a tag with \`--tag'" 1>&2
	  exit 1
#        else
#          $echo "$modename: using $tagname tagged configuration"
	fi
	;;
      esac
    fi

    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
    if test "X$xdir" = "X$obj"; then
      xdir=
    else
      xdir=$xdir/
    fi
    lobj=${xdir}$objdir/$objname

unknown's avatar
unknown committed
574 575 576 577 578 579 580 581
    if test -z "$base_compile"; then
      $echo "$modename: you must specify a compilation command" 1>&2
      $echo "$help" 1>&2
      exit 1
    fi

    # Delete any leftover library objects.
    if test "$build_old_libs" = yes; then
582
      removelist="$obj $lobj $libobj ${libobj}T"
unknown's avatar
unknown committed
583
    else
584
      removelist="$lobj $libobj ${libobj}T"
unknown's avatar
unknown committed
585 586 587 588 589
    fi

    $run $rm $removelist
    trap "$run $rm $removelist; exit 1" 1 2 15

590 591 592 593 594 595
    # On Cygwin there's no "real" PIC flag so we must build both object types
    case $host_os in
    cygwin* | mingw* | pw32* | os2*)
      pic_mode=default
      ;;
    esac
596
    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
597 598 599 600
      # non-PIC code in shared libraries is not supported
      pic_mode=default
    fi

unknown's avatar
unknown committed
601 602 603
    # Calculate the filename of the output object if compiler does
    # not support -o with -c
    if test "$compiler_c_o" = no; then
604
      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
unknown's avatar
unknown committed
605 606 607 608
      lockfile="$output_obj.lock"
      removelist="$removelist $output_obj $lockfile"
      trap "$run $rm $removelist; exit 1" 1 2 15
    else
609
      output_obj=
unknown's avatar
unknown committed
610 611 612 613 614 615 616
      need_locks=no
      lockfile=
    fi

    # Lock this critical section if it is needed
    # We use this script file to make the link, it avoids creating a new file
    if test "$need_locks" = yes; then
617
      until $run ln "$0" "$lockfile" 2>/dev/null; do
unknown's avatar
unknown committed
618 619 620 621 622
	$show "Waiting for $lockfile to be removed"
	sleep 2
      done
    elif test "$need_locks" = warn; then
      if test -f "$lockfile"; then
623
	$echo "\
unknown's avatar
unknown committed
624 625 626 627 628 629 630 631 632 633 634 635 636
*** ERROR, $lockfile exists and contains:
`cat $lockfile 2>/dev/null`

This indicates that another process is trying to use the same
temporary object file, and libtool could not work around it because
your compiler does not support \`-c' and \`-o' together.  If you
repeat this compilation, it may succeed, by chance, but you had better
avoid parallel builds (make -j) in this platform, or get a better
compiler."

	$run $rm $removelist
	exit 1
      fi
637
      $echo $srcfile > "$lockfile"
unknown's avatar
unknown committed
638 639 640 641 642 643
    fi

    if test -n "$fix_srcfile_path"; then
      eval srcfile=\"$fix_srcfile_path\"
    fi

644 645 646 647 648 649 650 651 652 653 654 655 656 657
    $run $rm "$libobj" "${libobj}T"

    # Create a libtool object file (analogous to a ".la" file),
    # but don't create it if we're doing a dry run.
    test -z "$run" && cat > ${libobj}T <<EOF
# $libobj - a libtool object file
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
#
# Please DO NOT delete this file!
# It is necessary for linking the library.

# Name of the PIC object.
EOF

unknown's avatar
unknown committed
658 659 660 661 662
    # Only build a PIC object if we are building libtool libraries.
    if test "$build_libtool_libs" = yes; then
      # Without this assignment, base_compile gets emptied.
      fbsd_hideous_sh_bug=$base_compile

663
      if test "$pic_mode" != no; then
664
	command="$base_compile $srcfile $pic_flag"
665 666 667 668
      else
	# Don't build PIC code
	command="$base_compile $srcfile"
      fi
unknown's avatar
unknown committed
669

670 671 672 673 674 675
      if test ! -d "${xdir}$objdir"; then
	$show "$mkdir ${xdir}$objdir"
	$run $mkdir ${xdir}$objdir
	status=$?
	if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then
	  exit $status
unknown's avatar
unknown committed
676 677
	fi
      fi
678 679 680 681

      if test -z "$output_obj"; then
	# Place PIC objects in $objdir
	command="$command -o $lobj"
unknown's avatar
unknown committed
682 683
      fi

684 685
      $run $rm "$lobj" "$output_obj"

unknown's avatar
unknown committed
686 687 688 689 690 691 692 693
      $show "$command"
      if $run eval "$command"; then :
      else
	test -n "$output_obj" && $run $rm $removelist
	exit 1
      fi

      if test "$need_locks" = warn &&
694 695
	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
	$echo "\
unknown's avatar
unknown committed
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713
*** ERROR, $lockfile contains:
`cat $lockfile 2>/dev/null`

but it should contain:
$srcfile

This indicates that another process is trying to use the same
temporary object file, and libtool could not work around it because
your compiler does not support \`-c' and \`-o' together.  If you
repeat this compilation, it may succeed, by chance, but you had better
avoid parallel builds (make -j) in this platform, or get a better
compiler."

	$run $rm $removelist
	exit 1
      fi

      # Just move the object if needed, then go on to compile the next one
714 715 716
      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
	$show "$mv $output_obj $lobj"
	if $run $mv $output_obj $lobj; then :
unknown's avatar
unknown committed
717 718 719 720 721 722 723
	else
	  error=$?
	  $run $rm $removelist
	  exit $error
	fi
      fi

724 725 726
      # Append the name of the PIC object to the libtool object file.
      test -z "$run" && cat >> ${libobj}T <<EOF
pic_object='$objdir/$objname'
unknown's avatar
unknown committed
727

728
EOF
unknown's avatar
unknown committed
729 730 731

      # Allow error messages only from the first compilation.
      suppress_output=' >/dev/null 2>&1'
732 733 734 735 736 737 738
    else
      # No PIC object so indicate it doesn't exist in the libtool
      # object file.
      test -z "$run" && cat >> ${libobj}T <<EOF
pic_object=none

EOF
unknown's avatar
unknown committed
739 740 741 742
    fi

    # Only build a position-dependent object if we build old libraries.
    if test "$build_old_libs" = yes; then
743 744 745 746
      if test "$pic_mode" != yes; then
	# Don't build PIC code
	command="$base_compile $srcfile"
      else
747
	command="$base_compile $srcfile $pic_flag"
748
      fi
unknown's avatar
unknown committed
749 750 751 752 753 754
      if test "$compiler_c_o" = yes; then
	command="$command -o $obj"
      fi

      # Suppress compiler output if we already did a PIC compilation.
      command="$command$suppress_output"
755
      $run $rm "$obj" "$output_obj"
unknown's avatar
unknown committed
756 757 758 759 760 761 762 763
      $show "$command"
      if $run eval "$command"; then :
      else
	$run $rm $removelist
	exit 1
      fi

      if test "$need_locks" = warn &&
764 765
	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
	$echo "\
unknown's avatar
unknown committed
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783
*** ERROR, $lockfile contains:
`cat $lockfile 2>/dev/null`

but it should contain:
$srcfile

This indicates that another process is trying to use the same
temporary object file, and libtool could not work around it because
your compiler does not support \`-c' and \`-o' together.  If you
repeat this compilation, it may succeed, by chance, but you had better
avoid parallel builds (make -j) in this platform, or get a better
compiler."

	$run $rm $removelist
	exit 1
      fi

      # Just move the object if needed
784
      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
unknown's avatar
unknown committed
785 786 787 788 789 790 791 792 793
	$show "$mv $output_obj $obj"
	if $run $mv $output_obj $obj; then :
	else
	  error=$?
	  $run $rm $removelist
	  exit $error
	fi
      fi

794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
      # Append the name of the non-PIC object the libtool object file.
      # Only append if the libtool object file exists.
      test -z "$run" && cat >> ${libobj}T <<EOF
# Name of the non-PIC object.
non_pic_object='$objname'

EOF
    else
      # Append the name of the non-PIC object the libtool object file.
      # Only append if the libtool object file exists.
      test -z "$run" && cat >> ${libobj}T <<EOF
# Name of the non-PIC object.
non_pic_object=none

EOF
unknown's avatar
unknown committed
809 810
    fi

811 812
    $run $mv "${libobj}T" "${libobj}"

unknown's avatar
unknown committed
813 814
    # Unlock the critical section if it was locked
    if test "$need_locks" != no; then
815
      $run $rm "$lockfile"
unknown's avatar
unknown committed
816 817 818 819 820 821
    fi

    exit 0
    ;;

  # libtool link mode
822
  link | relink)
unknown's avatar
unknown committed
823
    modename="$modename: link"
824 825
    case $host in
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
unknown's avatar
unknown committed
826 827 828
      # It is impossible to link a dll without this setting, and
      # we shouldn't force the makefile maintainer to figure out
      # which system we are compiling for in order to pass an extra
829
      # flag for every libtool invocation.
unknown's avatar
unknown committed
830 831 832 833 834 835 836 837 838 839 840 841 842
      # allow_undefined=no

      # FIXME: Unfortunately, there are problems with the above when trying
      # to make a dll which has undefined symbols, in which case not
      # even a static library is built.  For now, we need to specify
      # -no-undefined on the libtool link line when we can be certain
      # that all symbols are satisfied, otherwise we get a static library.
      allow_undefined=yes
      ;;
    *)
      allow_undefined=yes
      ;;
    esac
843
    libtool_args="$nonopt"
844
    base_compile="$nonopt"
unknown's avatar
unknown committed
845 846
    compile_command="$nonopt"
    finalize_command="$nonopt"
unknown's avatar
unknown committed
847 848 849 850 851 852 853 854

    compile_rpath=
    finalize_rpath=
    compile_shlibpath=
    finalize_shlibpath=
    convenience=
    old_convenience=
    deplibs=
855 856 857 858 859
    old_deplibs=
    compiler_flags=
    linker_flags=
    dllsearchpath=
    lib_search_path=`pwd`
860
    inst_prefix_dir=
unknown's avatar
unknown committed
861 862 863 864 865 866 867 868 869 870 871 872

    avoid_version=no
    dlfiles=
    dlprefiles=
    dlself=no
    export_dynamic=no
    export_symbols=
    export_symbols_regex=
    generated=
    libobjs=
    ltlibs=
    module=no
873
    no_install=no
unknown's avatar
unknown committed
874
    objs=
875
    non_pic_objects=
unknown's avatar
unknown committed
876 877 878 879 880 881 882 883 884 885 886
    prefer_static_libs=no
    preload=no
    prev=
    prevarg=
    release=
    rpath=
    xrpath=
    perm_rpath=
    temp_rpath=
    thread_safe=no
    vinfo=
887
    vinfo_number=no
unknown's avatar
unknown committed
888 889 890 891

    # We need to know -static, to get the right output filenames.
    for arg
    do
892
      case $arg in
unknown's avatar
unknown committed
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
      -all-static | -static)
	if test "X$arg" = "X-all-static"; then
	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
	    $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
	  fi
	  if test -n "$link_static_flag"; then
	    dlopen_self=$dlopen_self_static
	  fi
	else
	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
	    dlopen_self=$dlopen_self_static
	  fi
	fi
	build_libtool_libs=no
	build_old_libs=yes
	prefer_static_libs=yes
	break
	;;
      esac
    done

    # See if our shared archives depend on static archives.
    test -n "$old_archive_from_new_cmds" && build_old_libs=yes

    # Go through the arguments, transforming them on the way.
918
    while test "$#" -gt 0; do
unknown's avatar
unknown committed
919
      arg="$1"
920
      base_compile="$base_compile $arg"
unknown's avatar
unknown committed
921
      shift
922 923 924 925 926 927 928
      case $arg in
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
	qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
	;;
      *) qarg=$arg ;;
      esac
      libtool_args="$libtool_args $qarg"
unknown's avatar
unknown committed
929 930 931

      # If the previous option needs an argument, assign it.
      if test -n "$prev"; then
932
	case $prev in
unknown's avatar
unknown committed
933 934 935 936 937 938
	output)
	  compile_command="$compile_command @OUTPUT@"
	  finalize_command="$finalize_command @OUTPUT@"
	  ;;
	esac

939
	case $prev in
unknown's avatar
unknown committed
940 941 942 943 944 945 946
	dlfiles|dlprefiles)
	  if test "$preload" = no; then
	    # Add the symbol object into the linking commands.
	    compile_command="$compile_command @SYMFILE@"
	    finalize_command="$finalize_command @SYMFILE@"
	    preload=yes
	  fi
947
	  case $arg in
unknown's avatar
unknown committed
948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975
	  *.la | *.lo) ;;  # We handle these cases below.
	  force)
	    if test "$dlself" = no; then
	      dlself=needless
	      export_dynamic=yes
	    fi
	    prev=
	    continue
	    ;;
	  self)
	    if test "$prev" = dlprefiles; then
	      dlself=yes
	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
	      dlself=yes
	    else
	      dlself=needless
	      export_dynamic=yes
	    fi
	    prev=
	    continue
	    ;;
	  *)
	    if test "$prev" = dlfiles; then
	      dlfiles="$dlfiles $arg"
	    else
	      dlprefiles="$dlprefiles $arg"
	    fi
	    prev=
976
	    continue
unknown's avatar
unknown committed
977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
	    ;;
	  esac
	  ;;
	expsyms)
	  export_symbols="$arg"
	  if test ! -f "$arg"; then
	    $echo "$modename: symbol file \`$arg' does not exist"
	    exit 1
	  fi
	  prev=
	  continue
	  ;;
	expsyms_regex)
	  export_symbols_regex="$arg"
	  prev=
	  continue
	  ;;
994 995 996 997 998
	inst_prefix)
	  inst_prefix_dir="$arg"
	  prev=
	  continue
	  ;;
unknown's avatar
unknown committed
999 1000 1001 1002 1003
	release)
	  release="-$arg"
	  prev=
	  continue
	  ;;
1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
	objectlist)
	  if test -f "$arg"; then
	    save_arg=$arg
	    moreargs=
	    for fil in `cat $save_arg`
	    do
#	      moreargs="$moreargs $fil"
	      arg=$fil
	      # A libtool-controlled object.

	      # Check to see that this really is a libtool object.
	      if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
		pic_object=
		non_pic_object=

		# Read the .lo file
		# If there is no directory component, then add one.
		case $arg in
		*/* | *\\*) . $arg ;;
		*) . ./$arg ;;
		esac

		if test -z "$pic_object" || \
		   test -z "$non_pic_object" ||
		   test "$pic_object" = none && \
		   test "$non_pic_object" = none; then
		  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
		  exit 1
		fi

		# Extract subdirectory from the argument.
		xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
		if test "X$xdir" = "X$arg"; then
		  xdir=
		else
		  xdir="$xdir/"
		fi

		if test "$pic_object" != none; then
		  # Prepend the subdirectory the object is found in.
		  pic_object="$xdir$pic_object"

		  if test "$prev" = dlfiles; then
		    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
		      dlfiles="$dlfiles $pic_object"
		      prev=
		      continue
		    else
		      # If libtool objects are unsupported, then we need to preload.
		      prev=dlprefiles
		    fi
		  fi

		  # CHECK ME:  I think I busted this.  -Ossama
		  if test "$prev" = dlprefiles; then
		    # Preload the old-style object.
		    dlprefiles="$dlprefiles $pic_object"
		    prev=
		  fi

		  # A PIC object.
		  libobjs="$libobjs $pic_object"
		  arg="$pic_object"
		fi

		# Non-PIC object.
		if test "$non_pic_object" != none; then
		  # Prepend the subdirectory the object is found in.
		  non_pic_object="$xdir$non_pic_object"

		  # A standard non-PIC object
		  non_pic_objects="$non_pic_objects $non_pic_object"
		  if test -z "$pic_object" || test "$pic_object" = none ; then
		    arg="$non_pic_object"
		  fi
		fi
	      else
		# Only an error if not doing a dry-run.
		if test -z "$run"; then
		  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
		  exit 1
		else
		  # Dry-run case.

		  # Extract subdirectory from the argument.
		  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
		  if test "X$xdir" = "X$arg"; then
		    xdir=
		  else
		    xdir="$xdir/"
		  fi

		  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
		  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
		  libobjs="$libobjs $pic_object"
		  non_pic_objects="$non_pic_objects $non_pic_object"
		fi
	      fi
	    done
	  else
	    $echo "$modename: link input file \`$save_arg' does not exist"
	    exit 1
	  fi
	  arg=$save_arg
	  prev=
	  continue
	  ;;
unknown's avatar
unknown committed
1111 1112
	rpath | xrpath)
	  # We need an absolute path.
1113
	  case $arg in
unknown's avatar
unknown committed
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
	  [\\/]* | [A-Za-z]:[\\/]*) ;;
	  *)
	    $echo "$modename: only absolute run-paths are allowed" 1>&2
	    exit 1
	    ;;
	  esac
	  if test "$prev" = rpath; then
	    case "$rpath " in
	    *" $arg "*) ;;
	    *) rpath="$rpath $arg" ;;
	    esac
	  else
	    case "$xrpath " in
	    *" $arg "*) ;;
	    *) xrpath="$xrpath $arg" ;;
	    esac
	  fi
	  prev=
	  continue
	  ;;
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148
	xcompiler)
	  compiler_flags="$compiler_flags $qarg"
	  prev=
	  compile_command="$compile_command $qarg"
	  finalize_command="$finalize_command $qarg"
	  continue
	  ;;
	xlinker)
	  linker_flags="$linker_flags $qarg"
	  compiler_flags="$compiler_flags $wl$qarg"
	  prev=
	  compile_command="$compile_command $wl$qarg"
	  finalize_command="$finalize_command $wl$qarg"
	  continue
	  ;;
1149 1150 1151 1152 1153 1154 1155 1156
	xcclinker)
	  linker_flags="$linker_flags $qarg"
	  compiler_flags="$compiler_flags $qarg"
	  prev=
	  compile_command="$compile_command $qarg"
	  finalize_command="$finalize_command $qarg"
	  continue
	  ;;
unknown's avatar
unknown committed
1157 1158 1159 1160 1161 1162
	*)
	  eval "$prev=\"\$arg\""
	  prev=
	  continue
	  ;;
	esac
1163
      fi # test -n "$prev"
unknown's avatar
unknown committed
1164 1165 1166

      prevarg="$arg"

1167
      case $arg in
unknown's avatar
unknown committed
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
      -all-static)
	if test -n "$link_static_flag"; then
	  compile_command="$compile_command $link_static_flag"
	  finalize_command="$finalize_command $link_static_flag"
	fi
	continue
	;;

      -allow-undefined)
	# FIXME: remove this flag sometime in the future.
	$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
	continue
	;;

      -avoid-version)
	avoid_version=yes
	continue
	;;

      -dlopen)
	prev=dlfiles
	continue
	;;

      -dlpreopen)
	prev=dlprefiles
	continue
	;;

      -export-dynamic)
	export_dynamic=yes
	continue
	;;

      -export-symbols | -export-symbols-regex)
	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1204
	  $echo "$modename: more than one -exported-symbols argument is not allowed"
unknown's avatar
unknown committed
1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
	  exit 1
	fi
	if test "X$arg" = "X-export-symbols"; then
	  prev=expsyms
	else
	  prev=expsyms_regex
	fi
	continue
	;;

1215 1216 1217 1218 1219
      -inst-prefix-dir)
	prev=inst_prefix
	continue
	;;

1220 1221 1222 1223
      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
      # so, if we see these flags be careful not to treat them like -L
      -L[A-Z][A-Z]*:*)
	case $with_gcc/$host in
1224
	no/*-*-irix* | /*-*-irix*)
1225 1226 1227 1228 1229 1230 1231
	  compile_command="$compile_command $arg"
	  finalize_command="$finalize_command $arg"
	  ;;
	esac
	continue
	;;

unknown's avatar
unknown committed
1232 1233 1234
      -L*)
	dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
	# We need an absolute path.
1235
	case $dir in
unknown's avatar
unknown committed
1236 1237 1238 1239
	[\\/]* | [A-Za-z]:[\\/]*) ;;
	*)
	  absdir=`cd "$dir" && pwd`
	  if test -z "$absdir"; then
1240 1241
	    $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
	    exit 1
unknown's avatar
unknown committed
1242 1243 1244 1245
	  fi
	  dir="$absdir"
	  ;;
	esac
1246 1247 1248 1249 1250 1251
	case "$deplibs " in
	*" -L$dir "*) ;;
	*)
	  deplibs="$deplibs -L$dir"
	  lib_search_path="$lib_search_path $dir"
	  ;;
unknown's avatar
unknown committed
1252
	esac
1253 1254 1255 1256 1257
	case $host in
	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
	  case :$dllsearchpath: in
	  *":$dir:"*) ;;
	  *) dllsearchpath="$dllsearchpath:$dir";;
unknown's avatar
unknown committed
1258 1259 1260
	  esac
	  ;;
	esac
1261
	continue
unknown's avatar
unknown committed
1262 1263 1264
	;;

      -l*)
1265 1266 1267 1268
	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
	  case $host in
	  *-*-cygwin* | *-*-pw32* | *-*-beos*)
	    # These systems don't actually have a C or math library (as such)
unknown's avatar
unknown committed
1269 1270
	    continue
	    ;;
1271 1272 1273 1274
	  *-*-mingw* | *-*-os2*)
	    # These systems don't actually have a C library (as such)
	    test "X$arg" = "X-lc" && continue
	    ;;
1275
	  *-*-openbsd* | *-*-freebsd*)
1276 1277 1278
	    # Do not include libc due to us having libc/libc_r.
	    test "X$arg" = "X-lc" && continue
	    ;;
1279 1280 1281
	  *-*-rhapsody* | *-*-darwin1.[012])
	    # Rhapsody C and math libraries are in the System framework
	    deplibs="$deplibs -framework System"
unknown's avatar
unknown committed
1282 1283
	    continue
	  esac
1284 1285 1286 1287 1288 1289 1290
	elif test "X$arg" = "X-lc_r"; then
	 case $host in
	 *-*-openbsd* | *-*-freebsd*)
	   # Do not include libc_r directly, use -pthread flag.
	   continue
	   ;;
	 esac
unknown's avatar
unknown committed
1291 1292
	fi
	deplibs="$deplibs $arg"
1293
	continue
unknown's avatar
unknown committed
1294 1295 1296 1297 1298 1299 1300
	;;

      -module)
	module=yes
	continue
	;;

1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328
      # gcc -m* arguments should be passed to the linker via $compiler_flags
      # in order to pass architecture information to the linker
      # (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo
      # but this is not reliable with gcc because gcc may use -mfoo to
      # select a different linker, different libraries, etc, while
      # -Wl,-mfoo simply passes -mfoo to the linker.
      -m*)
	# Unknown arguments in both finalize_command and compile_command need
	# to be aesthetically quoted because they are evaled later.
	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
	case $arg in
	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
	  arg="\"$arg\""
	  ;;
	esac
        compile_command="$compile_command $arg"
        finalize_command="$finalize_command $arg"
        if test "$with_gcc" = "yes" ; then
          compiler_flags="$compiler_flags $arg"
        fi
        continue
        ;;

      -shrext)
	prev=shrext
	continue
	;;

1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
      -no-fast-install)
	fast_install=no
	continue
	;;

      -no-install)
	case $host in
	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
	  # The PATH hackery in wrapper scripts is required on Windows
	  # in order for the loader to find any dlls it needs.
	  $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
	  $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
	  fast_install=no
	  ;;
	*) no_install=yes ;;
	esac
	continue
	;;

unknown's avatar
unknown committed
1348 1349 1350 1351 1352
      -no-undefined)
	allow_undefined=no
	continue
	;;

1353 1354 1355 1356 1357
      -objectlist)
	prev=objectlist
	continue
	;;

unknown's avatar
unknown committed
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377
      -o) prev=output ;;

      -release)
	prev=release
	continue
	;;

      -rpath)
	prev=rpath
	continue
	;;

      -R)
	prev=xrpath
	continue
	;;

      -R*)
	dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
	# We need an absolute path.
1378
	case $dir in
unknown's avatar
unknown committed
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392
	[\\/]* | [A-Za-z]:[\\/]*) ;;
	*)
	  $echo "$modename: only absolute run-paths are allowed" 1>&2
	  exit 1
	  ;;
	esac
	case "$xrpath " in
	*" $dir "*) ;;
	*) xrpath="$xrpath $dir" ;;
	esac
	continue
	;;

      -static)
1393 1394 1395 1396 1397
	# The effects of -static are defined in a previous loop.
	# We used to do the same as -all-static on platforms that
	# didn't have a PIC flag, but the assumption that the effects
	# would be equivalent was wrong.  It would break on at least
	# Digital Unix and AIX.
unknown's avatar
unknown committed
1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409
	continue
	;;

      -thread-safe)
	thread_safe=yes
	continue
	;;

      -version-info)
	prev=vinfo
	continue
	;;
1410 1411 1412 1413 1414
      -version-number)
	prev=vinfo
	vinfo_number=yes
	continue
	;;
unknown's avatar
unknown committed
1415

1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462
      -Wc,*)
	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
	arg=
	save_ifs="$IFS"; IFS=','
	for flag in $args; do
	  IFS="$save_ifs"
	  case $flag in
	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
	    flag="\"$flag\""
	    ;;
	  esac
	  arg="$arg $wl$flag"
	  compiler_flags="$compiler_flags $flag"
	done
	IFS="$save_ifs"
	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
	;;

      -Wl,*)
	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
	arg=
	save_ifs="$IFS"; IFS=','
	for flag in $args; do
	  IFS="$save_ifs"
	  case $flag in
	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
	    flag="\"$flag\""
	    ;;
	  esac
	  arg="$arg $wl$flag"
	  compiler_flags="$compiler_flags $wl$flag"
	  linker_flags="$linker_flags $flag"
	done
	IFS="$save_ifs"
	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
	;;

      -Xcompiler)
	prev=xcompiler
	continue
	;;

      -Xlinker)
	prev=xlinker
	continue
	;;

1463 1464 1465 1466 1467
      -XCClinker)
	prev=xcclinker
	continue
	;;

unknown's avatar
unknown committed
1468 1469 1470 1471 1472
      # Some other compiler flag.
      -* | +*)
	# Unknown arguments in both finalize_command and compile_command need
	# to be aesthetically quoted because they are evaled later.
	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1473 1474
	case $arg in
	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
unknown's avatar
unknown committed
1475 1476 1477 1478 1479
	  arg="\"$arg\""
	  ;;
	esac
	;;

1480 1481 1482 1483
      *.$objext)
	# A standard object.
	objs="$objs $arg"
	;;
unknown's avatar
unknown committed
1484

1485 1486 1487 1488 1489 1490 1491 1492 1493 1494
      *.lo)
	# A libtool-controlled object.

	# Check to see that this really is a libtool object.
	if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
	  pic_object=
	  non_pic_object=

	  # Read the .lo file
	  # If there is no directory component, then add one.
1495
	  case $arg in
1496 1497
	  */* | *\\*) . $arg ;;
	  *) . ./$arg ;;
1498
	  esac
1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574

	  if test -z "$pic_object" || \
	     test -z "$non_pic_object" ||
	     test "$pic_object" = none && \
	     test "$non_pic_object" = none; then
	    $echo "$modename: cannot find name of object for \`$arg'" 1>&2
	    exit 1
	  fi

	  # Extract subdirectory from the argument.
	  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
	  if test "X$xdir" = "X$arg"; then
	    xdir=
 	  else
	    xdir="$xdir/"
	  fi

	  if test "$pic_object" != none; then
	    # Prepend the subdirectory the object is found in.
	    pic_object="$xdir$pic_object"

	    if test "$prev" = dlfiles; then
	      if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
		dlfiles="$dlfiles $pic_object"
		prev=
		continue
	      else
		# If libtool objects are unsupported, then we need to preload.
		prev=dlprefiles
	      fi
	    fi

	    # CHECK ME:  I think I busted this.  -Ossama
	    if test "$prev" = dlprefiles; then
	      # Preload the old-style object.
	      dlprefiles="$dlprefiles $pic_object"
	      prev=
	    fi

	    # A PIC object.
	    libobjs="$libobjs $pic_object"
	    arg="$pic_object"
	  fi

	  # Non-PIC object.
	  if test "$non_pic_object" != none; then
	    # Prepend the subdirectory the object is found in.
	    non_pic_object="$xdir$non_pic_object"

	    # A standard non-PIC object
	    non_pic_objects="$non_pic_objects $non_pic_object"
	    if test -z "$pic_object" || test "$pic_object" = none ; then
	      arg="$non_pic_object"
	    fi
	  fi
	else
	  # Only an error if not doing a dry-run.
	  if test -z "$run"; then
	    $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
	    exit 1
	  else
	    # Dry-run case.

	    # Extract subdirectory from the argument.
	    xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
	    if test "X$xdir" = "X$arg"; then
	      xdir=
	    else
	      xdir="$xdir/"
	    fi

	    pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
	    non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
	    libobjs="$libobjs $pic_object"
	    non_pic_objects="$non_pic_objects $non_pic_object"
	  fi
unknown's avatar
unknown committed
1575
	fi
1576 1577 1578 1579 1580 1581 1582
	;;

      *.$libext)
	# An archive.
	deplibs="$deplibs $arg"
	old_deplibs="$old_deplibs $arg"
	continue
unknown's avatar
unknown committed
1583 1584 1585 1586 1587
	;;

      *.la)
	# A libtool-controlled library.

1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
	if test "$prev" = dlfiles; then
	  # This library was specified with -dlopen.
	  dlfiles="$dlfiles $arg"
	  prev=
	elif test "$prev" = dlprefiles; then
	  # The library was specified with -dlpreopen.
	  dlprefiles="$dlprefiles $arg"
	  prev=
	else
	  deplibs="$deplibs $arg"
	fi
	continue
	;;

      # Some other compiler argument.
      *)
	# Unknown arguments in both finalize_command and compile_command need
	# to be aesthetically quoted because they are evaled later.
	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
	case $arg in
	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
	  arg="\"$arg\""
	  ;;
	esac
	;;
      esac # arg

      # Now actually substitute the argument into the commands.
      if test -n "$arg"; then
	compile_command="$compile_command $arg"
	finalize_command="$finalize_command $arg"
      fi
    done # argument parsing loop

    if test -n "$prev"; then
      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
      $echo "$help" 1>&2
      exit 1
    fi

1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668
    # Infer tagged configuration to use if any are available and
    # if one wasn't chosen via the "--tag" command line option.
    # Only attempt this if the compiler in the base link
    # command doesn't match the default compiler.
    if test -n "$available_tags" && test -z "$tagname"; then
      case $base_compile in
      # Blanks in the command may have been stripped by the calling shell,
      # but not from the CC environment variable when configure was run.
      "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*) ;;
      # Blanks at the start of $base_compile will cause this to fail
      # if we don't check for them as well.
      *)
	for z in $available_tags; do
	  if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
	    # Evaluate the configuration.
	    eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
	    case $base_compile in
	    "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*)
	      # The compiler in $compile_command matches
	      # the one in the tagged configuration.
	      # Assume this is the tagged configuration we want.
	      tagname=$z
	      break
	      ;;
	    esac
	  fi
	done
	# If $tagname still isn't set, then no tagged configuration
	# was found and let the user know that the "--tag" command
	# line option must be used.
	if test -z "$tagname"; then
	  $echo "$modename: unable to infer tagged configuration"
	  $echo "$modename: specify a tag with \`--tag'" 1>&2
	  exit 1
#       else
#         $echo "$modename: using $tagname tagged configuration"
	fi
	;;
      esac
    fi

1669 1670 1671 1672 1673 1674
    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
      eval arg=\"$export_dynamic_flag_spec\"
      compile_command="$compile_command $arg"
      finalize_command="$finalize_command $arg"
    fi

1675
    oldlibs=
1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695
    # calculate the name of the file, without its directory
    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
    libobjs_save="$libobjs"

    if test -n "$shlibpath_var"; then
      # get the directories listed in $shlibpath_var
      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
    else
      shlib_search_path=
    fi
    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"

    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
    if test "X$output_objdir" = "X$output"; then
      output_objdir="$objdir"
    else
      output_objdir="$output_objdir/$objdir"
    fi
    # Create the object directory.
1696
    if test ! -d "$output_objdir"; then
1697 1698 1699
      $show "$mkdir $output_objdir"
      $run $mkdir $output_objdir
      status=$?
1700
      if test "$status" -ne 0 && test ! -d "$output_objdir"; then
1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
	exit $status
      fi
    fi

    # Determine the type of output
    case $output in
    "")
      $echo "$modename: you must specify an output file" 1>&2
      $echo "$help" 1>&2
      exit 1
      ;;
    *.$libext) linkmode=oldlib ;;
    *.lo | *.$objext) linkmode=obj ;;
    *.la) linkmode=lib ;;
    *) linkmode=prog ;; # Anything else should be a program.
    esac

1718 1719 1720 1721 1722 1723 1724 1725 1726
    case $host in
    *cygwin* | *mingw* | *pw32*)
      # don't eliminate duplcations in $postdeps and $predeps
      duplicate_compiler_generated_deps=yes
      ;;
    *)
      duplicate_compiler_generated_deps=$duplicate_deps
      ;;
    esac
1727
    specialdeplibs=
1728

1729 1730 1731 1732
    libs=
    # Find all interdependent deplibs by searching for libraries
    # that are linked more than once (e.g. -la -lb -la)
    for deplib in $deplibs; do
1733 1734 1735 1736 1737
      if test "X$duplicate_deps" = "Xyes" ; then
	case "$libs " in
	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
	esac
      fi
1738 1739
      libs="$libs $deplib"
    done
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758

    if test "$linkmode" = lib; then
      libs="$predeps $libs $compiler_lib_search_path $postdeps"

      # Compute libraries that are listed more than once in $predeps
      # $postdeps and mark them as special (i.e., whose duplicates are
      # not to be eliminated).
      pre_post_deps=
      if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
	for pre_post_dep in $predeps $postdeps; do
	  case "$pre_post_deps " in
	  *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
	  esac
	  pre_post_deps="$pre_post_deps $pre_post_dep"
	done
      fi
      pre_post_deps=
    fi

1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789
    deplibs=
    newdependency_libs=
    newlib_search_path=
    need_relink=no # whether we're linking any uninstalled libtool libraries
    notinst_deplibs= # not-installed libtool libraries
    notinst_path= # paths that contain not-installed libtool libraries
    case $linkmode in
    lib)
	passes="conv link"
	for file in $dlfiles $dlprefiles; do
	  case $file in
	  *.la) ;;
	  *)
	    $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
	    exit 1
	    ;;
	  esac
	done
	;;
    prog)
	compile_deplibs=
	finalize_deplibs=
	alldeplibs=no
	newdlfiles=
	newdlprefiles=
	passes="conv scan dlopen dlpreopen link"
	;;
    *)  passes="conv"
	;;
    esac
    for pass in $passes; do
1790 1791 1792 1793 1794 1795
      if test "$linkmode,$pass" = "lib,link" ||
	 test "$linkmode,$pass" = "prog,scan"; then
	libs="$deplibs"
	deplibs=
      fi
      if test "$linkmode" = prog; then
1796
	case $pass in
1797
	dlopen) libs="$dlfiles" ;;
1798 1799 1800 1801
	dlpreopen) libs="$dlprefiles" ;;
	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
	esac
      fi
1802 1803 1804 1805 1806
      if test "$pass" = dlopen; then
	# Collect dlpreopened libraries
	save_deplibs="$deplibs"
	deplibs=
      fi
1807 1808 1809 1810 1811
      for deplib in $libs; do
	lib=
	found=no
	case $deplib in
	-l*)
1812 1813
	  if test "$linkmode" != lib && test "$linkmode" != prog; then
	    $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
1814 1815
	    continue
	  fi
1816
	  if test "$pass" = conv; then
1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
	    deplibs="$deplib $deplibs"
	    continue
	  fi
	  name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
	  for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
	    # Search the libtool library
	    lib="$searchdir/lib${name}.la"
	    if test -f "$lib"; then
	      found=yes
	      break
	    fi
	  done
	  if test "$found" != yes; then
	    # deplib doesn't seem to be a libtool library
	    if test "$linkmode,$pass" = "prog,link"; then
	      compile_deplibs="$deplib $compile_deplibs"
	      finalize_deplibs="$deplib $finalize_deplibs"
	    else
	      deplibs="$deplib $deplibs"
1836
	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1837 1838
	    fi
	    continue
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874
	  else # deplib is a libtool library
	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
	    # We need to do some special things here, and not later.
	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	      case " $predeps $postdeps " in
	      *" $deplib "*)
		if (${SED} -e '2q' $lib |
                    grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
		  library_names=
		  old_library=
		  case $lib in
		  */* | *\\*) . $lib ;;
		  *) . ./$lib ;;
		  esac
		  for l in $old_library $library_names; do
		    ll="$l"
		  done
		  if test "X$ll" = "X$old_library" ; then # only static version available
		    found=no
		    ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
		    test "X$ladir" = "X$lib" && ladir="."
		    lib=$ladir/$old_library
		    if test "$linkmode,$pass" = "prog,link"; then
		      compile_deplibs="$deplib $compile_deplibs"
		      finalize_deplibs="$deplib $finalize_deplibs"
		    else
		      deplibs="$deplib $deplibs"
		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
		    fi
		    continue
		  fi
		fi
	        ;;
	      *) ;;
	      esac
	    fi
1875 1876 1877 1878 1879 1880
	  fi
	  ;; # -l
	-L*)
	  case $linkmode in
	  lib)
	    deplibs="$deplib $deplibs"
1881
	    test "$pass" = conv && continue
1882 1883 1884 1885
	    newdependency_libs="$deplib $newdependency_libs"
	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
	    ;;
	  prog)
1886
	    if test "$pass" = conv; then
1887 1888 1889
	      deplibs="$deplib $deplibs"
	      continue
	    fi
1890
	    if test "$pass" = scan; then
1891 1892 1893 1894 1895 1896 1897 1898
	      deplibs="$deplib $deplibs"
	      newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
	    else
	      compile_deplibs="$deplib $compile_deplibs"
	      finalize_deplibs="$deplib $finalize_deplibs"
	    fi
	    ;;
	  *)
1899
	    $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
1900 1901 1902 1903 1904
	    ;;
	  esac # linkmode
	  continue
	  ;; # -L
	-R*)
1905
	  if test "$pass" = link; then
1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917
	    dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
	    # Make sure the xrpath contains only unique directories.
	    case "$xrpath " in
	    *" $dir "*) ;;
	    *) xrpath="$xrpath $dir" ;;
	    esac
	  fi
	  deplibs="$deplib $deplibs"
	  continue
	  ;;
	*.la) lib="$deplib" ;;
	*.$libext)
1918
	  if test "$pass" = conv; then
1919 1920 1921 1922 1923 1924
	    deplibs="$deplib $deplibs"
	    continue
	  fi
	  case $linkmode in
	  lib)
	    if test "$deplibs_check_method" != pass_all; then
1925 1926 1927 1928 1929 1930 1931
	      $echo
	      $echo "*** Warning: Trying to link with static lib archive $deplib."
	      $echo "*** I have the capability to make that library automatically link in when"
	      $echo "*** you link to this library.  But I can only do this if you have a"
	      $echo "*** shared version of the library, which you do not appear to have"
	      $echo "*** because the file extensions .$libext of this argument makes me believe"
	      $echo "*** that it is just a static archive that I should not used here."
1932
	    else
1933 1934 1935
	      $echo
	      $echo "*** Warning: Linking the shared library $output against the"
	      $echo "*** static library $deplib is not portable!"
1936 1937 1938 1939 1940
	      deplibs="$deplib $deplibs"
	    fi
	    continue
	    ;;
	  prog)
1941
	    if test "$pass" != link; then
1942 1943 1944 1945 1946 1947 1948 1949 1950 1951
	      deplibs="$deplib $deplibs"
	    else
	      compile_deplibs="$deplib $compile_deplibs"
	      finalize_deplibs="$deplib $finalize_deplibs"
	    fi
	    continue
	    ;;
	  esac # linkmode
	  ;; # *.$libext
	*.lo | *.$objext)
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963
	  if test "$pass" = conv; then
	    deplibs="$deplib $deplibs"
	  elif test "$linkmode" = prog; then
	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
	      # If there is no dlopen support or we're linking statically,
	      # we need to preload.
	      newdlprefiles="$newdlprefiles $deplib"
	      compile_deplibs="$deplib $compile_deplibs"
	      finalize_deplibs="$deplib $finalize_deplibs"
	    else
	      newdlfiles="$newdlfiles $deplib"
	    fi
1964 1965 1966 1967 1968 1969 1970 1971
	  fi
	  continue
	  ;;
	%DEPLIBS%)
	  alldeplibs=yes
	  continue
	  ;;
	esac # case $deplib
1972
	if test "$found" = yes || test -f "$lib"; then :
1973 1974 1975 1976
	else
	  $echo "$modename: cannot find the library \`$lib'" 1>&2
	  exit 1
	fi
unknown's avatar
unknown committed
1977 1978

	# Check to see that this really is a libtool archive.
1979
	if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
unknown's avatar
unknown committed
1980
	else
1981
	  $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
unknown's avatar
unknown committed
1982 1983 1984
	  exit 1
	fi

1985 1986 1987 1988 1989 1990 1991 1992 1993
	ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
	test "X$ladir" = "X$lib" && ladir="."

	dlname=
	dlopen=
	dlpreopen=
	libdir=
	library_names=
	old_library=
unknown's avatar
unknown committed
1994
	# If the library was installed with an old release of libtool,
1995
	# it will not redefine variables installed, or shouldnotlink
unknown's avatar
unknown committed
1996
	installed=yes
1997
	shouldnotlink=no
unknown's avatar
unknown committed
1998 1999

	# Read the .la file
2000 2001 2002
	case $lib in
	*/* | *\\*) . $lib ;;
	*) . ./$lib ;;
unknown's avatar
unknown committed
2003 2004
	esac

2005 2006
	if test "$linkmode,$pass" = "lib,link" ||
	   test "$linkmode,$pass" = "prog,scan" ||
2007
	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2008 2009 2010 2011
	  test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
	  test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
	fi

2012
	if test "$pass" = conv; then
2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025
	  # Only check for convenience libraries
	  deplibs="$lib $deplibs"
	  if test -z "$libdir"; then
	    if test -z "$old_library"; then
	      $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
	      exit 1
	    fi
	    # It is a libtool convenience library, so add in its objects.
	    convenience="$convenience $ladir/$objdir/$old_library"
	    old_convenience="$old_convenience $ladir/$objdir/$old_library"
	    tmp_libs=
	    for deplib in $dependency_libs; do
	      deplibs="$deplib $deplibs"
2026 2027 2028 2029 2030
              if test "X$duplicate_deps" = "Xyes" ; then
	        case "$tmp_libs " in
	        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
	        esac
              fi
2031 2032
	      tmp_libs="$tmp_libs $deplib"
	    done
2033
	  elif test "$linkmode" != prog && test "$linkmode" != lib; then
2034 2035 2036 2037 2038 2039
	    $echo "$modename: \`$lib' is not a convenience library" 1>&2
	    exit 1
	  fi
	  continue
	fi # $pass = conv

2040
    
unknown's avatar
unknown committed
2041 2042 2043 2044 2045 2046
	# Get the name of the library we link against.
	linklib=
	for l in $old_library $library_names; do
	  linklib="$l"
	done
	if test -z "$linklib"; then
2047
	  $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
unknown's avatar
unknown committed
2048 2049 2050
	  exit 1
	fi

2051
	# This library was specified with -dlopen.
2052
	if test "$pass" = dlopen; then
2053 2054 2055 2056 2057 2058
	  if test -z "$libdir"; then
	    $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
	    exit 1
	  fi
	  if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
	    # If there is no dlname, no dlopen support or we're linking
2059 2060 2061 2062
	    # statically, we need to preload.  We also need to preload any
	    # dependent libraries so libltdl's deplib preloader doesn't
	    # bomb out in the load deplibs phase.
	    dlprefiles="$dlprefiles $lib $dependency_libs"
unknown's avatar
unknown committed
2063
	  else
2064
	    newdlfiles="$newdlfiles $lib"
unknown's avatar
unknown committed
2065 2066
	  fi
	  continue
2067
	fi # $pass = dlopen
unknown's avatar
unknown committed
2068

2069 2070 2071 2072 2073 2074 2075 2076 2077
	# We need an absolute path.
	case $ladir in
	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
	*)
	  abs_ladir=`cd "$ladir" && pwd`
	  if test -z "$abs_ladir"; then
	    $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
	    $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
	    abs_ladir="$ladir"
unknown's avatar
unknown committed
2078
	  fi
2079 2080 2081
	  ;;
	esac
	laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
unknown's avatar
unknown committed
2082

2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102
	# Find the relevant object directory and library name.
	if test "X$installed" = Xyes; then
	  if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
	    $echo "$modename: warning: library \`$lib' was moved." 1>&2
	    dir="$ladir"
	    absdir="$abs_ladir"
	    libdir="$abs_ladir"
	  else
	    dir="$libdir"
	    absdir="$libdir"
	  fi
	else
	  dir="$ladir/$objdir"
	  absdir="$abs_ladir/$objdir"
	  # Remove this search path later
	  notinst_path="$notinst_path $abs_ladir"
	fi # $installed = yes
	name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`

	# This library was specified with -dlpreopen.
2103
	if test "$pass" = dlpreopen; then
2104 2105 2106 2107
	  if test -z "$libdir"; then
	    $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
	    exit 1
	  fi
unknown's avatar
unknown committed
2108 2109 2110
	  # Prefer using a static library (so that no silly _DYNAMIC symbols
	  # are required to link).
	  if test -n "$old_library"; then
2111 2112 2113 2114
	    newdlprefiles="$newdlprefiles $dir/$old_library"
	  # Otherwise, use the dlname, so that lt_dlopen finds it.
	  elif test -n "$dlname"; then
	    newdlprefiles="$newdlprefiles $dir/$dlname"
unknown's avatar
unknown committed
2115
	  else
2116
	    newdlprefiles="$newdlprefiles $dir/$linklib"
unknown's avatar
unknown committed
2117
	  fi
2118 2119 2120 2121
	fi # $pass = dlpreopen

	if test -z "$libdir"; then
	  # Link the convenience library
2122
	  if test "$linkmode" = lib; then
2123 2124 2125 2126 2127
	    deplibs="$dir/$old_library $deplibs"
	  elif test "$linkmode,$pass" = "prog,link"; then
	    compile_deplibs="$dir/$old_library $compile_deplibs"
	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
	  else
2128
	    deplibs="$lib $deplibs" # used for prog,scan pass
2129 2130
	  fi
	  continue
unknown's avatar
unknown committed
2131 2132
	fi

2133 2134
    
	if test "$linkmode" = prog && test "$pass" != link; then
2135 2136 2137 2138 2139 2140 2141
	  newlib_search_path="$newlib_search_path $ladir"
	  deplibs="$lib $deplibs"

	  linkalldeplibs=no
	  if test "$link_all_deplibs" != no || test -z "$library_names" ||
	     test "$build_libtool_libs" = no; then
	    linkalldeplibs=yes
unknown's avatar
unknown committed
2142 2143
	  fi

2144 2145 2146 2147 2148 2149
	  tmp_libs=
	  for deplib in $dependency_libs; do
	    case $deplib in
	    -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
	    esac
	    # Need to link against all dependency_libs?
2150
	    if test "$linkalldeplibs" = yes; then
2151 2152 2153 2154 2155
	      deplibs="$deplib $deplibs"
	    else
	      # Need to hardcode shared library paths
	      # or/and link against static libraries
	      newdependency_libs="$deplib $newdependency_libs"
unknown's avatar
unknown committed
2156
	    fi
2157 2158 2159 2160 2161
	    if test "X$duplicate_deps" = "Xyes" ; then
	      case "$tmp_libs " in
	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
	      esac
	    fi
2162 2163 2164 2165
	    tmp_libs="$tmp_libs $deplib"
	  done # for deplib
	  continue
	fi # $linkmode = prog...
unknown's avatar
unknown committed
2166

2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178
	if test "$linkmode,$pass" = "prog,link"; then
	  if test -n "$library_names" &&
	     { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
	    # We need to hardcode the library path
	    if test -n "$shlibpath_var"; then
	      # Make sure the rpath contains only unique directories.
	      case "$temp_rpath " in
	      *" $dir "*) ;;
	      *" $absdir "*) ;;
	      *) temp_rpath="$temp_rpath $dir" ;;
	      esac
	    fi
2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192

	    # Hardcode the library path.
	    # Skip directories that are in the system default run-time
	    # search path.
	    case " $sys_lib_dlsearch_path " in
	    *" $absdir "*) ;;
	    *)
	      case "$compile_rpath " in
	      *" $absdir "*) ;;
	      *) compile_rpath="$compile_rpath $absdir"
	      esac
	      ;;
	    esac
	    case " $sys_lib_dlsearch_path " in
unknown's avatar
unknown committed
2193
	    *" $libdir "*) ;;
2194 2195 2196 2197 2198 2199
	    *)
	      case "$finalize_rpath " in
	      *" $libdir "*) ;;
	      *) finalize_rpath="$finalize_rpath $libdir"
	      esac
	      ;;
unknown's avatar
unknown committed
2200
	    esac
2201
	  fi # $linkmode,$pass = prog,link...
unknown's avatar
unknown committed
2202

2203 2204 2205 2206 2207 2208 2209
	  if test "$alldeplibs" = yes &&
	     { test "$deplibs_check_method" = pass_all ||
	       { test "$build_libtool_libs" = yes &&
		 test -n "$library_names"; }; }; then
	    # We only need to search for static libraries
	    continue
	  fi
2210
	fi
2211

2212 2213 2214
	link_static=no # Whether the deplib will be linked statically
	if test -n "$library_names" &&
	   { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2215 2216 2217 2218
	  if test "$installed" = no; then
	    notinst_deplibs="$notinst_deplibs $lib"
	    need_relink=yes
	  fi
2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254
	  # This is a shared library
	
      # Warn about portability, can't link against -module's on some systems (darwin)
      if test "$shouldnotlink" = yes && test "$pass" = link ; then
	    $echo
	    if test "$linkmode" = prog; then
	      $echo "*** Warning: Linking the executable $output against the loadable module"
	    else
	      $echo "*** Warning: Linking the shared library $output against the loadable module"
	    fi
	    $echo "*** $linklib is not portable!"    
      fi	  
	  if test "$linkmode" = lib &&
	     test "$hardcode_into_libs" = yes; then
	    # Hardcode the library path.
	    # Skip directories that are in the system default run-time
	    # search path.
	    case " $sys_lib_dlsearch_path " in
	    *" $absdir "*) ;;
	    *)
	      case "$compile_rpath " in
	      *" $absdir "*) ;;
	      *) compile_rpath="$compile_rpath $absdir"
	      esac
	      ;;
	    esac
	    case " $sys_lib_dlsearch_path " in
	    *" $libdir "*) ;;
	    *)
	      case "$finalize_rpath " in
	      *" $libdir "*) ;;
	      *) finalize_rpath="$finalize_rpath $libdir"
	      esac
	      ;;
	    esac
	  fi
2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267

	  if test -n "$old_archive_from_expsyms_cmds"; then
	    # figure out the soname
	    set dummy $library_names
	    realname="$2"
	    shift; shift
	    libname=`eval \\$echo \"$libname_spec\"`
	    # use dlname if we got it. it's perfectly good, no?
	    if test -n "$dlname"; then
	      soname="$dlname"
	    elif test -n "$soname_spec"; then
	      # bleh windows
	      case $host in
2268
	      *cygwin* | mingw*)
2269 2270
		major=`expr $current - $age`
		versuffix="-$major"
unknown's avatar
unknown committed
2271 2272
		;;
	      esac
2273 2274 2275 2276 2277 2278 2279
	      eval soname=\"$soname_spec\"
	    else
	      soname="$realname"
	    fi

	    # Make a new name for the extract_expsyms_cmds to use
	    soroot="$soname"
2280 2281
	    soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
	    newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311

	    # If the library has no export list, then create one now
	    if test -f "$output_objdir/$soname-def"; then :
	    else
	      $show "extracting exported symbol list from \`$soname'"
	      save_ifs="$IFS"; IFS='~'
	      eval cmds=\"$extract_expsyms_cmds\"
	      for cmd in $cmds; do
		IFS="$save_ifs"
		$show "$cmd"
		$run eval "$cmd" || exit $?
	      done
	      IFS="$save_ifs"
	    fi

	    # Create $newlib
	    if test -f "$output_objdir/$newlib"; then :; else
	      $show "generating import library for \`$soname'"
	      save_ifs="$IFS"; IFS='~'
	      eval cmds=\"$old_archive_from_expsyms_cmds\"
	      for cmd in $cmds; do
		IFS="$save_ifs"
		$show "$cmd"
		$run eval "$cmd" || exit $?
	      done
	      IFS="$save_ifs"
	    fi
	    # make sure the library variables are pointing to the new library
	    dir=$output_objdir
	    linklib=$newlib
2312
	  fi # test -n "$old_archive_from_expsyms_cmds"
2313

2314
	  if test "$linkmode" = prog || test "$mode" != relink; then
2315 2316 2317 2318 2319 2320 2321 2322
	    add_shlibpath=
	    add_dir=
	    add=
	    lib_linked=yes
	    case $hardcode_action in
	    immediate | unsupported)
	      if test "$hardcode_direct" = no; then
		add="$dir/$linklib"
2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338
		case $host in
		  *-*-sco3.2v5* ) add_dir="-L$dir" ;;
		  *-*-darwin* )
		    # if the lib is a module then we can not link against it, someone
		    # is ignoring the new warnings I added
		    if /usr/bin/file -L $add 2> /dev/null | grep "bundle" >/dev/null ; then
		      $echo "** Warning, lib $linklib is a module, not a shared library"
		      if test -z "$old_library" ; then
		        $echo
		        $echo "** And there doesn't seem to be a static archive available"
		        $echo "** The link will probably fail, sorry"
		      else
		        add="$dir/$old_library"
		      fi 
		    fi
		esac
2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356
	      elif test "$hardcode_minus_L" = no; then
		case $host in
		*-*-sunos*) add_shlibpath="$dir" ;;
		esac
		add_dir="-L$dir"
		add="-l$name"
	      elif test "$hardcode_shlibpath_var" = no; then
		add_shlibpath="$dir"
		add="-l$name"
	      else
		lib_linked=no
	      fi
	      ;;
	    relink)
	      if test "$hardcode_direct" = yes; then
		add="$dir/$linklib"
	      elif test "$hardcode_minus_L" = yes; then
		add_dir="-L$dir"
2357 2358 2359 2360 2361 2362 2363 2364
		# Try looking first in the location we're being installed to.
		if test -n "$inst_prefix_dir"; then
		  case "$libdir" in
		    [\\/]*)
		      add_dir="-L$inst_prefix_dir$libdir $add_dir"
		      ;;
		  esac
		fi
2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384
		add="-l$name"
	      elif test "$hardcode_shlibpath_var" = yes; then
		add_shlibpath="$dir"
		add="-l$name"
	      else
		lib_linked=no
	      fi
	      ;;
	    *) lib_linked=no ;;
	    esac

	    if test "$lib_linked" != yes; then
	      $echo "$modename: configuration error: unsupported hardcode properties"
	      exit 1
	    fi

	    if test -n "$add_shlibpath"; then
	      case :$compile_shlibpath: in
	      *":$add_shlibpath:"*) ;;
	      *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
unknown's avatar
unknown committed
2385
	      esac
2386
	    fi
2387
	    if test "$linkmode" = prog; then
2388 2389
	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
unknown's avatar
unknown committed
2390
	    else
2391 2392 2393 2394 2395 2396 2397 2398 2399 2400
	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
	      test -n "$add" && deplibs="$add $deplibs"
	      if test "$hardcode_direct" != yes && \
		 test "$hardcode_minus_L" != yes && \
		 test "$hardcode_shlibpath_var" = yes; then
		case :$finalize_shlibpath: in
		*":$libdir:"*) ;;
		*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
		esac
	      fi
unknown's avatar
unknown committed
2401
	    fi
2402
	  fi
unknown's avatar
unknown committed
2403

2404
	  if test "$linkmode" = prog || test "$mode" = relink; then
2405 2406 2407 2408
	    add_shlibpath=
	    add_dir=
	    add=
	    # Finalize command for both is simple: just hardcode it.
unknown's avatar
unknown committed
2409
	    if test "$hardcode_direct" = yes; then
2410
	      add="$libdir/$linklib"
unknown's avatar
unknown committed
2411
	    elif test "$hardcode_minus_L" = yes; then
2412 2413
	      add_dir="-L$libdir"
	      add="-l$name"
unknown's avatar
unknown committed
2414
	    elif test "$hardcode_shlibpath_var" = yes; then
2415 2416 2417
	      case :$finalize_shlibpath: in
	      *":$libdir:"*) ;;
	      *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
unknown's avatar
unknown committed
2418
	      esac
2419
	      add="-l$name"
2420 2421 2422 2423 2424 2425
	    elif test "$hardcode_automatic" = yes; then
	      if test -n "$inst_prefix_dir" && test -f "$inst_prefix_dir$libdir/$linklib" ; then
	        add="$inst_prefix_dir$libdir/$linklib"
	      else
	        add="$libdir/$linklib"
	      fi
unknown's avatar
unknown committed
2426
	    else
2427
	      # We cannot seem to hardcode it, guess we'll fake it.
2428 2429 2430 2431 2432 2433 2434 2435
	      add_dir="-L$libdir"
	      # Try looking first in the location we're being installed to.
	      if test -n "$inst_prefix_dir"; then
		case "$libdir" in
		  [\\/]*)
		    add_dir="-L$inst_prefix_dir$libdir $add_dir"
		    ;;
		esac
2436 2437
	      fi
	      add="-l$name"
unknown's avatar
unknown committed
2438 2439
	    fi

2440
	    if test "$linkmode" = prog; then
2441 2442 2443 2444 2445 2446
	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
	    else
	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
	      test -n "$add" && deplibs="$add $deplibs"
	    fi
unknown's avatar
unknown committed
2447
	  fi
2448
	elif test "$linkmode" = prog; then
unknown's avatar
unknown committed
2449 2450 2451 2452 2453
	  # Here we assume that one of hardcode_direct or hardcode_minus_L
	  # is not unsupported.  This is valid on all known static and
	  # shared platforms.
	  if test "$hardcode_direct" != unsupported; then
	    test -n "$old_library" && linklib="$old_library"
2454 2455
	    compile_deplibs="$dir/$linklib $compile_deplibs"
	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
unknown's avatar
unknown committed
2456
	  else
2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467
	    compile_deplibs="-l$name -L$dir $compile_deplibs"
	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
	  fi
	elif test "$build_libtool_libs" = yes; then
	  # Not a shared library
	  if test "$deplibs_check_method" != pass_all; then
	    # We're trying link a shared library against a static one
	    # but the system doesn't support it.

	    # Just print a warning and add the library to dependency_libs so
	    # that the program can be linked against the static library.
2468 2469 2470 2471 2472
	    $echo
	    $echo "*** Warning: This system can not link to static lib archive $lib."
	    $echo "*** I have the capability to make that library automatically link in when"
	    $echo "*** you link to this library.  But I can only do this if you have a"
	    $echo "*** shared version of the library, which you do not appear to have."
2473
	    if test "$module" = yes; then
2474 2475 2476
	      $echo "*** But as you try to build a module library, libtool will still create "
	      $echo "*** a static module, that should work as long as the dlopening application"
	      $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2477
	      if test -z "$global_symbol_pipe"; then
2478 2479 2480 2481 2482
		$echo
		$echo "*** However, this would only work if libtool was able to extract symbol"
		$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
		$echo "*** not find such a program.  So, this module is probably useless."
		$echo "*** \`nm' from GNU binutils and a full rebuild may help."
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498
	      fi
	      if test "$build_old_libs" = no; then
		build_libtool_libs=module
		build_old_libs=yes
	      else
		build_libtool_libs=no
	      fi
	    fi
	  else
	    convenience="$convenience $dir/$old_library"
	    old_convenience="$old_convenience $dir/$old_library"
	    deplibs="$dir/$old_library $deplibs"
	    link_static=yes
	  fi
	fi # link shared/static library?

2499
	if test "$linkmode" = lib; then
2500
	  if test -n "$dependency_libs" &&
2501 2502
	     { test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes ||
	       test "$link_static" = yes; }; then
2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515
	    # Extract -R from dependency_libs
	    temp_deplibs=
	    for libdir in $dependency_libs; do
	      case $libdir in
	      -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
		   case " $xrpath " in
		   *" $temp_xrpath "*) ;;
		   *) xrpath="$xrpath $temp_xrpath";;
		   esac;;
	      *) temp_deplibs="$temp_deplibs $libdir";;
	      esac
	    done
	    dependency_libs="$temp_deplibs"
unknown's avatar
unknown committed
2516 2517
	  fi

2518 2519 2520 2521 2522 2523 2524
	  newlib_search_path="$newlib_search_path $absdir"
	  # Link against this library
	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
	  # ... and its dependency_libs
	  tmp_libs=
	  for deplib in $dependency_libs; do
	    newdependency_libs="$deplib $newdependency_libs"
2525 2526 2527 2528 2529
	    if test "X$duplicate_deps" = "Xyes" ; then
	      case "$tmp_libs " in
	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
	      esac
	    fi
2530 2531
	    tmp_libs="$tmp_libs $deplib"
	  done
unknown's avatar
unknown committed
2532

2533
	  if test "$link_all_deplibs" != no; then
2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552
	    # Add the search paths of all dependency libraries
	    for deplib in $dependency_libs; do
	      case $deplib in
	      -L*) path="$deplib" ;;
	      *.la)
		dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
		test "X$dir" = "X$deplib" && dir="."
		# We need an absolute path.
		case $dir in
		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
		*)
		  absdir=`cd "$dir" && pwd`
		  if test -z "$absdir"; then
		    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
		    absdir="$dir"
		  fi
		  ;;
		esac
		if grep "^installed=no" $deplib > /dev/null; then
2553
		  path="$absdir/$objdir"
2554
		else
2555
		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2556 2557 2558 2559 2560 2561 2562
		  if test -z "$libdir"; then
		    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
		    exit 1
		  fi
		  if test "$absdir" != "$libdir"; then
		    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
		  fi
2563
		  path="$absdir"
2564
		fi
2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601
		depdepl=
		case $host in
		*-*-darwin*)
		  # we do not want to link against static libs, but need to link against shared
		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
		  if test -n "$deplibrary_names" ; then
		    for tmp in $deplibrary_names ; do
		      depdepl=$tmp
		    done
		    if test -f "$path/$depdepl" ; then
		      depdepl="$path/$depdepl"
		   fi
		    newlib_search_path="$newlib_search_path $path"
		    path=""
		  fi
		  ;;
		*)
		path="-L$path"
		;;
		esac 
		
		;;
		  -l*)
		case $host in
		*-*-darwin*)
		 # Again, we only want to link against shared libraries
		 eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
		 for tmp in $newlib_search_path ; do
		     if test -f "$tmp/lib$tmp_libs.dylib" ; then
		       eval depdepl="$tmp/lib$tmp_libs.dylib"
		       break
		     fi  
         done
         path=""
		  ;;
		*) continue ;;
		esac  		  
2602 2603 2604 2605
		;;
	      *) continue ;;
	      esac
	      case " $deplibs " in
2606 2607 2608 2609
	      *" $depdepl "*) ;;
	      *) deplibs="$deplibs $depdepl" ;;
	      esac	      
	      case " $deplibs " in
2610 2611 2612 2613 2614 2615 2616
	      *" $path "*) ;;
	      *) deplibs="$deplibs $path" ;;
	      esac
	    done
	  fi # link_all_deplibs != no
	fi # linkmode = lib
      done # for deplib in $libs
2617 2618
      dependency_libs="$newdependency_libs"
      if test "$pass" = dlpreopen; then
2619 2620 2621 2622
	# Link the dlpreopened libraries before other libraries
	for deplib in $save_deplibs; do
	  deplibs="$deplib $deplibs"
	done
unknown's avatar
unknown committed
2623
      fi
2624 2625
      if test "$pass" != dlopen; then
	if test "$pass" != conv; then
2626 2627 2628 2629 2630 2631 2632 2633 2634 2635
	  # Make sure lib_search_path contains only unique directories.
	  lib_search_path=
	  for dir in $newlib_search_path; do
	    case "$lib_search_path " in
	    *" $dir "*) ;;
	    *) lib_search_path="$lib_search_path $dir" ;;
	    esac
	  done
	  newlib_search_path=
	fi
unknown's avatar
unknown committed
2636

2637 2638 2639 2640 2641 2642 2643 2644 2645 2646
	if test "$linkmode,$pass" != "prog,link"; then
	  vars="deplibs"
	else
	  vars="compile_deplibs finalize_deplibs"
	fi
	for var in $vars dependency_libs; do
	  # Add libraries to $var in reverse order
	  eval tmp_libs=\"\$$var\"
	  new_libs=
	  for deplib in $tmp_libs; do
2647 2648 2649 2650 2651 2652
	    # FIXME: Pedantically, this is the right thing to do, so
	    #        that some nasty dependency loop isn't accidentally
	    #        broken:
	    #new_libs="$deplib $new_libs"
	    # Pragmatically, this seems to cause very few problems in
	    # practice:
2653 2654
	    case $deplib in
	    -L*) new_libs="$deplib $new_libs" ;;
2655
	    -R*) ;;
2656
	    *)
2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670
	      # And here is the reason: when a library appears more
	      # than once as an explicit dependence of a library, or
	      # is implicitly linked in more than once by the
	      # compiler, it is considered special, and multiple
	      # occurrences thereof are not removed.  Compare this
	      # with having the same library being listed as a
	      # dependency of multiple other libraries: in this case,
	      # we know (pedantically, we assume) the library does not
	      # need to be listed more than once, so we keep only the
	      # last copy.  This is not always right, but it is rare
	      # enough that we require users that really mean to play
	      # such unportable linking tricks to link the library
	      # using -Wl,-lname, so that libtool does not consider it
	      # for duplicate removal.
2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696
	      case " $specialdeplibs " in
	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
	      *)
		case " $new_libs " in
		*" $deplib "*) ;;
		*) new_libs="$deplib $new_libs" ;;
		esac
		;;
	      esac
	      ;;
	    esac
	  done
	  tmp_libs=
	  for deplib in $new_libs; do
	    case $deplib in
	    -L*)
	      case " $tmp_libs " in
	      *" $deplib "*) ;;
	      *) tmp_libs="$tmp_libs $deplib" ;;
	      esac
	      ;;
	    *) tmp_libs="$tmp_libs $deplib" ;;
	    esac
	  done
	  eval $var=\"$tmp_libs\"
	done # for var
unknown's avatar
unknown committed
2697
      fi
2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710
      # Last step: remove runtime libs from dependency_libs (they stay in deplibs)
      tmp_libs=
      for i in $dependency_libs ; do
	case " $predeps $postdeps $compiler_lib_search_path " in
	*" $i "*)
	  i=""
	  ;;
	esac
	if test -n "$i" ; then
	  tmp_libs="$tmp_libs $i"
	fi
      done
      dependency_libs=$tmp_libs
2711
    done # for pass
2712
    if test "$linkmode" = prog; then
2713 2714 2715
      dlfiles="$newdlfiles"
      dlprefiles="$newdlprefiles"
    fi
unknown's avatar
unknown committed
2716

2717 2718
    case $linkmode in
    oldlib)
2719 2720 2721 2722
      if test -n "$deplibs"; then
	$echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
      fi

unknown's avatar
unknown committed
2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
	$echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
      fi

      if test -n "$rpath"; then
	$echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
      fi

      if test -n "$xrpath"; then
	$echo "$modename: warning: \`-R' is ignored for archives" 1>&2
      fi

      if test -n "$vinfo"; then
2736
	$echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
unknown's avatar
unknown committed
2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749
      fi

      if test -n "$release"; then
	$echo "$modename: warning: \`-release' is ignored for archives" 1>&2
      fi

      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
	$echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
      fi

      # Now set the variables for building old libraries.
      build_libtool_libs=no
      oldlibs="$output"
2750
      objs="$objs$old_deplibs"
unknown's avatar
unknown committed
2751 2752
      ;;

2753
    lib)
unknown's avatar
unknown committed
2754
      # Make sure we only generate libraries of the form `libNAME.la'.
2755
      case $outputname in
unknown's avatar
unknown committed
2756 2757
      lib*)
	name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2758
	eval shared_ext=\"$shrext\"
unknown's avatar
unknown committed
2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769
	eval libname=\"$libname_spec\"
	;;
      *)
	if test "$module" = no; then
	  $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
	  $echo "$help" 1>&2
	  exit 1
	fi
	if test "$need_lib_prefix" != no; then
	  # Add the "lib" prefix for modules if required
	  name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2770
	  eval shared_ext=\"$shrext\"
unknown's avatar
unknown committed
2771 2772 2773 2774 2775 2776 2777 2778
	  eval libname=\"$libname_spec\"
	else
	  libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
	fi
	;;
      esac

      if test -n "$objs"; then
2779 2780 2781 2782
	if test "$deplibs_check_method" != pass_all; then
	  $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
	  exit 1
	else
2783 2784 2785
	  $echo
	  $echo "*** Warning: Linking the shared library $output against the non-libtool"
	  $echo "*** objects $objs is not portable!"
2786 2787
	  libobjs="$libobjs $objs"
	fi
unknown's avatar
unknown committed
2788 2789
      fi

2790 2791
      if test "$dlself" != no; then
	$echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
unknown's avatar
unknown committed
2792 2793 2794
      fi

      set dummy $rpath
2795
      if test "$#" -gt 2; then
unknown's avatar
unknown committed
2796 2797 2798 2799 2800 2801 2802 2803
	$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
      fi
      install_libdir="$2"

      oldlibs=
      if test -z "$rpath"; then
	if test "$build_libtool_libs" = yes; then
	  # Building a libtool convenience library.
2804 2805 2806
	  # Some compilers have problems with a `.al' extension so
	  # convenience libraries should have the same extension an
	  # archive normally would.
unknown's avatar
unknown committed
2807 2808 2809 2810 2811 2812
	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
	  build_libtool_libs=convenience
	  build_old_libs=yes
	fi

	if test -n "$vinfo"; then
2813
	  $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
unknown's avatar
unknown committed
2814 2815 2816 2817 2818 2819 2820 2821
	fi

	if test -n "$release"; then
	  $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
	fi
      else

	# Parse the version information argument.
2822
	save_ifs="$IFS"; IFS=':'
unknown's avatar
unknown committed
2823 2824 2825 2826 2827 2828 2829 2830 2831
	set dummy $vinfo 0 0 0
	IFS="$save_ifs"

	if test -n "$8"; then
	  $echo "$modename: too many parameters to \`-version-info'" 1>&2
	  $echo "$help" 1>&2
	  exit 1
	fi

2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871
	# convert absolute version numbers to libtool ages
	# this retains compatibility with .la files and attempts
	# to make the code below a bit more comprehensible
	
	case $vinfo_number in
	yes)
	  number_major="$2"
	  number_minor="$3"
	  number_revision="$4"
	  #
	  # There are really only two kinds -- those that
	  # use the current revision as the major version
	  # and those that subtract age and use age as
	  # a minor version.  But, then there is irix
	  # which has an extra 1 added just for fun
	  #
	  case $version_type in
	  darwin|linux|osf|windows)
	    current=`expr $number_major + $number_minor`
	    age="$number_minor"
	    revision="$number_revision"
	    ;;
	  freebsd-aout|freebsd-elf|sunos)
	    current="$number_major"
	    revision="$number_minor"
	    age="0"
	    ;;
	  irix|nonstopux)
	    current=`expr $number_major + $number_minor - 1`
	    age="$number_minor"
	    revision="$number_minor"
	    ;;
	  esac
	  ;;
	no)
	  current="$2"
	  revision="$3"
	  age="$4"
	  ;;
	esac
unknown's avatar
unknown committed
2872 2873

	# Check that each of the things are valid numbers.
2874 2875
	case $current in
	0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
unknown's avatar
unknown committed
2876 2877 2878 2879 2880 2881 2882
	*)
	  $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
	  exit 1
	  ;;
	esac

2883 2884
	case $revision in
	0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
unknown's avatar
unknown committed
2885 2886 2887 2888 2889 2890 2891
	*)
	  $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
	  exit 1
	  ;;
	esac

2892 2893
	case $age in
	0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
unknown's avatar
unknown committed
2894 2895 2896 2897 2898 2899 2900
	*)
	  $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
	  exit 1
	  ;;
	esac

2901
	if test "$age" -gt "$current"; then
unknown's avatar
unknown committed
2902 2903 2904 2905 2906 2907 2908 2909 2910
	  $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
	  exit 1
	fi

	# Calculate the version variables.
	major=
	versuffix=
	verstring=
2911
	case $version_type in
unknown's avatar
unknown committed
2912 2913
	none) ;;

2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933
	darwin)
	  # Like Linux, but with the current version available in
	  # verstring for coding it into the library header
	  major=.`expr $current - $age`
	  versuffix="$major.$age.$revision"
	  # Darwin ld doesn't like 0 for these options...
	  minor_current=`expr $current + 1`
	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
	  ;;

	freebsd-aout)
	  major=".$current"
	  versuffix=".$current.$revision";
	  ;;

	freebsd-elf)
	  major=".$current"
	  versuffix=".$current";
	  ;;

2934
	irix | nonstopux)
unknown's avatar
unknown committed
2935
	  major=`expr $current - $age + 1`
2936 2937 2938 2939 2940 2941

	  case $version_type in
	    nonstopux) verstring_prefix=nonstopux ;;
	    *)         verstring_prefix=sgi ;;
	  esac
	  verstring="$verstring_prefix$major.$revision"
unknown's avatar
unknown committed
2942 2943 2944

	  # Add in all the interfaces that we are compatible with.
	  loop=$revision
2945
	  while test "$loop" -ne 0; do
unknown's avatar
unknown committed
2946 2947
	    iface=`expr $revision - $loop`
	    loop=`expr $loop - 1`
2948
	    verstring="$verstring_prefix$major.$iface:$verstring"
unknown's avatar
unknown committed
2949
	  done
2950 2951 2952 2953

	  # Before this point, $major must not contain `.'.
	  major=.$major
	  versuffix="$major.$revision"
unknown's avatar
unknown committed
2954 2955 2956 2957 2958 2959 2960 2961
	  ;;

	linux)
	  major=.`expr $current - $age`
	  versuffix="$major.$age.$revision"
	  ;;

	osf)
2962
	  major=.`expr $current - $age`
unknown's avatar
unknown committed
2963 2964 2965 2966 2967
	  versuffix=".$current.$age.$revision"
	  verstring="$current.$age.$revision"

	  # Add in all the interfaces that we are compatible with.
	  loop=$age
2968
	  while test "$loop" -ne 0; do
unknown's avatar
unknown committed
2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983
	    iface=`expr $current - $loop`
	    loop=`expr $loop - 1`
	    verstring="$verstring:${iface}.0"
	  done

	  # Make executables depend on our current version.
	  verstring="$verstring:${current}.0"
	  ;;

	sunos)
	  major=".$current"
	  versuffix=".$current.$revision"
	  ;;

	windows)
2984 2985
	  # Use '-' rather than '.', since we only want one
	  # extension on DOS 8.3 filesystems.
unknown's avatar
unknown committed
2986
	  major=`expr $current - $age`
2987
	  versuffix="-$major"
unknown's avatar
unknown committed
2988 2989 2990 2991
	  ;;

	*)
	  $echo "$modename: unknown library version type \`$version_type'" 1>&2
2992
	  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
unknown's avatar
unknown committed
2993 2994 2995 2996 2997 2998 2999
	  exit 1
	  ;;
	esac

	# Clear the version info if we defaulted, and they specified a release.
	if test -z "$vinfo" && test -n "$release"; then
	  major=
3000 3001 3002 3003
	  case $version_type in
	  darwin)
	    # we can't check for "0.0" in archive_cmds due to quoting
	    # problems, so we reset it completely
3004
	    verstring=
3005 3006 3007 3008 3009
	    ;;
	  *)
	    verstring="0.0"
	    ;;
	  esac
unknown's avatar
unknown committed
3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022
	  if test "$need_version" = no; then
	    versuffix=
	  else
	    versuffix=".0.0"
	  fi
	fi

	# Remove version info from name if versioning should be avoided
	if test "$avoid_version" = yes && test "$need_version" = no; then
	  major=
	  versuffix=
	  verstring=""
	fi
3023

unknown's avatar
unknown committed
3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036
	# Check to see if the archive will have undefined symbols.
	if test "$allow_undefined" = yes; then
	  if test "$allow_undefined_flag" = unsupported; then
	    $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
	    build_libtool_libs=no
	    build_old_libs=yes
	  fi
	else
	  # Don't allow undefined symbols.
	  allow_undefined_flag="$no_undefined_flag"
	fi
      fi

3037
      if test "$mode" != relink; then
3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055
	# Remove our outputs, but don't remove object files since they
	# may have been created when compiling PIC objects.
	removelist=
	tempremovelist=`$echo "$output_objdir/*"`
	for p in $tempremovelist; do
	  case $p in
	    *.$objext)
	       ;;
	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
	       removelist="$removelist $p"
	       ;;
	    *) ;;
	  esac
	done
	if test -n "$removelist"; then
	  $show "${rm}r $removelist"
	  $run ${rm}r $removelist
	fi
unknown's avatar
unknown committed
3056 3057 3058 3059 3060 3061 3062 3063 3064 3065
      fi

      # Now set the variables for building old libraries.
      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
	oldlibs="$oldlibs $output_objdir/$libname.$libext"

	# Transform .lo files to .o files.
	oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
      fi

3066 3067
      # Eliminate all temporary directories.
      for path in $notinst_path; do
3068 3069 3070
	lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
	deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
	dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082
      done

      if test -n "$xrpath"; then
	# If the user specified any rpath flags, then add them.
	temp_xrpath=
	for libdir in $xrpath; do
	  temp_xrpath="$temp_xrpath -R$libdir"
	  case "$finalize_rpath " in
	  *" $libdir "*) ;;
	  *) finalize_rpath="$finalize_rpath $libdir" ;;
	  esac
	done
3083
	if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107
	  dependency_libs="$temp_xrpath $dependency_libs"
	fi
      fi

      # Make sure dlfiles contains only unique files that won't be dlpreopened
      old_dlfiles="$dlfiles"
      dlfiles=
      for lib in $old_dlfiles; do
	case " $dlprefiles $dlfiles " in
	*" $lib "*) ;;
	*) dlfiles="$dlfiles $lib" ;;
	esac
      done

      # Make sure dlprefiles contains only unique files
      old_dlprefiles="$dlprefiles"
      dlprefiles=
      for lib in $old_dlprefiles; do
	case "$dlprefiles " in
	*" $lib "*) ;;
	*) dlprefiles="$dlprefiles $lib" ;;
	esac
      done

unknown's avatar
unknown committed
3108
      if test "$build_libtool_libs" = yes; then
3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120
	if test -n "$rpath"; then
	  case $host in
	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
	    # these systems don't actually have a c library (as such)!
	    ;;
	  *-*-rhapsody* | *-*-darwin1.[012])
	    # Rhapsody C library is in the System framework
	    deplibs="$deplibs -framework System"
	    ;;
	  *-*-netbsd*)
	    # Don't link with libc until the a.out ld.so is fixed.
	    ;;
3121
	  *-*-openbsd* | *-*-freebsd*)
3122
	    # Do not include libc due to us having libc/libc_r.
3123
	    test "X$arg" = "X-lc" && continue
3124
	    ;;
3125
 	  *)
3126
	    # Add libc to deplibs on all other systems if necessary.
3127
	    if test "$build_libtool_need_lc" = "yes"; then
3128 3129 3130 3131 3132 3133
	      deplibs="$deplibs -lc"
	    fi
	    ;;
	  esac
	fi

unknown's avatar
unknown committed
3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147
	# Transform deplibs into only deplibs that can be linked in shared.
	name_save=$name
	libname_save=$libname
	release_save=$release
	versuffix_save=$versuffix
	major_save=$major
	# I'm not sure if I'm treating the release correctly.  I think
	# release should show up in the -l (ie -lgmp5) so we don't want to
	# add it in twice.  Is that correct?
	release=""
	versuffix=""
	major=""
	newdeplibs=
	droppeddeps=no
3148
	case $deplibs_check_method in
unknown's avatar
unknown committed
3149 3150 3151 3152 3153
	pass_all)
	  # Don't check for shared/static.  Everything works.
	  # This might be a little naive.  We might want to check
	  # whether the library exists or not.  But this is on
	  # osf3 & osf4 and I'm not really sure... Just
3154
	  # implementing what was already the behavior.
unknown's avatar
unknown committed
3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166
	  newdeplibs=$deplibs
	  ;;
	test_compile)
	  # This code stresses the "libraries are programs" paradigm to its
	  # limits. Maybe even breaks it.  We compile a program, linking it
	  # against the deplibs as a proxy for the library.  Then we can check
	  # whether they linked in statically or dynamically with ldd.
	  $rm conftest.c
	  cat > conftest.c <<EOF
	  int main() { return 0; }
EOF
	  $rm conftest
3167 3168
	  $LTCC -o conftest conftest.c $deplibs
	  if test "$?" -eq 0 ; then
unknown's avatar
unknown committed
3169 3170 3171 3172
	    ldd_output=`ldd conftest`
	    for i in $deplibs; do
	      name="`expr $i : '-l\(.*\)'`"
	      # If $name is empty we are operating on a -L argument.
3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198
              if test "$name" != "" && test "$name" -ne "0"; then
		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
		  case " $predeps $postdeps " in
		  *" $i "*)
		    newdeplibs="$newdeplibs $i"
		    i=""
		    ;;
		  esac
	        fi
		if test -n "$i" ; then
		  libname=`eval \\$echo \"$libname_spec\"`
		  deplib_matches=`eval \\$echo \"$library_names_spec\"`
		  set dummy $deplib_matches
		  deplib_match=$2
		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
		    newdeplibs="$newdeplibs $i"
		  else
		    droppeddeps=yes
		    $echo
		    $echo "*** Warning: dynamic linker does not accept needed library $i."
		    $echo "*** I have the capability to make that library automatically link in when"
		    $echo "*** you link to this library.  But I can only do this if you have a"
		    $echo "*** shared version of the library, which I believe you do not have"
		    $echo "*** because a test_compile did reveal that the linker did not use it for"
		    $echo "*** its dynamic dependency list that programs get resolved with at runtime."
		  fi
unknown's avatar
unknown committed
3199 3200 3201 3202 3203 3204
		fi
	      else
		newdeplibs="$newdeplibs $i"
	      fi
	    done
	  else
3205 3206
	    # Error occurred in the first compile.  Let's try to salvage
	    # the situation: Compile a separate program for each library.
unknown's avatar
unknown committed
3207 3208
	    for i in $deplibs; do
	      name="`expr $i : '-l\(.*\)'`"
3209 3210
	      # If $name is empty we are operating on a -L argument.
              if test "$name" != "" && test "$name" != "0"; then
unknown's avatar
unknown committed
3211
		$rm conftest
3212
		$LTCC -o conftest conftest.c $i
unknown's avatar
unknown committed
3213
		# Did it work?
3214
		if test "$?" -eq 0 ; then
unknown's avatar
unknown committed
3215
		  ldd_output=`ldd conftest`
3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240
		  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
		    case " $predeps $postdeps " in
		    *" $i "*)
		      newdeplibs="$newdeplibs $i"
		      i=""
		      ;;
		    esac
		  fi
		  if test -n "$i" ; then
		    libname=`eval \\$echo \"$libname_spec\"`
		    deplib_matches=`eval \\$echo \"$library_names_spec\"`
		    set dummy $deplib_matches
		    deplib_match=$2
		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
		      newdeplibs="$newdeplibs $i"
		    else
		      droppeddeps=yes
		      $echo
		      $echo "*** Warning: dynamic linker does not accept needed library $i."
		      $echo "*** I have the capability to make that library automatically link in when"
		      $echo "*** you link to this library.  But I can only do this if you have a"
		      $echo "*** shared version of the library, which you do not appear to have"
		      $echo "*** because a test_compile did reveal that the linker did not use this one"
		      $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
		    fi
unknown's avatar
unknown committed
3241 3242 3243
		  fi
		else
		  droppeddeps=yes
3244 3245 3246 3247 3248
		  $echo
		  $echo "*** Warning!  Library $i is needed by this library but I was not able to"
		  $echo "***  make it link in!  You will probably need to install it or some"
		  $echo "*** library that it depends on before this library will be fully"
		  $echo "*** functional.  Installing it before continuing would be even better."
unknown's avatar
unknown committed
3249 3250 3251 3252 3253 3254 3255 3256 3257
		fi
	      else
		newdeplibs="$newdeplibs $i"
	      fi
	    done
	  fi
	  ;;
	file_magic*)
	  set dummy $deplibs_check_method
3258
	  file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
unknown's avatar
unknown committed
3259 3260 3261
	  for a_deplib in $deplibs; do
	    name="`expr $a_deplib : '-l\(.*\)'`"
	    # If $name is empty we are operating on a -L argument.
3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275
            if test "$name" != "" && test  "$name" != "0"; then
	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
		case " $predeps $postdeps " in
		*" $a_deplib "*)
		  newdeplibs="$newdeplibs $a_deplib"
		  a_deplib=""
		  ;;
		esac
	      fi
	      if test -n "$a_deplib" ; then
		libname=`eval \\$echo \"$libname_spec\"`
		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
		  for potent_lib in $potential_libs; do
unknown's avatar
unknown committed
3276 3277 3278
		      # Follow soft links.
		      if ls -lLd "$potent_lib" 2>/dev/null \
			 | grep " -> " >/dev/null; then
3279
			continue
unknown's avatar
unknown committed
3280 3281 3282 3283 3284 3285 3286 3287
		      fi
		      # The statement above tries to avoid entering an
		      # endless loop below, in case of cyclic links.
		      # We might still enter an endless loop, since a link
		      # loop can be closed while we follow links,
		      # but so what?
		      potlib="$potent_lib"
		      while test -h "$potlib" 2>/dev/null; do
3288
			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3289
			case $potliblink in
unknown's avatar
unknown committed
3290 3291 3292 3293 3294
			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
			*) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
			esac
		      done
		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3295 3296
			 | ${SED} 10q \
			 | $EGREP "$file_magic_regex" > /dev/null; then
unknown's avatar
unknown committed
3297 3298 3299 3300
			newdeplibs="$newdeplibs $a_deplib"
			a_deplib=""
			break 2
		      fi
3301 3302 3303
		  done
		done
	      fi
unknown's avatar
unknown committed
3304 3305
	      if test -n "$a_deplib" ; then
		droppeddeps=yes
3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317
		$echo
		$echo "*** Warning: linker path does not have real file for library $a_deplib."
		$echo "*** I have the capability to make that library automatically link in when"
		$echo "*** you link to this library.  But I can only do this if you have a"
		$echo "*** shared version of the library, which you do not appear to have"
		$echo "*** because I did check the linker path looking for a file starting"
		if test -z "$potlib" ; then
		  $echo "*** with $libname but no candidates were found. (...for file magic test)"
		else
		  $echo "*** with $libname and none of the candidates passed a file format test"
		  $echo "*** using a file magic. Last file checked: $potlib"
		fi
unknown's avatar
unknown committed
3318 3319 3320 3321 3322 3323 3324
	      fi
	    else
	      # Add a -L argument.
	      newdeplibs="$newdeplibs $a_deplib"
	    fi
	  done # Gone through all deplibs.
	  ;;
3325 3326 3327 3328 3329 3330 3331
	match_pattern*)
	  set dummy $deplibs_check_method
	  match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
	  for a_deplib in $deplibs; do
	    name="`expr $a_deplib : '-l\(.*\)'`"
	    # If $name is empty we are operating on a -L argument.
	    if test -n "$name" && test "$name" != "0"; then
3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353
	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
		case " $predeps $postdeps " in
		*" $a_deplib "*)
		  newdeplibs="$newdeplibs $a_deplib"
		  a_deplib=""
		  ;;
		esac
	      fi
	      if test -n "$a_deplib" ; then
		libname=`eval \\$echo \"$libname_spec\"`
		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
		  for potent_lib in $potential_libs; do
		    potlib="$potent_lib" # see symlink-check above in file_magic test
		    if eval $echo \"$potent_lib\" 2>/dev/null \
		        | ${SED} 10q \
		        | $EGREP "$match_pattern_regex" > /dev/null; then
		      newdeplibs="$newdeplibs $a_deplib"
		      a_deplib=""
		      break 2
		    fi
		  done
3354
		done
3355
	      fi
3356 3357
	      if test -n "$a_deplib" ; then
		droppeddeps=yes
3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369
		$echo
		$echo "*** Warning: linker path does not have real file for library $a_deplib."
		$echo "*** I have the capability to make that library automatically link in when"
		$echo "*** you link to this library.  But I can only do this if you have a"
		$echo "*** shared version of the library, which you do not appear to have"
		$echo "*** because I did check the linker path looking for a file starting"
		if test -z "$potlib" ; then
		  $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
		else
		  $echo "*** with $libname and none of the candidates passed a file format test"
		  $echo "*** using a regex pattern. Last file checked: $potlib"
		fi
3370 3371 3372 3373 3374 3375 3376
	      fi
	    else
	      # Add a -L argument.
	      newdeplibs="$newdeplibs $a_deplib"
	    fi
	  done # Gone through all deplibs.
	  ;;
unknown's avatar
unknown committed
3377 3378
	none | unknown | *)
	  newdeplibs=""
3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389
	  tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
	    -e 's/ -[LR][^ ]*//g'`
	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	    for i in $predeps $postdeps ; do
	      # can't use Xsed below, because $i might contain '/'
	      tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
	    done
	  fi
	  if $echo "X $tmp_deplibs" | $Xsed -e 's/[ 	]//g' \
	    | grep . >/dev/null; then
	    $echo
unknown's avatar
unknown committed
3390
	    if test "X$deplibs_check_method" = "Xnone"; then
3391
	      $echo "*** Warning: inter-library dependencies are not supported in this platform."
unknown's avatar
unknown committed
3392
	    else
3393
	      $echo "*** Warning: inter-library dependencies are not known to be supported."
unknown's avatar
unknown committed
3394
	    fi
3395
	    $echo "*** All declared inter-library dependencies are being dropped."
unknown's avatar
unknown committed
3396 3397 3398 3399 3400 3401 3402 3403 3404 3405
	    droppeddeps=yes
	  fi
	  ;;
	esac
	versuffix=$versuffix_save
	major=$major_save
	release=$release_save
	libname=$libname_save
	name=$name_save

3406 3407 3408 3409 3410 3411 3412
	case $host in
	*-*-rhapsody* | *-*-darwin1.[012])
	  # On Rhapsody replace the C library is the System framework
	  newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
	  ;;
	esac

unknown's avatar
unknown committed
3413 3414
	if test "$droppeddeps" = yes; then
	  if test "$module" = yes; then
3415 3416 3417 3418 3419
	    $echo
	    $echo "*** Warning: libtool could not satisfy all declared inter-library"
	    $echo "*** dependencies of module $libname.  Therefore, libtool will create"
	    $echo "*** a static module, that should work as long as the dlopening"
	    $echo "*** application is linked with the -dlopen flag."
unknown's avatar
unknown committed
3420
	    if test -z "$global_symbol_pipe"; then
3421 3422 3423 3424 3425
	      $echo
	      $echo "*** However, this would only work if libtool was able to extract symbol"
	      $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
	      $echo "*** not find such a program.  So, this module is probably useless."
	      $echo "*** \`nm' from GNU binutils and a full rebuild may help."
unknown's avatar
unknown committed
3426 3427 3428 3429 3430 3431 3432 3433 3434
	    fi
	    if test "$build_old_libs" = no; then
	      oldlibs="$output_objdir/$libname.$libext"
	      build_libtool_libs=module
	      build_old_libs=yes
	    else
	      build_libtool_libs=no
	    fi
	  else
3435 3436 3437 3438 3439 3440 3441 3442 3443 3444
	    $echo "*** The inter-library dependencies that have been dropped here will be"
	    $echo "*** automatically added whenever a program is linked with this library"
	    $echo "*** or is declared to -dlopen it."

	    if test "$allow_undefined" = no; then
	      $echo
	      $echo "*** Since this library must not contain undefined symbols,"
	      $echo "*** because either the platform does not support them or"
	      $echo "*** it was explicitly requested with -no-undefined,"
	      $echo "*** libtool will only create a static version of it."
3445 3446 3447 3448 3449 3450 3451 3452
	      if test "$build_old_libs" = no; then
		oldlibs="$output_objdir/$libname.$libext"
		build_libtool_libs=module
		build_old_libs=yes
	      else
		build_libtool_libs=no
	      fi
	    fi
unknown's avatar
unknown committed
3453 3454 3455 3456 3457 3458 3459 3460 3461 3462
	  fi
	fi
	# Done checking deplibs!
	deplibs=$newdeplibs
      fi

      # All the library-specific variables (install_libdir is set above).
      library_names=
      old_library=
      dlname=
3463

unknown's avatar
unknown committed
3464 3465
      # Test again, we may have decided not to build it any more
      if test "$build_libtool_libs" = yes; then
3466
	if test "$hardcode_into_libs" = yes; then
3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501
	  # Hardcode the library paths
	  hardcode_libdirs=
	  dep_rpath=
	  rpath="$finalize_rpath"
	  test "$mode" != relink && rpath="$compile_rpath$rpath"
	  for libdir in $rpath; do
	    if test -n "$hardcode_libdir_flag_spec"; then
	      if test -n "$hardcode_libdir_separator"; then
		if test -z "$hardcode_libdirs"; then
		  hardcode_libdirs="$libdir"
		else
		  # Just accumulate the unique libdirs.
		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
		    ;;
		  *)
		    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
		    ;;
		  esac
		fi
	      else
		eval flag=\"$hardcode_libdir_flag_spec\"
		dep_rpath="$dep_rpath $flag"
	      fi
	    elif test -n "$runpath_var"; then
	      case "$perm_rpath " in
	      *" $libdir "*) ;;
	      *) perm_rpath="$perm_rpath $libdir" ;;
	      esac
	    fi
	  done
	  # Substitute the hardcoded libdirs into the rpath.
	  if test -n "$hardcode_libdir_separator" &&
	     test -n "$hardcode_libdirs"; then
	    libdir="$hardcode_libdirs"
3502 3503 3504 3505 3506
	    if test -n "$hardcode_libdir_flag_spec_ld"; then
	      eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
	    else
	      eval dep_rpath=\"$hardcode_libdir_flag_spec\"
	    fi
3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524
	  fi
	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
	    # We should set the runpath_var.
	    rpath=
	    for dir in $perm_rpath; do
	      rpath="$rpath$dir:"
	    done
	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
	  fi
	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
	fi

	shlibpath="$finalize_shlibpath"
	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
	if test -n "$shlibpath"; then
	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
	fi

unknown's avatar
unknown committed
3525
	# Get the real and link names of the library.
3526
	eval shared_ext=\"$shrext\"
unknown's avatar
unknown committed
3527 3528 3529 3530 3531 3532 3533 3534 3535 3536
	eval library_names=\"$library_names_spec\"
	set dummy $library_names
	realname="$2"
	shift; shift

	if test -n "$soname_spec"; then
	  eval soname=\"$soname_spec\"
	else
	  soname="$realname"
	fi
3537 3538 3539
	if test -z "$dlname"; then
	  dlname=$soname
	fi
unknown's avatar
unknown committed
3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556

	lib="$output_objdir/$realname"
	for link
	do
	  linknames="$linknames $link"
	done

	# Use standard objects if they are pic
	test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

	# Prepare the list of exported symbols
	if test -z "$export_symbols"; then
	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
	    $show "generating symbol list for \`$libname.la'"
	    export_symbols="$output_objdir/$libname.exp"
	    $run $rm $export_symbols
	    eval cmds=\"$export_symbols_cmds\"
3557
	    save_ifs="$IFS"; IFS='~'
unknown's avatar
unknown committed
3558 3559
	    for cmd in $cmds; do
	      IFS="$save_ifs"
3560 3561 3562 3563 3564 3565 3566 3567 3568 3569
	      if len=`expr "X$cmd" : ".*"` &&
	       test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
	        $show "$cmd"
	        $run eval "$cmd" || exit $?
	        skipped_export=false
	      else
	        # The command line is too long to execute in one step.
	        $show "using reloadable object file for export list..."
	        skipped_export=:
	      fi
unknown's avatar
unknown committed
3570 3571 3572
	    done
	    IFS="$save_ifs"
	    if test -n "$export_symbols_regex"; then
3573 3574
	      $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
	      $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
unknown's avatar
unknown committed
3575 3576 3577 3578 3579 3580 3581 3582 3583 3584
	      $show "$mv \"${export_symbols}T\" \"$export_symbols\""
	      $run eval '$mv "${export_symbols}T" "$export_symbols"'
	    fi
	  fi
	fi

	if test -n "$export_symbols" && test -n "$include_expsyms"; then
	  $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
	fi

3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595
	tmp_deplibs=
	for test_deplib in $deplibs; do
		case " $convenience " in
		*" $test_deplib "*) ;;
		*) 
			tmp_deplibs="$tmp_deplibs $test_deplib"
			;;
		esac
	done
	deplibs="$tmp_deplibs" 

unknown's avatar
unknown committed
3596 3597
	if test -n "$convenience"; then
	  if test -n "$whole_archive_flag_spec"; then
3598
	    save_libobjs=$libobjs
unknown's avatar
unknown committed
3599 3600 3601 3602 3603
	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
	  else
	    gentop="$output_objdir/${outputname}x"
	    $show "${rm}r $gentop"
	    $run ${rm}r "$gentop"
3604 3605
	    $show "$mkdir $gentop"
	    $run $mkdir "$gentop"
unknown's avatar
unknown committed
3606
	    status=$?
3607
	    if test "$status" -ne 0 && test ! -d "$gentop"; then
unknown's avatar
unknown committed
3608 3609 3610 3611 3612 3613
	      exit $status
	    fi
	    generated="$generated $gentop"

	    for xlib in $convenience; do
	      # Extract the objects.
3614
	      case $xlib in
unknown's avatar
unknown committed
3615 3616 3617 3618 3619 3620 3621 3622
	      [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
	      *) xabs=`pwd`"/$xlib" ;;
	      esac
	      xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
	      xdir="$gentop/$xlib"

	      $show "${rm}r $xdir"
	      $run ${rm}r "$xdir"
3623 3624
	      $show "$mkdir $xdir"
	      $run $mkdir "$xdir"
unknown's avatar
unknown committed
3625
	      status=$?
3626
	      if test "$status" -ne 0 && test ! -d "$xdir"; then
unknown's avatar
unknown committed
3627 3628
		exit $status
	      fi
3629 3630 3631
	      # We will extract separately just the conflicting names and we will no
	      # longer touch any unique names. It is faster to leave these extract
	      # automatically by $AR in one run.
unknown's avatar
unknown committed
3632 3633
	      $show "(cd $xdir && $AR x $xabs)"
	      $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656
	      if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
		:
	      else
		$echo "$modename: warning: object name conflicts; renaming object files" 1>&2
		$echo "$modename: warning: to ensure that they will not overwrite" 1>&2
		$AR t "$xabs" | sort | uniq -cd | while read -r count name
		do
		  i=1
		  while test "$i" -le "$count"
		  do
		   # Put our $i before any first dot (extension)
		   # Never overwrite any file
		   name_to="$name"
		   while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
		   do
		     name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
		   done
		   $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
		   $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
		   i=`expr $i + 1`
		  done
		done
	      fi
unknown's avatar
unknown committed
3657

3658
	      libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
unknown's avatar
unknown committed
3659 3660 3661 3662 3663 3664
	    done
	  fi
	fi

	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
	  eval flag=\"$thread_safe_flag_spec\"
3665 3666 3667 3668 3669 3670
	  linker_flags="$linker_flags $flag"
	fi

	# Make a backup of the uninstalled library when relinking
	if test "$mode" = relink; then
	  $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
unknown's avatar
unknown committed
3671 3672 3673
	fi

	# Do each of the archive commands.
3674 3675 3676 3677 3678 3679 3680
	if test "$module" = yes && test -n "$module_cmds" ; then
	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
	    eval cmds=\"$module_expsym_cmds\"
	  else
	    eval cmds=\"$module_cmds\"
	  fi
	else
unknown's avatar
unknown committed
3681 3682 3683 3684
	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
	  eval cmds=\"$archive_expsym_cmds\"
	else
	  eval cmds=\"$archive_cmds\"
3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797
	  fi
	fi

	if test "X$skipped_export" != "X:" && len=`expr "X$cmds" : ".*"` &&
	   test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
	  :
	else
	  # The command line is too long to link in one step, link piecewise.
	  $echo "creating reloadable object files..."

	  # Save the value of $output and $libobjs because we want to
	  # use them later.  If we have whole_archive_flag_spec, we
	  # want to use save_libobjs as it was before
	  # whole_archive_flag_spec was expanded, because we can't
	  # assume the linker understands whole_archive_flag_spec.
	  # This may have to be revisited, in case too many
	  # convenience libraries get linked in and end up exceeding
	  # the spec.
	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
	    save_libobjs=$libobjs
	  fi
	  save_output=$output

	  # Clear the reloadable object creation command queue and
	  # initialize k to one.
	  test_cmds=
	  concat_cmds=
	  objlist=
	  delfiles=
	  last_robj=
	  k=1
	  output=$output_objdir/$save_output-${k}.$objext
	  # Loop over the list of objects to be linked.
	  for obj in $save_libobjs
	  do
	    eval test_cmds=\"$reload_cmds $objlist $last_robj\"
	    if test "X$objlist" = X ||
	       { len=`expr "X$test_cmds" : ".*"` &&
		 test "$len" -le "$max_cmd_len"; }; then
	      objlist="$objlist $obj"
	    else
	      # The command $test_cmds is almost too long, add a
	      # command to the queue.
	      if test "$k" -eq 1 ; then
		# The first file doesn't have a previous command to add.
		eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
	      else
		# All subsequent reloadable object files will link in
		# the last one created.
		eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
	      fi
	      last_robj=$output_objdir/$save_output-${k}.$objext
	      k=`expr $k + 1`
	      output=$output_objdir/$save_output-${k}.$objext
	      objlist=$obj
	      len=1
	    fi
	  done
	  # Handle the remaining objects by creating one last
	  # reloadable object file.  All subsequent reloadable object
	  # files will link in the last one created.
	  test -z "$concat_cmds" || concat_cmds=$concat_cmds~
	  eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"

	  if ${skipped_export-false}; then
	    $show "generating symbol list for \`$libname.la'"
	    export_symbols="$output_objdir/$libname.exp"
	    $run $rm $export_symbols
	    libobjs=$output
	    # Append the command to create the export file.
	    eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
          fi

	  # Set up a command to remove the reloadale object files
	  # after they are used.
	  i=0
	  while test "$i" -lt "$k"
	  do
	    i=`expr $i + 1`
	    delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
	  done

	  $echo "creating a temporary reloadable object file: $output"

	  # Loop through the commands generated above and execute them.
	  save_ifs="$IFS"; IFS='~'
	  for cmd in $concat_cmds; do
	    IFS="$save_ifs"
	    $show "$cmd"
	    $run eval "$cmd" || exit $?
	  done
	  IFS="$save_ifs"

	  libobjs=$output
	  # Restore the value of output.
	  output=$save_output

	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
	  fi
	  # Expand the library linking commands again to reset the
	  # value of $libobjs for piecewise linking.

	  # Do each of the archive commands.
	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
	    eval cmds=\"$archive_expsym_cmds\"
	  else
	    eval cmds=\"$archive_cmds\"
	  fi

	  # Append the command to remove the reloadable object files
	  # to the just-reset $cmds.
	  eval cmds=\"\$cmds~$rm $delfiles\"
unknown's avatar
unknown committed
3798
	fi
3799
	save_ifs="$IFS"; IFS='~'
unknown's avatar
unknown committed
3800 3801 3802 3803 3804 3805 3806
	for cmd in $cmds; do
	  IFS="$save_ifs"
	  $show "$cmd"
	  $run eval "$cmd" || exit $?
	done
	IFS="$save_ifs"

3807 3808 3809 3810 3811 3812
	# Restore the uninstalled library and exit
	if test "$mode" = relink; then
	  $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
	  exit 0
	fi

unknown's avatar
unknown committed
3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828
	# Create links to the real library.
	for linkname in $linknames; do
	  if test "$realname" != "$linkname"; then
	    $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
	    $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
	  fi
	done

	# If -module or -export-dynamic was specified, set the dlname.
	if test "$module" = yes || test "$export_dynamic" = yes; then
	  # On all known operating systems, these are identical.
	  dlname="$soname"
	fi
      fi
      ;;

3829
    obj)
unknown's avatar
unknown committed
3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853
      if test -n "$deplibs"; then
	$echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
      fi

      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
	$echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
      fi

      if test -n "$rpath"; then
	$echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
      fi

      if test -n "$xrpath"; then
	$echo "$modename: warning: \`-R' is ignored for objects" 1>&2
      fi

      if test -n "$vinfo"; then
	$echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
      fi

      if test -n "$release"; then
	$echo "$modename: warning: \`-release' is ignored for objects" 1>&2
      fi

3854
      case $output in
unknown's avatar
unknown committed
3855
      *.lo)
3856
	if test -n "$objs$old_deplibs"; then
unknown's avatar
unknown committed
3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879
	  $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
	  exit 1
	fi
	libobj="$output"
	obj=`$echo "X$output" | $Xsed -e "$lo2o"`
	;;
      *)
	libobj=
	obj="$output"
	;;
      esac

      # Delete the old objects.
      $run $rm $obj $libobj

      # Objects from convenience libraries.  This assumes
      # single-version convenience libraries.  Whenever we create
      # different ones for PIC/non-PIC, this we'll have to duplicate
      # the extraction.
      reload_conv_objs=
      gentop=
      # reload_cmds runs $LD directly, so let us get rid of
      # -Wl from whole_archive_flag_spec
3880
      wl=
unknown's avatar
unknown committed
3881 3882 3883 3884 3885 3886 3887 3888

      if test -n "$convenience"; then
	if test -n "$whole_archive_flag_spec"; then
	  eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
	else
	  gentop="$output_objdir/${obj}x"
	  $show "${rm}r $gentop"
	  $run ${rm}r "$gentop"
3889 3890
	  $show "$mkdir $gentop"
	  $run $mkdir "$gentop"
unknown's avatar
unknown committed
3891
	  status=$?
3892
	  if test "$status" -ne 0 && test ! -d "$gentop"; then
unknown's avatar
unknown committed
3893 3894 3895 3896 3897 3898
	    exit $status
	  fi
	  generated="$generated $gentop"

	  for xlib in $convenience; do
	    # Extract the objects.
3899
	    case $xlib in
unknown's avatar
unknown committed
3900 3901 3902 3903 3904 3905 3906 3907
	    [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
	    *) xabs=`pwd`"/$xlib" ;;
	    esac
	    xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
	    xdir="$gentop/$xlib"

	    $show "${rm}r $xdir"
	    $run ${rm}r "$xdir"
3908 3909
	    $show "$mkdir $xdir"
	    $run $mkdir "$xdir"
unknown's avatar
unknown committed
3910
	    status=$?
3911
	    if test "$status" -ne 0 && test ! -d "$xdir"; then
unknown's avatar
unknown committed
3912 3913
	      exit $status
	    fi
3914 3915 3916
	    # We will extract separately just the conflicting names and we will no
	    # longer touch any unique names. It is faster to leave these extract
	    # automatically by $AR in one run.
unknown's avatar
unknown committed
3917 3918
	    $show "(cd $xdir && $AR x $xabs)"
	    $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941
	    if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
	      :
	    else
	      $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
	      $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
	      $AR t "$xabs" | sort | uniq -cd | while read -r count name
	      do
		i=1
		while test "$i" -le "$count"
		do
		 # Put our $i before any first dot (extension)
		 # Never overwrite any file
		 name_to="$name"
		 while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
		 do
		   name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
		 done
		 $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
		 $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
		 i=`expr $i + 1`
		done
	      done
	    fi
unknown's avatar
unknown committed
3942

3943
	    reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
unknown's avatar
unknown committed
3944 3945 3946 3947 3948
	  done
	fi
      fi

      # Create the old-style object.
3949
      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
unknown's avatar
unknown committed
3950 3951 3952

      output="$obj"
      eval cmds=\"$reload_cmds\"
3953
      save_ifs="$IFS"; IFS='~'
unknown's avatar
unknown committed
3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978
      for cmd in $cmds; do
	IFS="$save_ifs"
	$show "$cmd"
	$run eval "$cmd" || exit $?
      done
      IFS="$save_ifs"

      # Exit if we aren't doing a library object file.
      if test -z "$libobj"; then
	if test -n "$gentop"; then
	  $show "${rm}r $gentop"
	  $run ${rm}r $gentop
	fi

	exit 0
      fi

      if test "$build_libtool_libs" != yes; then
	if test -n "$gentop"; then
	  $show "${rm}r $gentop"
	  $run ${rm}r $gentop
	fi

	# Create an invalid libtool object if no PIC, so that we don't
	# accidentally link it into a program.
3979 3980
	# $show "echo timestamp > $libobj"
	# $run eval "echo timestamp > $libobj" || exit $?
unknown's avatar
unknown committed
3981 3982 3983
	exit 0
      fi

3984
      if test -n "$pic_flag" || test "$pic_mode" != default; then
unknown's avatar
unknown committed
3985 3986 3987 3988
	# Only do commands if we really have different PIC objects.
	reload_objs="$libobjs $reload_conv_objs"
	output="$libobj"
	eval cmds=\"$reload_cmds\"
3989
	save_ifs="$IFS"; IFS='~'
unknown's avatar
unknown committed
3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005
	for cmd in $cmds; do
	  IFS="$save_ifs"
	  $show "$cmd"
	  $run eval "$cmd" || exit $?
	done
	IFS="$save_ifs"
      fi

      if test -n "$gentop"; then
	$show "${rm}r $gentop"
	$run ${rm}r $gentop
      fi

      exit 0
      ;;

4006 4007
    prog)
      case $host in
4008
	*cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
4009
      esac
unknown's avatar
unknown committed
4010 4011 4012 4013 4014 4015 4016 4017 4018
      if test -n "$vinfo"; then
	$echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
      fi

      if test -n "$release"; then
	$echo "$modename: warning: \`-release' is ignored for programs" 1>&2
      fi

      if test "$preload" = yes; then
4019
	if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
unknown's avatar
unknown committed
4020 4021
	   test "$dlopen_self_static" = unknown; then
	  $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4022
	fi
unknown's avatar
unknown committed
4023
      fi
4024 4025 4026 4027 4028 4029 4030 4031 4032

      case $host in
      *-*-rhapsody* | *-*-darwin1.[012])
	# On Rhapsody replace the C library is the System framework
	compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
	finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
	;;
      esac

4033 4034 4035 4036 4037 4038 4039 4040 4041 4042
      case $host in
      *darwin*)
        # Don't allow lazy linking, it breaks C++ global constructors
        if test "$tagname" = CXX ; then
        compile_command="$compile_command ${wl}-bind_at_load"
        finalize_command="$finalize_command ${wl}-bind_at_load"
        fi
        ;;
      esac

4043 4044 4045
      compile_command="$compile_command $compile_deplibs"
      finalize_command="$finalize_command $finalize_deplibs"

unknown's avatar
unknown committed
4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066
      if test -n "$rpath$xrpath"; then
	# If the user specified any rpath flags, then add them.
	for libdir in $rpath $xrpath; do
	  # This is the magic to use -rpath.
	  case "$finalize_rpath " in
	  *" $libdir "*) ;;
	  *) finalize_rpath="$finalize_rpath $libdir" ;;
	  esac
	done
      fi

      # Now hardcode the library paths
      rpath=
      hardcode_libdirs=
      for libdir in $compile_rpath $finalize_rpath; do
	if test -n "$hardcode_libdir_flag_spec"; then
	  if test -n "$hardcode_libdir_separator"; then
	    if test -z "$hardcode_libdirs"; then
	      hardcode_libdirs="$libdir"
	    else
	      # Just accumulate the unique libdirs.
4067
	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
unknown's avatar
unknown committed
4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084
	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
		;;
	      *)
		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
		;;
	      esac
	    fi
	  else
	    eval flag=\"$hardcode_libdir_flag_spec\"
	    rpath="$rpath $flag"
	  fi
	elif test -n "$runpath_var"; then
	  case "$perm_rpath " in
	  *" $libdir "*) ;;
	  *) perm_rpath="$perm_rpath $libdir" ;;
	  esac
	fi
4085 4086 4087 4088 4089 4090 4091 4092
	case $host in
	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
	  case :$dllsearchpath: in
	  *":$libdir:"*) ;;
	  *) dllsearchpath="$dllsearchpath:$libdir";;
	  esac
	  ;;
	esac
unknown's avatar
unknown committed
4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110
      done
      # Substitute the hardcoded libdirs into the rpath.
      if test -n "$hardcode_libdir_separator" &&
	 test -n "$hardcode_libdirs"; then
	libdir="$hardcode_libdirs"
	eval rpath=\" $hardcode_libdir_flag_spec\"
      fi
      compile_rpath="$rpath"

      rpath=
      hardcode_libdirs=
      for libdir in $finalize_rpath; do
	if test -n "$hardcode_libdir_flag_spec"; then
	  if test -n "$hardcode_libdir_separator"; then
	    if test -z "$hardcode_libdirs"; then
	      hardcode_libdirs="$libdir"
	    else
	      # Just accumulate the unique libdirs.
4111
	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
unknown's avatar
unknown committed
4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153
	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
		;;
	      *)
		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
		;;
	      esac
	    fi
	  else
	    eval flag=\"$hardcode_libdir_flag_spec\"
	    rpath="$rpath $flag"
	  fi
	elif test -n "$runpath_var"; then
	  case "$finalize_perm_rpath " in
	  *" $libdir "*) ;;
	  *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
	  esac
	fi
      done
      # Substitute the hardcoded libdirs into the rpath.
      if test -n "$hardcode_libdir_separator" &&
	 test -n "$hardcode_libdirs"; then
	libdir="$hardcode_libdirs"
	eval rpath=\" $hardcode_libdir_flag_spec\"
      fi
      finalize_rpath="$rpath"

      if test -n "$libobjs" && test "$build_old_libs" = yes; then
	# Transform all the library objects into standard objects.
	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
      fi

      dlsyms=
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
	if test -n "$NM" && test -n "$global_symbol_pipe"; then
	  dlsyms="${outputname}S.c"
	else
	  $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
	fi
      fi

      if test -n "$dlsyms"; then
4154
	case $dlsyms in
unknown's avatar
unknown committed
4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185
	"") ;;
	*.c)
	  # Discover the nlist of each of the dlfiles.
	  nlist="$output_objdir/${outputname}.nm"

	  $show "$rm $nlist ${nlist}S ${nlist}T"
	  $run $rm "$nlist" "${nlist}S" "${nlist}T"

	  # Parse the name list into a source file.
	  $show "creating $output_objdir/$dlsyms"

	  test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */

#ifdef __cplusplus
extern \"C\" {
#endif

/* Prevent the only kind of declaration conflicts we can make. */
#define lt_preloaded_symbols some_other_symbol

/* External symbol declarations for the compiler. */\
"

	  if test "$dlself" = yes; then
	    $show "generating symbol list for \`$output'"

	    test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"

	    # Add our own program objects to the symbol list.
4186
	    progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
unknown's avatar
unknown committed
4187 4188 4189 4190 4191 4192
	    for arg in $progfiles; do
	      $show "extracting global C symbols from \`$arg'"
	      $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
	    done

	    if test -n "$exclude_expsyms"; then
4193
	      $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
unknown's avatar
unknown committed
4194 4195
	      $run eval '$mv "$nlist"T "$nlist"'
	    fi
4196

unknown's avatar
unknown committed
4197
	    if test -n "$export_symbols_regex"; then
4198
	      $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
unknown's avatar
unknown committed
4199 4200 4201 4202 4203 4204 4205
	      $run eval '$mv "$nlist"T "$nlist"'
	    fi

	    # Prepare the list of exported symbols
	    if test -z "$export_symbols"; then
	      export_symbols="$output_objdir/$output.exp"
	      $run $rm $export_symbols
4206
	      $run eval "${SED} -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
unknown's avatar
unknown committed
4207
	    else
4208
	      $run eval "${SED} -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
unknown's avatar
unknown committed
4209 4210 4211 4212 4213 4214 4215
	      $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
	      $run eval 'mv "$nlist"T "$nlist"'
	    fi
	  fi

	  for arg in $dlprefiles; do
	    $show "extracting global C symbols from \`$arg'"
4216 4217
	    name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
	    $run eval '$echo ": $name " >> "$nlist"'
unknown's avatar
unknown committed
4218 4219 4220 4221 4222 4223 4224 4225
	    $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
	  done

	  if test -z "$run"; then
	    # Make sure we have at least an empty file.
	    test -f "$nlist" || : > "$nlist"

	    if test -n "$exclude_expsyms"; then
4226
	      $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
unknown's avatar
unknown committed
4227 4228 4229 4230
	      $mv "$nlist"T "$nlist"
	    fi

	    # Try sorting and uniquifying the output.
4231 4232 4233 4234 4235 4236 4237
	    if grep -v "^: " < "$nlist" |
		if sort -k 3 </dev/null >/dev/null 2>&1; then
		  sort -k 3
		else
		  sort +2
		fi |
		uniq > "$nlist"S; then
unknown's avatar
unknown committed
4238 4239 4240 4241 4242 4243 4244 4245
	      :
	    else
	      grep -v "^: " < "$nlist" > "$nlist"S
	    fi

	    if test -f "$nlist"S; then
	      eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
	    else
4246
	      $echo '/* NONE */' >> "$output_objdir/$dlsyms"
unknown's avatar
unknown committed
4247 4248 4249 4250 4251 4252 4253
	    fi

	    $echo >> "$output_objdir/$dlsyms" "\

#undef lt_preloaded_symbols

#if defined (__STDC__) && __STDC__
4254
# define lt_ptr void *
unknown's avatar
unknown committed
4255
#else
4256
# define lt_ptr char *
unknown's avatar
unknown committed
4257 4258 4259 4260 4261 4262
# define const
#endif

/* The mapping between symbol names and symbols. */
const struct {
  const char *name;
4263
  lt_ptr address;
unknown's avatar
unknown committed
4264 4265 4266 4267 4268
}
lt_preloaded_symbols[] =
{\
"

4269
	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
unknown's avatar
unknown committed
4270 4271

	    $echo >> "$output_objdir/$dlsyms" "\
4272
  {0, (lt_ptr) 0}
unknown's avatar
unknown committed
4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288
};

/* This works around a problem in FreeBSD linker */
#ifdef FREEBSD_WORKAROUND
static const void *lt_preloaded_setup() {
  return lt_preloaded_symbols;
}
#endif

#ifdef __cplusplus
}
#endif\
"
	  fi

	  pic_flag_for_symtable=
4289
	  case $host in
unknown's avatar
unknown committed
4290 4291 4292 4293 4294
	  # compiling the symbol table file with pic_flag works around
	  # a FreeBSD bug that causes programs to crash when -lm is
	  # linked before any other PIC object.  But we must not use
	  # pic_flag when linking with -static.  The problem exists in
	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
unknown's avatar
unknown committed
4295
	  *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
unknown's avatar
unknown committed
4296 4297
	    case "$compile_command " in
	    *" -static "*) ;;
4298
	    *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
unknown's avatar
unknown committed
4299 4300 4301 4302
	    esac;;
	  *-*-hpux*)
	    case "$compile_command " in
	    *" -static "*) ;;
4303
	    *) pic_flag_for_symtable=" $pic_flag";;
unknown's avatar
unknown committed
4304 4305 4306 4307
	    esac
	  esac

	  # Now compile the dynamic symbol file.
4308 4309
	  $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
	  $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
unknown's avatar
unknown committed
4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333

	  # Clean up the generated files.
	  $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
	  $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"

	  # Transform the symbol file into the correct name.
	  compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
	  finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
	  ;;
	*)
	  $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
	  exit 1
	  ;;
	esac
      else
	# We keep going just in case the user didn't refer to
	# lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
	# really was required.

	# Nullify the symbol file.
	compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
	finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
      fi

4334
      if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
unknown's avatar
unknown committed
4335 4336 4337 4338 4339 4340 4341 4342
	# Replace the output file specification.
	compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
	link_command="$compile_command$compile_rpath"

	# We have no uninstalled library dependencies, so finalize right now.
	$show "$link_command"
	$run eval "$link_command"
	status=$?
4343

unknown's avatar
unknown committed
4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356
	# Delete the generated files.
	if test -n "$dlsyms"; then
	  $show "$rm $output_objdir/${outputname}S.${objext}"
	  $run $rm "$output_objdir/${outputname}S.${objext}"
	fi

	exit $status
      fi

      if test -n "$shlibpath_var"; then
	# We should set the shlibpath_var
	rpath=
	for dir in $temp_rpath; do
4357
	  case $dir in
unknown's avatar
unknown committed
4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398
	  [\\/]* | [A-Za-z]:[\\/]*)
	    # Absolute path.
	    rpath="$rpath$dir:"
	    ;;
	  *)
	    # Relative path: add a thisdir entry.
	    rpath="$rpath\$thisdir/$dir:"
	    ;;
	  esac
	done
	temp_rpath="$rpath"
      fi

      if test -n "$compile_shlibpath$finalize_shlibpath"; then
	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
      fi
      if test -n "$finalize_shlibpath"; then
	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
      fi

      compile_var=
      finalize_var=
      if test -n "$runpath_var"; then
	if test -n "$perm_rpath"; then
	  # We should set the runpath_var.
	  rpath=
	  for dir in $perm_rpath; do
	    rpath="$rpath$dir:"
	  done
	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
	fi
	if test -n "$finalize_perm_rpath"; then
	  # We should set the runpath_var.
	  rpath=
	  for dir in $finalize_perm_rpath; do
	    rpath="$rpath$dir:"
	  done
	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
	fi
      fi

4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411
      if test "$no_install" = yes; then
	# We don't need to create a wrapper script.
	link_command="$compile_var$compile_command$compile_rpath"
	# Replace the output file specification.
	link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
	# Delete the old output file.
	$run $rm $output
	# Link the executable and exit
	$show "$link_command"
	$run eval "$link_command" || exit $?
	exit 0
      fi

unknown's avatar
unknown committed
4412 4413 4414 4415
      if test "$hardcode_action" = relink; then
	# Fast installation is not supported
	link_command="$compile_var$compile_command$compile_rpath"
	relink_command="$finalize_var$finalize_command$finalize_rpath"
4416

unknown's avatar
unknown committed
4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435
	$echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
	$echo "$modename: \`$output' will be relinked during installation" 1>&2
      else
	if test "$fast_install" != no; then
	  link_command="$finalize_var$compile_command$finalize_rpath"
	  if test "$fast_install" = yes; then
	    relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
	  else
	    # fast_install is set to needless
	    relink_command=
	  fi
	else
	  link_command="$compile_var$compile_command$compile_rpath"
	  relink_command="$finalize_var$finalize_command$finalize_rpath"
	fi
      fi

      # Replace the output file specification.
      link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4436

unknown's avatar
unknown committed
4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447
      # Delete the old output files.
      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname

      $show "$link_command"
      $run eval "$link_command" || exit $?

      # Now create the wrapper script.
      $show "creating $output"

      # Quote the relink command for shipping.
      if test -n "$relink_command"; then
4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458
	# Preserve any variables that may affect compiler behavior
	for var in $variables_saved_for_relink; do
	  if eval test -z \"\${$var+set}\"; then
	    relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
	  elif eval var_value=\$$var; test -z "$var_value"; then
	    relink_command="$var=; export $var; $relink_command"
	  else
	    var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
	    relink_command="$var=\"$var_value\"; export $var; $relink_command"
	  fi
	done
4459
	relink_command="(cd `pwd`; $relink_command)"
unknown's avatar
unknown committed
4460 4461 4462 4463 4464
	relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
      fi

      # Quote $echo for shipping.
      if test "X$echo" = "X$SHELL $0 --fallback-echo"; then
4465
	case $0 in
unknown's avatar
unknown committed
4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478
	[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $0 --fallback-echo";;
	*) qecho="$SHELL `pwd`/$0 --fallback-echo";;
	esac
	qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
      else
	qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
      fi

      # Only actually do things if our run command is non-null.
      if test -z "$run"; then
	# win32 will think the script is a binary if it has
	# a .exe suffix, so we strip it off here.
	case $output in
4479
	  *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
unknown's avatar
unknown committed
4480
	esac
4481 4482
	# test for cygwin because mv fails w/o .exe extensions
	case $host in
4483 4484 4485
	  *cygwin*)
	    exeext=.exe
	    outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
4486 4487
	  *) exeext= ;;
	esac
4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700
	case $host in
	  *cygwin* | *mingw* )
	    cwrappersource=`$echo ${objdir}/lt-${output}.c`
	    cwrapper=`$echo ${output}.exe`
	    $rm $cwrappersource $cwrapper
	    trap "$rm $cwrappersource $cwrapper; exit 1" 1 2 15

	    cat > $cwrappersource <<EOF

/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
   Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP

   The $output program cannot be directly executed until all the libtool
   libraries that it depends on are installed.
   
   This wrapper executable should never be moved out of the build directory.
   If it is, it will not operate correctly.

   Currently, it simply execs the wrapper *script* "/bin/sh $output",
   but could eventually absorb all of the scripts functionality and
   exec $objdir/$outputname directly.
*/
EOF
	    cat >> $cwrappersource<<"EOF"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <malloc.h>
#include <stdarg.h>
#include <assert.h>

#if defined(PATH_MAX)
# define LT_PATHMAX PATH_MAX
#elif defined(MAXPATHLEN)
# define LT_PATHMAX MAXPATHLEN
#else
# define LT_PATHMAX 1024
#endif

#ifndef DIR_SEPARATOR
#define DIR_SEPARATOR '/'
#endif

#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
  defined (__OS2__)
#define HAVE_DOS_BASED_FILE_SYSTEM
#ifndef DIR_SEPARATOR_2 
#define DIR_SEPARATOR_2 '\\'
#endif
#endif

#ifndef DIR_SEPARATOR_2
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
#else /* DIR_SEPARATOR_2 */
# define IS_DIR_SEPARATOR(ch) \
        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
#endif /* DIR_SEPARATOR_2 */

#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
#define XFREE(stale) do { \
  if (stale) { free ((void *) stale); stale = 0; } \
} while (0)

const char *program_name = NULL;

void * xmalloc (size_t num);
char * xstrdup (const char *string);
char * basename (const char *name);
char * fnqualify(const char *path);
char * strendzap(char *str, const char *pat);
void lt_fatal (const char *message, ...);

int
main (int argc, char *argv[])
{
  char **newargz;
  int i;
  
  program_name = (char *) xstrdup ((char *) basename (argv[0]));
  newargz = XMALLOC(char *, argc+2);
EOF

	    cat >> $cwrappersource <<EOF
  newargz[0] = "$SHELL";
EOF

	    cat >> $cwrappersource <<"EOF"
  newargz[1] = fnqualify(argv[0]);
  /* we know the script has the same name, without the .exe */
  /* so make sure newargz[1] doesn't end in .exe */
  strendzap(newargz[1],".exe"); 
  for (i = 1; i < argc; i++)
    newargz[i+1] = xstrdup(argv[i]);
  newargz[argc+1] = NULL;
EOF

	    cat >> $cwrappersource <<EOF
  execv("$SHELL",newargz);
EOF

	    cat >> $cwrappersource <<"EOF"
}

void *
xmalloc (size_t num)
{
  void * p = (void *) malloc (num);
  if (!p)
    lt_fatal ("Memory exhausted");

  return p;
}

char * 
xstrdup (const char *string)
{
  return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
;
}

char *
basename (const char *name)
{
  const char *base;

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
  /* Skip over the disk name in MSDOS pathnames. */
  if (isalpha (name[0]) && name[1] == ':') 
    name += 2;
#endif

  for (base = name; *name; name++)
    if (IS_DIR_SEPARATOR (*name))
      base = name + 1;
  return (char *) base;
}

char * 
fnqualify(const char *path)
{
  size_t size;
  char *p;
  char tmp[LT_PATHMAX + 1];

  assert(path != NULL);

  /* Is it qualified already? */
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
  if (isalpha (path[0]) && path[1] == ':')
    return xstrdup (path);
#endif
  if (IS_DIR_SEPARATOR (path[0]))
    return xstrdup (path);

  /* prepend the current directory */
  /* doesn't handle '~' */
  if (getcwd (tmp, LT_PATHMAX) == NULL)
    lt_fatal ("getcwd failed");
  size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '\0' */
  p = XMALLOC(char, size);
  sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path);
  return p;
}

char *
strendzap(char *str, const char *pat) 
{
  size_t len, patlen;

  assert(str != NULL);
  assert(pat != NULL);

  len = strlen(str);
  patlen = strlen(pat);

  if (patlen <= len)
  {
    str += len - patlen;
    if (strcmp(str, pat) == 0)
      *str = '\0';
  }
  return str;
}

static void
lt_error_core (int exit_status, const char * mode, 
          const char * message, va_list ap)
{
  fprintf (stderr, "%s: %s: ", program_name, mode);
  vfprintf (stderr, message, ap);
  fprintf (stderr, ".\n");

  if (exit_status >= 0)
    exit (exit_status);
}

void
lt_fatal (const char *message, ...)
{
  va_list ap;
  va_start (ap, message);
  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
  va_end (ap);
}
EOF
	  # we should really use a build-platform specific compiler
	  # here, but OTOH, the wrappers (shell script and this C one)
	  # are only useful if you want to execute the "real" binary.
	  # Since the "real" binary is built for $host, then this
	  # wrapper might as well be built for $host, too.
	  $run $LTCC -s -o $cwrapper $cwrappersource
	  ;;
	esac
unknown's avatar
unknown committed
4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717
	$rm $output
	trap "$rm $output; exit 1" 1 2 15

	$echo > $output "\
#! $SHELL

# $output - temporary wrapper script for $objdir/$outputname
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
#
# The $output program cannot be directly executed until all the libtool
# libraries that it depends on are installed.
#
# This wrapper script should never be moved out of the build directory.
# If it is, it will not operate correctly.

# Sed substitution that helps us do robust quoting.  It backslashifies
# metacharacters that are still active within double-quoted strings.
4718
Xsed='${SED} -e 1s/^X//'
unknown's avatar
unknown committed
4719 4720 4721 4722
sed_quote_subst='$sed_quote_subst'

# The HP-UX ksh and POSIX shell print the target directory to stdout
# if CDPATH is set.
unknown's avatar
unknown committed
4723
if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
unknown's avatar
unknown committed
4724 4725 4726 4727 4728 4729

relink_command=\"$relink_command\"

# This environment variable determines our operation mode.
if test \"\$libtool_install_magic\" = \"$magic\"; then
  # install mode needs the following variable:
4730
  notinst_deplibs='$notinst_deplibs'
unknown's avatar
unknown committed
4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755
else
  # When we are sourced in execute mode, \$file and \$echo are already set.
  if test \"\$libtool_execute_magic\" != \"$magic\"; then
    echo=\"$qecho\"
    file=\"\$0\"
    # Make sure echo works.
    if test \"X\$1\" = X--no-reexec; then
      # Discard the --no-reexec flag, and continue.
      shift
    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
      # Yippee, \$echo works!
      :
    else
      # Restart under the correct shell, and then maybe \$echo will work.
      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
    fi
  fi\
"
	$echo >> $output "\

  # Find the directory that this script lives in.
  thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
  test \"x\$thisdir\" = \"x\$file\" && thisdir=.

  # Follow symbolic links until we get to the real thisdir.
4756
  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
unknown's avatar
unknown committed
4757 4758 4759 4760 4761 4762
  while test -n \"\$file\"; do
    destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`

    # If there was a directory component, then change thisdir.
    if test \"x\$destdir\" != \"x\$file\"; then
      case \"\$destdir\" in
4763
      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
unknown's avatar
unknown committed
4764 4765 4766 4767 4768
      *) thisdir=\"\$thisdir/\$destdir\" ;;
      esac
    fi

    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
4769
    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
unknown's avatar
unknown committed
4770 4771 4772 4773 4774 4775 4776 4777
  done

  # Try to get the absolute directory name.
  absdir=\`cd \"\$thisdir\" && pwd\`
  test -n \"\$absdir\" && thisdir=\"\$absdir\"
"

	if test "$fast_install" = yes; then
4778
	  $echo >> $output "\
4779
  program=lt-'$outputname'$exeext
unknown's avatar
unknown committed
4780
  progdir=\"\$thisdir/$objdir\"
4781

unknown's avatar
unknown committed
4782
  if test ! -f \"\$progdir/\$program\" || \\
4783
     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
unknown's avatar
unknown committed
4784 4785 4786 4787 4788 4789 4790 4791 4792 4793
       test \"X\$file\" != \"X\$progdir/\$program\"; }; then

    file=\"\$\$-\$program\"

    if test ! -d \"\$progdir\"; then
      $mkdir \"\$progdir\"
    else
      $rm \"\$progdir/\$file\"
    fi"

4794
	  $echo >> $output "\
unknown's avatar
unknown committed
4795 4796 4797

    # relink executable if necessary
    if test -n \"\$relink_command\"; then
4798
      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
unknown's avatar
unknown committed
4799
      else
4800
	$echo \"\$relink_command_output\" >&2
unknown's avatar
unknown committed
4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811
	$rm \"\$progdir/\$file\"
	exit 1
      fi
    fi

    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
    { $rm \"\$progdir/\$program\";
      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
    $rm \"\$progdir/\$file\"
  fi"
	else
4812
	  $echo >> $output "\
unknown's avatar
unknown committed
4813
  program='$outputname'
unknown's avatar
unknown committed
4814 4815 4816 4817
  progdir=\"\$thisdir/$objdir\"
"
	fi

4818
	$echo >> $output "\
unknown's avatar
unknown committed
4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848

  if test -f \"\$progdir/\$program\"; then"

	# Export our shlibpath_var if we have one.
	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
	  $echo >> $output "\
    # Add our own library path to $shlibpath_var
    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"

    # Some systems cannot cope with colon-terminated $shlibpath_var
    # The second colon is a workaround for a bug in BeOS R4 sed
    $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`

    export $shlibpath_var
"
	fi

	# fixup the dll searchpath if we need to.
	if test -n "$dllsearchpath"; then
	  $echo >> $output "\
    # Add the dll search path components to the executable PATH
    PATH=$dllsearchpath:\$PATH
"
	fi

	$echo >> $output "\
    if test \"\$libtool_execute_magic\" != \"$magic\"; then
      # Run the actual program with our arguments.
"
	case $host in
unknown's avatar
unknown committed
4849 4850
	# Backslashes separate directories on plain windows
	*-*-mingw | *-*-os2*)
unknown's avatar
unknown committed
4851 4852 4853 4854
	  $echo >> $output "\
      exec \$progdir\\\\\$program \${1+\"\$@\"}
"
	  ;;
unknown's avatar
unknown committed
4855

unknown's avatar
unknown committed
4856 4857
	*)
	  $echo >> $output "\
4858
      exec \$progdir/\$program \${1+\"\$@\"}
unknown's avatar
unknown committed
4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869
"
	  ;;
	esac
	$echo >> $output "\
      \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
      exit 1
    fi
  else
    # The program doesn't exist.
    \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
    \$echo \"This script is just a wrapper for \$program.\" 1>&2
4870
    $echo \"See the $PACKAGE documentation for more information.\" 1>&2
unknown's avatar
unknown committed
4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892
    exit 1
  fi
fi\
"
	chmod +x $output
      fi
      exit 0
      ;;
    esac

    # See if we need to build an old-fashioned archive.
    for oldlib in $oldlibs; do

      if test "$build_libtool_libs" = convenience; then
	oldobjs="$libobjs_save"
	addlibs="$convenience"
	build_libtool_libs=no
      else
	if test "$build_libtool_libs" = module; then
	  oldobjs="$libobjs_save"
	  build_libtool_libs=no
	else
4893
	  oldobjs="$old_deplibs $non_pic_objects"
unknown's avatar
unknown committed
4894 4895 4896 4897 4898 4899 4900 4901
	fi
	addlibs="$old_convenience"
      fi

      if test -n "$addlibs"; then
	gentop="$output_objdir/${outputname}x"
	$show "${rm}r $gentop"
	$run ${rm}r "$gentop"
4902 4903
	$show "$mkdir $gentop"
	$run $mkdir "$gentop"
unknown's avatar
unknown committed
4904
	status=$?
4905
	if test "$status" -ne 0 && test ! -d "$gentop"; then
unknown's avatar
unknown committed
4906 4907 4908
	  exit $status
	fi
	generated="$generated $gentop"
4909

unknown's avatar
unknown committed
4910 4911 4912
	# Add in members from convenience archives.
	for xlib in $addlibs; do
	  # Extract the objects.
4913
	  case $xlib in
unknown's avatar
unknown committed
4914 4915 4916 4917 4918 4919 4920 4921
	  [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
	  *) xabs=`pwd`"/$xlib" ;;
	  esac
	  xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
	  xdir="$gentop/$xlib"

	  $show "${rm}r $xdir"
	  $run ${rm}r "$xdir"
4922 4923
	  $show "$mkdir $xdir"
	  $run $mkdir "$xdir"
unknown's avatar
unknown committed
4924
	  status=$?
4925
	  if test "$status" -ne 0 && test ! -d "$xdir"; then
unknown's avatar
unknown committed
4926 4927
	    exit $status
	  fi
4928 4929 4930
	  # We will extract separately just the conflicting names and we will no
	  # longer touch any unique names. It is faster to leave these extract
	  # automatically by $AR in one run.
unknown's avatar
unknown committed
4931 4932
	  $show "(cd $xdir && $AR x $xabs)"
	  $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955
	  if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
	    :
	  else
	    $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
	    $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
	    $AR t "$xabs" | sort | uniq -cd | while read -r count name
	    do
	      i=1
	      while test "$i" -le "$count"
	      do
	       # Put our $i before any first dot (extension)
	       # Never overwrite any file
	       name_to="$name"
	       while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
	       do
		 name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
	       done
	       $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
	       $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
	       i=`expr $i + 1`
	      done
	    done
	  fi
unknown's avatar
unknown committed
4956 4957 4958 4959 4960 4961 4962 4963 4964

	  oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP`
	done
      fi

      # Do each command in the archive commands.
      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
	eval cmds=\"$old_archive_from_new_cmds\"
      else
4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004
	eval cmds=\"$old_archive_cmds\"

	if len=`expr "X$cmds" : ".*"` &&
	     test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
	  :
	else
	  # the command line is too long to link in one step, link in parts
	  $echo "using piecewise archive linking..."
	  save_RANLIB=$RANLIB
	  RANLIB=:
	  objlist=
	  concat_cmds=
	  save_oldobjs=$oldobjs
	  # GNU ar 2.10+ was changed to match POSIX; thus no paths are
	  # encoded into archives.  This makes 'ar r' malfunction in
	  # this piecewise linking case whenever conflicting object
	  # names appear in distinct ar calls; check, warn and compensate.
	    if (for obj in $save_oldobjs
	    do
	      $echo "X$obj" | $Xsed -e 's%^.*/%%'
	    done | sort | sort -uc >/dev/null 2>&1); then
	    :
	  else
	    $echo "$modename: warning: object name conflicts; overriding AR_FLAGS to 'cq'" 1>&2
	    $echo "$modename: warning: to ensure that POSIX-compatible ar will work" 1>&2
	    AR_FLAGS=cq
	  fi
	  # Is there a better way of finding the last object in the list?
	  for obj in $save_oldobjs
	  do
	    last_oldobj=$obj
	  done  
	  for obj in $save_oldobjs
	  do
	    oldobjs="$objlist $obj"
	    objlist="$objlist $obj"
	    eval test_cmds=\"$old_archive_cmds\"
	    if len=`expr "X$test_cmds" : ".*"` &&
	       test "$len" -le "$max_cmd_len"; then
	      :
unknown's avatar
unknown committed
5005
	    else
5006 5007 5008 5009 5010 5011 5012 5013
	      # the above command should be used before it gets too long
	      oldobjs=$objlist
	      if test "$obj" = "$last_oldobj" ; then
	        RANLIB=$save_RANLIB
	      fi  
	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
	      eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
	      objlist=
unknown's avatar
unknown committed
5014
	    fi
5015 5016 5017 5018 5019 5020 5021
	  done
	  RANLIB=$save_RANLIB
	  oldobjs=$objlist
	  if test "X$oldobjs" = "X" ; then
	    eval cmds=\"\$concat_cmds\"
	  else
	    eval cmds=\"\$concat_cmds~$old_archive_cmds\"
unknown's avatar
unknown committed
5022
	  fi
5023
	fi
unknown's avatar
unknown committed
5024
      fi
5025
      save_ifs="$IFS"; IFS='~'
unknown's avatar
unknown committed
5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039
      for cmd in $cmds; do
	IFS="$save_ifs"
	$show "$cmd"
	$run eval "$cmd" || exit $?
      done
      IFS="$save_ifs"
    done

    if test -n "$generated"; then
      $show "${rm}r$generated"
      $run ${rm}r$generated
    fi

    # Now create the libtool archive.
5040
    case $output in
unknown's avatar
unknown committed
5041 5042 5043 5044 5045
    *.la)
      old_library=
      test "$build_old_libs" = yes && old_library="$libname.$libext"
      $show "creating $output"

5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057
      # Preserve any variables that may affect compiler behavior
      for var in $variables_saved_for_relink; do
	if eval test -z \"\${$var+set}\"; then
	  relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
	elif eval var_value=\$$var; test -z "$var_value"; then
	  relink_command="$var=; export $var; $relink_command"
	else
	  var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
	  relink_command="$var=\"$var_value\"; export $var; $relink_command"
	fi
      done
      # Quote the link command for shipping.
5058
      relink_command="(cd `pwd`; $SHELL $0 --mode=relink $libtool_args @inst_prefix_dir@)"
5059
      relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
unknown's avatar
unknown committed
5060 5061 5062 5063 5064 5065 5066 5067 5068

      # Only create the output if not a dry run.
      if test -z "$run"; then
	for installed in no yes; do
	  if test "$installed" = yes; then
	    if test -z "$install_libdir"; then
	      break
	    fi
	    output="$output_objdir/$outputname"i
5069 5070 5071 5072 5073 5074
	    # Replace all uninstalled libtool libraries with the installed ones
	    newdependency_libs=
	    for deplib in $dependency_libs; do
	      case $deplib in
	      *.la)
		name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
5075
		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088
		if test -z "$libdir"; then
		  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
		  exit 1
		fi
		newdependency_libs="$newdependency_libs $libdir/$name"
		;;
	      *) newdependency_libs="$newdependency_libs $deplib" ;;
	      esac
	    done
	    dependency_libs="$newdependency_libs"
	    newdlfiles=
	    for lib in $dlfiles; do
	      name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5089
	      eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5090 5091 5092 5093 5094 5095 5096 5097 5098 5099
	      if test -z "$libdir"; then
		$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
		exit 1
	      fi
	      newdlfiles="$newdlfiles $libdir/$name"
	    done
	    dlfiles="$newdlfiles"
	    newdlprefiles=
	    for lib in $dlprefiles; do
	      name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5100
	      eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5101 5102 5103 5104 5105 5106 5107
	      if test -z "$libdir"; then
		$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
		exit 1
	      fi
	      newdlprefiles="$newdlprefiles $libdir/$name"
	    done
	    dlprefiles="$newdlprefiles"
unknown's avatar
unknown committed
5108 5109
	  fi
	  $rm $output
5110 5111 5112
	  # place dlname in correct position for cygwin
	  tdlname=$dlname
	  case $host,$output,$installed,$module,$dlname in
5113
	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
5114
	  esac
unknown's avatar
unknown committed
5115 5116 5117 5118 5119 5120 5121 5122
	  $echo > $output "\
# $outputname - a libtool library file
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
#
# Please DO NOT delete this file!
# It is necessary for linking the library.

# The name that we can dlopen(3).
5123
dlname='$tdlname'
unknown's avatar
unknown committed
5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141

# Names of this library.
library_names='$library_names'

# The name of the static archive.
old_library='$old_library'

# Libraries that this one depends upon.
dependency_libs='$dependency_libs'

# Version information for $libname.
current=$current
age=$age
revision=$revision

# Is this an already installed library?
installed=$installed

5142 5143 5144
# Should we warn about portability when linking against -modules?
shouldnotlink=$module

5145 5146 5147 5148
# Files to dlopen/dlpreopen
dlopen='$dlfiles'
dlpreopen='$dlprefiles'

unknown's avatar
unknown committed
5149
# Directory that this library needs to be installed in:
5150
libdir='$install_libdir'"
5151
	  if test "$installed" = no && test "$need_relink" = yes; then
5152 5153 5154
	    $echo >> $output "\
relink_command=\"$relink_command\""
	  fi
unknown's avatar
unknown committed
5155 5156 5157 5158 5159 5160
	done
      fi

      # Do a symbolic link so that the libtool archive can be found in
      # LD_LIBRARY_PATH before the program is installed.
      $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5161
      $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
unknown's avatar
unknown committed
5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172
      ;;
    esac
    exit 0
    ;;

  # libtool install mode
  install)
    modename="$modename: install"

    # There may be an optional sh(1) argument at the beginning of
    # install_prog (especially on Windows NT).
5173 5174 5175
    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
       # Allow the use of GNU shtool's install command.
       $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
unknown's avatar
unknown committed
5176 5177
      # Aesthetically quote it.
      arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5178
      case $arg in
unknown's avatar
unknown committed
5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)
	arg="\"$arg\""
	;;
      esac
      install_prog="$arg "
      arg="$1"
      shift
    else
      install_prog=
      arg="$nonopt"
    fi

    # The real first argument should be the name of the installation program.
    # Aesthetically quote it.
    arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5194
    case $arg in
unknown's avatar
unknown committed
5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216
    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)
      arg="\"$arg\""
      ;;
    esac
    install_prog="$install_prog$arg"

    # We need to accept at least all the BSD install flags.
    dest=
    files=
    opts=
    prev=
    install_type=
    isdir=no
    stripme=
    for arg
    do
      if test -n "$dest"; then
	files="$files $dest"
	dest="$arg"
	continue
      fi

5217
      case $arg in
unknown's avatar
unknown committed
5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241
      -d) isdir=yes ;;
      -f) prev="-f" ;;
      -g) prev="-g" ;;
      -m) prev="-m" ;;
      -o) prev="-o" ;;
      -s)
	stripme=" -s"
	continue
	;;
      -*) ;;

      *)
	# If the previous option needed an argument, then skip it.
	if test -n "$prev"; then
	  prev=
	else
	  dest="$arg"
	  continue
	fi
	;;
      esac

      # Aesthetically quote the argument.
      arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5242
      case $arg in
unknown's avatar
unknown committed
5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)
	arg="\"$arg\""
	;;
      esac
      install_prog="$install_prog $arg"
    done

    if test -z "$install_prog"; then
      $echo "$modename: you must specify an install program" 1>&2
      $echo "$help" 1>&2
      exit 1
    fi

    if test -n "$prev"; then
      $echo "$modename: the \`$prev' option requires an argument" 1>&2
      $echo "$help" 1>&2
      exit 1
    fi

    if test -z "$files"; then
      if test -z "$dest"; then
	$echo "$modename: no file or destination specified" 1>&2
      else
	$echo "$modename: you must specify a destination" 1>&2
      fi
      $echo "$help" 1>&2
      exit 1
    fi

    # Strip any trailing slash from the destination.
    dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`

    # Check to see that the destination is a directory.
    test -d "$dest" && isdir=yes
    if test "$isdir" = yes; then
      destdir="$dest"
      destname=
    else
      destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
      test "X$destdir" = "X$dest" && destdir=.
      destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`

      # Not a directory, so check to see that there is only one file specified.
      set dummy $files
5287
      if test "$#" -gt 2; then
unknown's avatar
unknown committed
5288 5289 5290 5291 5292
	$echo "$modename: \`$dest' is not a directory" 1>&2
	$echo "$help" 1>&2
	exit 1
      fi
    fi
5293
    case $destdir in
unknown's avatar
unknown committed
5294 5295 5296
    [\\/]* | [A-Za-z]:[\\/]*) ;;
    *)
      for file in $files; do
5297
	case $file in
unknown's avatar
unknown committed
5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318
	*.lo) ;;
	*)
	  $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
	  $echo "$help" 1>&2
	  exit 1
	  ;;
	esac
      done
      ;;
    esac

    # This variable tells wrapper scripts just to set variables rather
    # than running their programs.
    libtool_install_magic="$magic"

    staticlibs=
    future_libdirs=
    current_libdirs=
    for file in $files; do

      # Do each installation.
5319 5320
      case $file in
      *.$libext)
unknown's avatar
unknown committed
5321 5322 5323 5324 5325 5326
	# Do the static libraries later.
	staticlibs="$staticlibs $file"
	;;

      *.la)
	# Check to see that this really is a libtool archive.
5327
	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
unknown's avatar
unknown committed
5328 5329 5330 5331 5332 5333 5334 5335
	else
	  $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
	  $echo "$help" 1>&2
	  exit 1
	fi

	library_names=
	old_library=
5336
	relink_command=
unknown's avatar
unknown committed
5337
	# If there is no directory component, then add one.
5338
	case $file in
unknown's avatar
unknown committed
5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356
	*/* | *\\*) . $file ;;
	*) . ./$file ;;
	esac

	# Add the libdir to current_libdirs if it is the destination.
	if test "X$destdir" = "X$libdir"; then
	  case "$current_libdirs " in
	  *" $libdir "*) ;;
	  *) current_libdirs="$current_libdirs $libdir" ;;
	  esac
	else
	  # Note the libdir as a future libdir.
	  case "$future_libdirs " in
	  *" $libdir "*) ;;
	  *) future_libdirs="$future_libdirs $libdir" ;;
	  esac
	fi

5357
	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
unknown's avatar
unknown committed
5358 5359 5360
	test "X$dir" = "X$file/" && dir=
	dir="$dir$objdir"

5361
	if test -n "$relink_command"; then
5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382
	  # Determine the prefix the user has applied to our future dir.
	  inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`

	  # Don't allow the user to place us outside of our expected
	  # location b/c this prevents finding dependent libraries that
	  # are installed to the same prefix.
	  # At present, this check doesn't affect windows .dll's that
	  # are installed into $libdir/../bin (currently, that works fine)
	  # but it's something to keep an eye on.
	  if test "$inst_prefix_dir" = "$destdir"; then
	    $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
	    exit 1
	  fi

	  if test -n "$inst_prefix_dir"; then
	    # Stick the inst_prefix_dir data into the link command.
	    relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
	  else
	    relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
	  fi

5383 5384 5385 5386 5387
	  $echo "$modename: warning: relinking \`$file'" 1>&2
	  $show "$relink_command"
	  if $run eval "$relink_command"; then :
	  else
	    $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5388
	    exit 1
5389 5390 5391
	  fi
	fi

unknown's avatar
unknown committed
5392 5393 5394 5395 5396 5397 5398
	# See the names of the shared library.
	set dummy $library_names
	if test -n "$2"; then
	  realname="$2"
	  shift
	  shift

5399 5400 5401
	  srcname="$realname"
	  test -n "$relink_command" && srcname="$realname"T

unknown's avatar
unknown committed
5402
	  # Install the shared library and build the symlinks.
5403 5404 5405 5406 5407 5408
	  $show "$install_prog $dir/$srcname $destdir/$realname"
	  $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
	  if test -n "$stripme" && test -n "$striplib"; then
	    $show "$striplib $destdir/$realname"
	    $run eval "$striplib $destdir/$realname" || exit $?
	  fi
unknown's avatar
unknown committed
5409

5410
	  if test "$#" -gt 0; then
unknown's avatar
unknown committed
5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423
	    # Delete the old symlinks, and create new ones.
	    for linkname
	    do
	      if test "$linkname" != "$realname"; then
		$show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
		$run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
	      fi
	    done
	  fi

	  # Do each command in the postinstall commands.
	  lib="$destdir/$realname"
	  eval cmds=\"$postinstall_cmds\"
5424
	  save_ifs="$IFS"; IFS='~'
unknown's avatar
unknown committed
5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454
	  for cmd in $cmds; do
	    IFS="$save_ifs"
	    $show "$cmd"
	    $run eval "$cmd" || exit $?
	  done
	  IFS="$save_ifs"
	fi

	# Install the pseudo-library for information purposes.
	name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
	instname="$dir/$name"i
	$show "$install_prog $instname $destdir/$name"
	$run eval "$install_prog $instname $destdir/$name" || exit $?

	# Maybe install the static library, too.
	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
	;;

      *.lo)
	# Install (i.e. copy) a libtool object.

	# Figure out destination file name, if it wasn't already specified.
	if test -n "$destname"; then
	  destfile="$destdir/$destname"
	else
	  destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
	  destfile="$destdir/$destfile"
	fi

	# Deduce the name of the destination old-style object file.
5455
	case $destfile in
unknown's avatar
unknown committed
5456 5457 5458
	*.lo)
	  staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
	  ;;
5459
	*.$objext)
unknown's avatar
unknown committed
5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495
	  staticdest="$destfile"
	  destfile=
	  ;;
	*)
	  $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
	  $echo "$help" 1>&2
	  exit 1
	  ;;
	esac

	# Install the libtool object if requested.
	if test -n "$destfile"; then
	  $show "$install_prog $file $destfile"
	  $run eval "$install_prog $file $destfile" || exit $?
	fi

	# Install the old object if enabled.
	if test "$build_old_libs" = yes; then
	  # Deduce the name of the old-style object file.
	  staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`

	  $show "$install_prog $staticobj $staticdest"
	  $run eval "$install_prog \$staticobj \$staticdest" || exit $?
	fi
	exit 0
	;;

      *)
	# Figure out destination file name, if it wasn't already specified.
	if test -n "$destname"; then
	  destfile="$destdir/$destname"
	else
	  destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
	  destfile="$destdir/$destfile"
	fi

5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508
	# If the file is missing, and there is a .exe on the end, strip it
	# because it is most likely a libtool script we actually want to
	# install
	stripped_ext=""
	case $file in
	  *.exe)
	    if test ! -f "$file"; then
	      file=`$echo $file|${SED} 's,.exe$,,'`
	      stripped_ext=".exe"
	    fi
	    ;;
	esac

unknown's avatar
unknown committed
5509
	# Do a test to see if this is really a libtool program.
5510 5511 5512 5513 5514 5515 5516 5517 5518
	case $host in
	*cygwin*|*mingw*)
	    wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
	    ;;
	*)
	    wrapper=$file
	    ;;
	esac
	if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
5519
	  notinst_deplibs=
unknown's avatar
unknown committed
5520 5521
	  relink_command=

5522 5523 5524 5525 5526 5527 5528
	  # To insure that "foo" is sourced, and not "foo.exe",
	  # finese the cygwin/MSYS system by explicitly sourcing "foo."
	  # which disallows the automatic-append-.exe behavior.
	  case $build in
	  *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
	  *) wrapperdot=${wrapper} ;;
	  esac
unknown's avatar
unknown committed
5529
	  # If there is no directory component, then add one.
5530
	  case $file in
5531 5532
	  */* | *\\*) . ${wrapperdot} ;;
	  *) . ./${wrapperdot} ;;
unknown's avatar
unknown committed
5533 5534 5535
	  esac

	  # Check the variables that should have been set.
5536
	  if test -z "$notinst_deplibs"; then
5537
	    $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
unknown's avatar
unknown committed
5538 5539 5540 5541
	    exit 1
	  fi

	  finalize=yes
5542
	  for lib in $notinst_deplibs; do
unknown's avatar
unknown committed
5543 5544 5545 5546
	    # Check to see that each library is installed.
	    libdir=
	    if test -f "$lib"; then
	      # If there is no directory component, then add one.
5547
	      case $lib in
unknown's avatar
unknown committed
5548 5549 5550 5551
	      */* | *\\*) . $lib ;;
	      *) . ./$lib ;;
	      esac
	    fi
5552
	    libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
unknown's avatar
unknown committed
5553 5554 5555 5556 5557 5558
	    if test -n "$libdir" && test ! -f "$libfile"; then
	      $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
	      finalize=no
	    fi
	  done

5559
	  relink_command=
5560 5561 5562 5563 5564 5565 5566
	  # To insure that "foo" is sourced, and not "foo.exe",
	  # finese the cygwin/MSYS system by explicitly sourcing "foo."
	  # which disallows the automatic-append-.exe behavior.
	  case $build in
	  *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
	  *) wrapperdot=${wrapper} ;;
	  esac
5567 5568
	  # If there is no directory component, then add one.
	  case $file in
5569 5570
	  */* | *\\*) . ${wrapperdot} ;;
	  *) . ./${wrapperdot} ;;
5571 5572
	  esac

unknown's avatar
unknown committed
5573 5574 5575 5576 5577
	  outputname=
	  if test "$fast_install" = no && test -n "$relink_command"; then
	    if test "$finalize" = yes && test -z "$run"; then
	      tmpdir="/tmp"
	      test -n "$TMPDIR" && tmpdir="$TMPDIR"
5578 5579
              tmpdir=`mktemp -d $tmpdir/libtool-XXXXXX 2> /dev/null` ||
                tmpdir="$tmpdir/libtool-$$"
unknown's avatar
unknown committed
5580 5581 5582 5583 5584
	      if $mkdir -p "$tmpdir" && chmod 700 "$tmpdir"; then :
	      else
		$echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
		continue
	      fi
5585
	      file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
unknown's avatar
unknown committed
5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602
	      outputname="$tmpdir/$file"
	      # Replace the output file specification.
	      relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`

	      $show "$relink_command"
	      if $run eval "$relink_command"; then :
	      else
		$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
		${rm}r "$tmpdir"
		continue
	      fi
	      file="$outputname"
	    else
	      $echo "$modename: warning: cannot relink \`$file'" 1>&2
	    fi
	  else
	    # Install the binary that we compiled earlier.
5603
	    file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
unknown's avatar
unknown committed
5604 5605 5606
	  fi
	fi

5607 5608 5609
	# remove .exe since cygwin /usr/bin/install will append another
	# one anyways
	case $install_prog,$host in
5610
	*/usr/bin/install*,*cygwin*)
5611 5612 5613 5614 5615 5616 5617 5618
	  case $file:$destfile in
	  *.exe:*.exe)
	    # this is ok
	    ;;
	  *.exe:*)
	    destfile=$destfile.exe
	    ;;
	  *:*.exe)
5619
	    destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
5620 5621 5622 5623
	    ;;
	  esac
	  ;;
	esac
unknown's avatar
unknown committed
5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639
	$show "$install_prog$stripme $file $destfile"
	$run eval "$install_prog\$stripme \$file \$destfile" || exit $?
	test -n "$outputname" && ${rm}r "$tmpdir"
	;;
      esac
    done

    for file in $staticlibs; do
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`

      # Set up the ranlib parameters.
      oldlib="$destdir/$name"

      $show "$install_prog $file $oldlib"
      $run eval "$install_prog \$file \$oldlib" || exit $?

5640 5641 5642 5643 5644
      if test -n "$stripme" && test -n "$striplib"; then
	$show "$old_striplib $oldlib"
	$run eval "$old_striplib $oldlib" || exit $?
      fi

unknown's avatar
unknown committed
5645 5646
      # Do each command in the postinstall commands.
      eval cmds=\"$old_postinstall_cmds\"
5647
      save_ifs="$IFS"; IFS='~'
unknown's avatar
unknown committed
5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662
      for cmd in $cmds; do
	IFS="$save_ifs"
	$show "$cmd"
	$run eval "$cmd" || exit $?
      done
      IFS="$save_ifs"
    done

    if test -n "$future_libdirs"; then
      $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
    fi

    if test -n "$current_libdirs"; then
      # Maybe just do a dry run.
      test -n "$run" && current_libdirs=" -n$current_libdirs"
5663 5664 5665
      exec_cmd='$SHELL $0 --finish$current_libdirs'
    else
      exit 0
unknown's avatar
unknown committed
5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684
    fi
    ;;

  # libtool finish mode
  finish)
    modename="$modename: finish"
    libdirs="$nonopt"
    admincmds=

    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
      for dir
      do
	libdirs="$libdirs $dir"
      done

      for libdir in $libdirs; do
	if test -n "$finish_cmds"; then
	  # Do each command in the finish commands.
	  eval cmds=\"$finish_cmds\"
5685
	  save_ifs="$IFS"; IFS='~'
unknown's avatar
unknown committed
5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703
	  for cmd in $cmds; do
	    IFS="$save_ifs"
	    $show "$cmd"
	    $run eval "$cmd" || admincmds="$admincmds
       $cmd"
	  done
	  IFS="$save_ifs"
	fi
	if test -n "$finish_eval"; then
	  # Do the single finish_eval.
	  eval cmds=\"$finish_eval\"
	  $run eval "$cmds" || admincmds="$admincmds
       $cmds"
	fi
      done
    fi

    # Exit here if they wanted silent mode.
5704
    test "$show" = : && exit 0
unknown's avatar
unknown committed
5705

5706 5707
    $echo "----------------------------------------------------------------------"
    $echo "Libraries have been installed in:"
unknown's avatar
unknown committed
5708
    for libdir in $libdirs; do
5709
      $echo "   $libdir"
unknown's avatar
unknown committed
5710
    done
5711 5712 5713 5714 5715
    $echo
    $echo "If you ever happen to want to link against installed libraries"
    $echo "in a given directory, LIBDIR, you must either use libtool, and"
    $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
    $echo "flag during linking and do at least one of the following:"
unknown's avatar
unknown committed
5716
    if test -n "$shlibpath_var"; then
5717 5718
      $echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
      $echo "     during execution"
unknown's avatar
unknown committed
5719 5720
    fi
    if test -n "$runpath_var"; then
5721 5722
      $echo "   - add LIBDIR to the \`$runpath_var' environment variable"
      $echo "     during linking"
unknown's avatar
unknown committed
5723 5724 5725 5726 5727
    fi
    if test -n "$hardcode_libdir_flag_spec"; then
      libdir=LIBDIR
      eval flag=\"$hardcode_libdir_flag_spec\"

5728
      $echo "   - use the \`$flag' linker flag"
unknown's avatar
unknown committed
5729 5730
    fi
    if test -n "$admincmds"; then
5731
      $echo "   - have your system administrator run these commands:$admincmds"
unknown's avatar
unknown committed
5732 5733
    fi
    if test -f /etc/ld.so.conf; then
5734
      $echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
unknown's avatar
unknown committed
5735
    fi
5736 5737 5738 5739
    $echo
    $echo "See any operating system documentation about shared libraries for"
    $echo "more information, such as the ld(1) and ld.so(8) manual pages."
    $echo "----------------------------------------------------------------------"
unknown's avatar
unknown committed
5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763
    exit 0
    ;;

  # libtool execute mode
  execute)
    modename="$modename: execute"

    # The first argument is the command name.
    cmd="$nonopt"
    if test -z "$cmd"; then
      $echo "$modename: you must specify a COMMAND" 1>&2
      $echo "$help"
      exit 1
    fi

    # Handle -dlopen flags immediately.
    for file in $execute_dlfiles; do
      if test ! -f "$file"; then
	$echo "$modename: \`$file' is not a file" 1>&2
	$echo "$help" 1>&2
	exit 1
      fi

      dir=
5764
      case $file in
unknown's avatar
unknown committed
5765 5766
      *.la)
	# Check to see that this really is a libtool archive.
5767
	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
unknown's avatar
unknown committed
5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778
	else
	  $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
	  $echo "$help" 1>&2
	  exit 1
	fi

	# Read the libtool library.
	dlname=
	library_names=

	# If there is no directory component, then add one.
5779
	case $file in
unknown's avatar
unknown committed
5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833
	*/* | *\\*) . $file ;;
	*) . ./$file ;;
	esac

	# Skip this library if it cannot be dlopened.
	if test -z "$dlname"; then
	  # Warn if it was a shared library.
	  test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
	  continue
	fi

	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
	test "X$dir" = "X$file" && dir=.

	if test -f "$dir/$objdir/$dlname"; then
	  dir="$dir/$objdir"
	else
	  $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
	  exit 1
	fi
	;;

      *.lo)
	# Just add the directory containing the .lo file.
	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
	test "X$dir" = "X$file" && dir=.
	;;

      *)
	$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
	continue
	;;
      esac

      # Get the absolute pathname.
      absdir=`cd "$dir" && pwd`
      test -n "$absdir" && dir="$absdir"

      # Now add the directory to shlibpath_var.
      if eval "test -z \"\$$shlibpath_var\""; then
	eval "$shlibpath_var=\"\$dir\""
      else
	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
      fi
    done

    # This variable tells wrapper scripts just to set shlibpath_var
    # rather than running their programs.
    libtool_execute_magic="$magic"

    # Check if any of the arguments is a wrapper script.
    args=
    for file
    do
5834
      case $file in
unknown's avatar
unknown committed
5835 5836 5837
      -*) ;;
      *)
	# Do a test to see if this is really a libtool program.
5838
	if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
unknown's avatar
unknown committed
5839
	  # If there is no directory component, then add one.
5840
	  case $file in
unknown's avatar
unknown committed
5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855
	  */* | *\\*) . $file ;;
	  *) . ./$file ;;
	  esac

	  # Transform arg to wrapped name.
	  file="$progdir/$program"
	fi
	;;
      esac
      # Quote arguments (to preserve shell metacharacters).
      file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
      args="$args \"$file\""
    done

    if test -z "$run"; then
unknown's avatar
unknown committed
5856
      if test -n "$shlibpath_var"; then
5857 5858
	# Export the shlibpath_var.
	eval "export $shlibpath_var"
unknown's avatar
unknown committed
5859
      fi
unknown's avatar
unknown committed
5860

5861
      # Restore saved environment variables
unknown's avatar
unknown committed
5862 5863 5864 5865 5866 5867 5868
      if test "${save_LC_ALL+set}" = set; then
	LC_ALL="$save_LC_ALL"; export LC_ALL
      fi
      if test "${save_LANG+set}" = set; then
	LANG="$save_LANG"; export LANG
      fi

5869
      # Now prepare to actually exec the command.
5870
      exec_cmd="\"\$cmd\"$args"
unknown's avatar
unknown committed
5871 5872
    else
      # Display what would be done.
unknown's avatar
unknown committed
5873
      if test -n "$shlibpath_var"; then
5874 5875
	eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
	$echo "export $shlibpath_var"
unknown's avatar
unknown committed
5876
      fi
5877
      eval \$echo \"\$cmd\"$args
unknown's avatar
unknown committed
5878 5879 5880 5881
      exit 0
    fi
    ;;

5882 5883 5884
  # libtool clean and uninstall mode
  clean | uninstall)
    modename="$modename: $mode"
unknown's avatar
unknown committed
5885 5886
    rm="$nonopt"
    files=
5887 5888 5889 5890 5891 5892
    rmforce=
    exit_status=0

    # This variable tells wrapper scripts just to set variables rather
    # than running their programs.
    libtool_install_magic="$magic"
unknown's avatar
unknown committed
5893 5894 5895

    for arg
    do
5896 5897
      case $arg in
      -f) rm="$rm $arg"; rmforce=yes ;;
unknown's avatar
unknown committed
5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908
      -*) rm="$rm $arg" ;;
      *) files="$files $arg" ;;
      esac
    done

    if test -z "$rm"; then
      $echo "$modename: you must specify an RM program" 1>&2
      $echo "$help" 1>&2
      exit 1
    fi

5909 5910
    rmdirs=

5911
    origobjdir="$objdir"
unknown's avatar
unknown committed
5912 5913
    for file in $files; do
      dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5914 5915
      if test "X$dir" = "X$file"; then
	dir=.
5916
	objdir="$origobjdir"
5917
      else
5918
	objdir="$dir/$origobjdir"
5919
      fi
unknown's avatar
unknown committed
5920
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5921
      test "$mode" = uninstall && objdir="$dir"
5922 5923

      # Remember objdir for removal later, being careful to avoid duplicates
5924
      if test "$mode" = clean; then
5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941
	case " $rmdirs " in
	  *" $objdir "*) ;;
	  *) rmdirs="$rmdirs $objdir" ;;
	esac
      fi

      # Don't error if the file doesn't exist and rm -f was used.
      if (test -L "$file") >/dev/null 2>&1 \
	|| (test -h "$file") >/dev/null 2>&1 \
	|| test -f "$file"; then
	:
      elif test -d "$file"; then
	exit_status=1
	continue
      elif test "$rmforce" = yes; then
	continue
      fi
unknown's avatar
unknown committed
5942 5943 5944

      rmfiles="$file"

5945
      case $name in
unknown's avatar
unknown committed
5946 5947
      *.la)
	# Possibly a libtool archive, so verify it.
5948
	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
unknown's avatar
unknown committed
5949 5950 5951 5952
	  . $dir/$name

	  # Delete the libtool libraries and symlinks.
	  for n in $library_names; do
5953
	    rmfiles="$rmfiles $objdir/$n"
unknown's avatar
unknown committed
5954
	  done
5955
	  test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
5956
	  test "$mode" = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
5957

5958
	  if test "$mode" = uninstall; then
5959 5960 5961 5962 5963 5964 5965 5966
	    if test -n "$library_names"; then
	      # Do each command in the postuninstall commands.
	      eval cmds=\"$postuninstall_cmds\"
	      save_ifs="$IFS"; IFS='~'
	      for cmd in $cmds; do
		IFS="$save_ifs"
		$show "$cmd"
		$run eval "$cmd"
5967
		if test "$?" -ne 0 && test "$rmforce" != yes; then
5968 5969 5970
		  exit_status=1
		fi
	      done
unknown's avatar
unknown committed
5971
	      IFS="$save_ifs"
5972
	    fi
unknown's avatar
unknown committed
5973

5974 5975 5976 5977 5978 5979 5980 5981
	    if test -n "$old_library"; then
	      # Do each command in the old_postuninstall commands.
	      eval cmds=\"$old_postuninstall_cmds\"
	      save_ifs="$IFS"; IFS='~'
	      for cmd in $cmds; do
		IFS="$save_ifs"
		$show "$cmd"
		$run eval "$cmd"
5982
		if test "$?" -ne 0 && test "$rmforce" != yes; then
5983 5984 5985
		  exit_status=1
		fi
	      done
unknown's avatar
unknown committed
5986
	      IFS="$save_ifs"
5987 5988
	    fi
	    # FIXME: should reinstall the best remaining shared library.
unknown's avatar
unknown committed
5989 5990 5991 5992 5993
	  fi
	fi
	;;

      *.lo)
5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010
	# Possibly a libtool object, so verify it.
	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

	  # Read the .lo file
	  . $dir/$name

	  # Add PIC object to the list of files to remove.
	  if test -n "$pic_object" \
	     && test "$pic_object" != none; then
	    rmfiles="$rmfiles $dir/$pic_object"
	  fi

	  # Add non-PIC object to the list of files to remove.
	  if test -n "$non_pic_object" \
	     && test "$non_pic_object" != none; then
	    rmfiles="$rmfiles $dir/$non_pic_object"
	  fi
unknown's avatar
unknown committed
6011 6012 6013 6014
	fi
	;;

      *)
6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029
	if test "$mode" = clean ; then
	  noexename=$name
	  case $file in
	  *.exe) 
	    file=`$echo $file|${SED} 's,.exe$,,'`
	    noexename=`$echo $name|${SED} 's,.exe$,,'`
	    # $file with .exe has already been added to rmfiles,
	    # add $file without .exe
	    rmfiles="$rmfiles $file"
	    ;;
	  esac
	  # Do a test to see if this is a libtool program.
	  if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
	    relink_command=
	    . $dir/$noexename
6030

6031 6032 6033 6034 6035 6036 6037 6038 6039
	    # note $name still contains .exe if it was in $file originally
	    # as does the version of $file that was added into $rmfiles
	    rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
	    if test "$fast_install" = yes && test -n "$relink_command"; then
	      rmfiles="$rmfiles $objdir/lt-$name"
	    fi
	    if test "X$noexename" != "X$name" ; then
	      rmfiles="$rmfiles $objdir/lt-${noexename}.c"
	    fi
6040 6041
	  fi
	fi
unknown's avatar
unknown committed
6042 6043
	;;
      esac
6044 6045
      $show "$rm $rmfiles"
      $run $rm $rmfiles || exit_status=1
unknown's avatar
unknown committed
6046
    done
6047
    objdir="$origobjdir"
6048 6049 6050 6051 6052 6053 6054 6055 6056 6057

    # Try to remove the ${objdir}s in the directories where we deleted files
    for dir in $rmdirs; do
      if test -d "$dir"; then
	$show "rmdir $dir"
	$run rmdir $dir >/dev/null 2>&1
      fi
    done

    exit $exit_status
unknown's avatar
unknown committed
6058 6059 6060 6061 6062 6063 6064 6065 6066
    ;;

  "")
    $echo "$modename: you must specify a MODE" 1>&2
    $echo "$generic_help" 1>&2
    exit 1
    ;;
  esac

6067 6068 6069 6070 6071
  if test -z "$exec_cmd"; then
    $echo "$modename: invalid operation mode \`$mode'" 1>&2
    $echo "$generic_help" 1>&2
    exit 1
  fi
unknown's avatar
unknown committed
6072 6073
fi # test -z "$show_help"

6074 6075 6076 6077 6078
if test -n "$exec_cmd"; then
  eval exec $exec_cmd
  exit 1
fi

unknown's avatar
unknown committed
6079
# We need to display help for each of the modes.
6080
case $mode in
unknown's avatar
unknown committed
6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094
"") $echo \
"Usage: $modename [OPTION]... [MODE-ARG]...

Provide generalized library-building support services.

    --config          show all configuration variables
    --debug           enable verbose shell tracing
-n, --dry-run         display commands without modifying any files
    --features        display basic configuration information and exit
    --finish          same as \`--mode=finish'
    --help            display this help message and exit
    --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
    --quiet           same as \`--silent'
    --silent          don't print informational messages
6095
    --tag=TAG         use configuration variables from tag TAG
unknown's avatar
unknown committed
6096 6097 6098 6099
    --version         print version information

MODE must be one of the following:

6100
      clean           remove files from the build directory
unknown's avatar
unknown committed
6101 6102 6103 6104 6105 6106 6107 6108
      compile         compile a source file into a libtool object
      execute         automatically set library path, then run a program
      finish          complete the installation of libtool libraries
      install         install libraries or executables
      link            create a library or an executable
      uninstall       remove libraries from an installed directory

MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
6109 6110 6111
a more detailed description of MODE.

Report bugs to <bug-libtool@gnu.org>."
unknown's avatar
unknown committed
6112 6113 6114
  exit 0
  ;;

6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128
clean)
  $echo \
"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...

Remove files from the build directory.

RM is the name of the program to use to delete files associated with each FILE
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
to RM.

If FILE is a libtool library, object or program, all the files associated
with it are deleted. Otherwise, only FILE itself is deleted using RM."
  ;;

unknown's avatar
unknown committed
6129 6130 6131 6132 6133 6134 6135 6136 6137
compile)
  $echo \
"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE

Compile a source file into a libtool library object.

This mode accepts the following additional options:

  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
6138 6139
  -prefer-pic       try to building PIC objects only
  -prefer-non-pic   try to building non-PIC objects only
unknown's avatar
unknown committed
6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218
  -static           always build a \`.o' file suitable for static linking

COMPILE-COMMAND is a command to be used in creating a \`standard' object file
from the given SOURCEFILE.

The output file name is determined by removing the directory component from
SOURCEFILE, then substituting the C source code suffix \`.c' with the
library object suffix, \`.lo'."
  ;;

execute)
  $echo \
"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...

Automatically set library path, then run a program.

This mode accepts the following additional options:

  -dlopen FILE      add the directory containing FILE to the library path

This mode sets the library path environment variable according to \`-dlopen'
flags.

If any of the ARGS are libtool executable wrappers, then they are translated
into their corresponding uninstalled binary, and any of their required library
directories are added to the library path.

Then, COMMAND is executed, with ARGS as arguments."
  ;;

finish)
  $echo \
"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...

Complete the installation of libtool libraries.

Each LIBDIR is a directory that contains libtool libraries.

The commands that this mode executes may require superuser privileges.  Use
the \`--dry-run' option if you just want to see what would be executed."
  ;;

install)
  $echo \
"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...

Install executables or libraries.

INSTALL-COMMAND is the installation command.  The first component should be
either the \`install' or \`cp' program.

The rest of the components are interpreted as arguments to that command (only
BSD-compatible install options are recognized)."
  ;;

link)
  $echo \
"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...

Link object files or libraries together to form another library, or to
create an executable program.

LINK-COMMAND is a command using the C compiler that you would use to create
a program from several object files.

The following components of LINK-COMMAND are treated specially:

  -all-static       do not do any dynamic linking at all
  -avoid-version    do not add a version suffix if possible
  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
  -export-symbols SYMFILE
		    try to export only the symbols listed in SYMFILE
  -export-symbols-regex REGEX
		    try to export only the symbols matching REGEX
  -LLIBDIR          search LIBDIR for required installed libraries
  -lNAME            OUTPUT-FILE requires the installed library libNAME
  -module           build a library that can dlopened
6219 6220
  -no-fast-install  disable the fast-install mode
  -no-install       link a not-installable executable
unknown's avatar
unknown committed
6221 6222
  -no-undefined     declare that a library does not refer to external symbols
  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
6223
  -objectlist FILE  Use a list of object files found in FILE to specify objects
unknown's avatar
unknown committed
6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268
  -release RELEASE  specify package release information
  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
  -static           do not do any dynamic linking of libtool libraries
  -version-info CURRENT[:REVISION[:AGE]]
		    specify library version info [each variable defaults to 0]

All other options (arguments beginning with \`-') are ignored.

Every other argument is treated as a filename.  Files ending in \`.la' are
treated as uninstalled libtool libraries, other files are standard or library
object files.

If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
only library objects (\`.lo' files) may be specified, and \`-rpath' is
required, except when creating a convenience library.

If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
using \`ar' and \`ranlib', or on Windows using \`lib'.

If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
is created, otherwise an executable program is created."
  ;;

uninstall)
  $echo \
"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...

Remove libraries from an installation directory.

RM is the name of the program to use to delete files associated with each FILE
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
to RM.

If FILE is a libtool library, all the files associated with it are deleted.
Otherwise, only FILE itself is deleted using RM."
  ;;

*)
  $echo "$modename: invalid operation mode \`$mode'" 1>&2
  $echo "$help" 1>&2
  exit 1
  ;;
esac

6269
$echo
unknown's avatar
unknown committed
6270 6271 6272 6273
$echo "Try \`$modename --help' for more information about other modes."

exit 0

6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293
# The TAGs below are defined such that we never get into a situation
# in which we disable both kinds of libraries.  Given conflicting
# choices, we go for a static library, that is the most portable,
# since we can't tell whether shared libraries were disabled because
# the user asked for that or because the platform doesn't support
# them.  This is particularly important on AIX, because we don't
# support having both static and shared libraries enabled at the same
# time on that platform, so we default to a shared-only configuration.
# If a disable-shared tag is given, we'll fallback to a static-only
# configuration.  But we'll never go from static-only to shared-only.

# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
build_libtool_libs=no
build_old_libs=yes
# ### END LIBTOOL TAG CONFIG: disable-shared

# ### BEGIN LIBTOOL TAG CONFIG: disable-static
build_old_libs=`case $build_libtool_libs in yes) $echo no;; *) $echo yes;; esac`
# ### END LIBTOOL TAG CONFIG: disable-static

unknown's avatar
unknown committed
6294 6295 6296 6297
# Local Variables:
# mode:shell-script
# sh-indentation:2
# End: