gift-gnutella/gift-gnutella-0.0.11-1pba: d39e1d0d75b6 ltmain.sh

4266 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

4267

4268 output="$obj"

4269 cmds=$reload_cmds

4270 save_ifs="$IFS"; IFS='~'

4271 for cmd in $cmds; do

4272 IFS="$save_ifs"

4273 eval cmd=\"$cmd\"

4274 $show "$cmd"

4275 $run eval "$cmd" || exit $?

4276 done

4277 IFS="$save_ifs"

4278

4279 # Exit if we aren't doing a library object file.

4280 if test -z "$libobj"; then

4281 if test -n "$gentop"; then

4282 $show "${rm}r $gentop"

4283 $run ${rm}r $gentop

4284 fi

4285

4286 exit $EXIT_SUCCESS

4287 fi

4288

4289 if test "$build_libtool_libs" != yes; then

4290 if test -n "$gentop"; then

4291 $show "${rm}r $gentop"

4292 $run ${rm}r $gentop

4293 fi

4294

4295 # Create an invalid libtool object if no PIC, so that we don't

4296 # accidentally link it into a program.

4297 # $show "echo timestamp > $libobj"

4298 # $run eval "echo timestamp > $libobj" || exit $?

4299 exit $EXIT_SUCCESS

4300 fi

4301

4302 if test -n "$pic_flag" || test "$pic_mode" != default; then

4303 # Only do commands if we really have different PIC objects.

4304 reload_objs="$libobjs $reload_conv_objs"

4305 output="$libobj"

4306 cmds=$reload_cmds

4307 save_ifs="$IFS"; IFS='~'

4308 for cmd in $cmds; do

4309 IFS="$save_ifs"

4310 eval cmd=\"$cmd\"

4311 $show "$cmd"

4312 $run eval "$cmd" || exit $?

4313 done

4314 IFS="$save_ifs"

4315 fi

4316

4317 if test -n "$gentop"; then

4318 $show "${rm}r $gentop"

4319 $run ${rm}r $gentop

4320 fi

4321

4322 exit $EXIT_SUCCESS

4323 ;;

4324

4325 prog)

4326 case $host in

4327 *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;

4328 esac

4329 if test -n "$vinfo"; then

4330 $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2

4331 fi

4332

4333 if test -n "$release"; then

4334 $echo "$modename: warning: \`-release' is ignored for programs" 1>&2

4335 fi

4336

4337 if test "$preload" = yes; then

4338 if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&

4339 test "$dlopen_self_static" = unknown; then

4340 $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."

4341 fi

4342 fi

4343

4344 case $host in

4345 *-*-rhapsody* | *-*-darwin1.[012])

4346 # On Rhapsody replace the C library is the System framework

4347 compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`

4348 finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`

4349 ;;

4350 esac

4351

4352 case $host in

4353 *darwin*)

4354 # Don't allow lazy linking, it breaks C++ global constructors

4355 if test "$tagname" = CXX ; then

4356 compile_command="$compile_command ${wl}-bind_at_load"

4357 finalize_command="$finalize_command ${wl}-bind_at_load"

4358 fi

4359 ;;

4360 esac

4361

4362

4363 # move library search paths that coincide with paths to not yet

4364 # installed libraries to the beginning of the library search list

4365 new_libs=

4366 for path in $notinst_path; do

4367 case " $new_libs " in

4368 *" -L$path/$objdir "*) ;;

4369 *)

4370 case " $compile_deplibs " in

4371 *" -L$path/$objdir "*)

4372 new_libs="$new_libs -L$path/$objdir" ;;

4373 esac

4374 ;;

4375 esac

4376 done

4377 for deplib in $compile_deplibs; do

4378 case $deplib in

4379 -L*)

4380 case " $new_libs " in

4381 *" $deplib "*) ;;

4382 *) new_libs="$new_libs $deplib" ;;

4383 esac

4384 ;;

4385 *) new_libs="$new_libs $deplib" ;;

4386 esac

4387 done

4388 compile_deplibs="$new_libs"

4389

4390

4391 compile_command="$compile_command $compile_deplibs"

4392 finalize_command="$finalize_command $finalize_deplibs"

4393

4394 if test -n "$rpath$xrpath"; then

4395 # If the user specified any rpath flags, then add them.

4396 for libdir in $rpath $xrpath; do

4397 # This is the magic to use -rpath.

4398 case "$finalize_rpath " in

4399 *" $libdir "*) ;;

4400 *) finalize_rpath="$finalize_rpath $libdir" ;;

4401 esac

4402 done

4403 fi

4404

4405 # Now hardcode the library paths

4406 rpath=

4407 hardcode_libdirs=

4408 for libdir in $compile_rpath $finalize_rpath; do

4409 if test -n "$hardcode_libdir_flag_spec"; then

4410 if test -n "$hardcode_libdir_separator"; then

4411 if test -z "$hardcode_libdirs"; then

4412 hardcode_libdirs="$libdir"

4413 else

4414 # Just accumulate the unique libdirs.

4415 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

4416 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

4417 ;;

4418 *)

4419 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

4420 ;;

4421 esac

4422 fi

4423 else

4424 eval flag=\"$hardcode_libdir_flag_spec\"

4425 rpath="$rpath $flag"

4426 fi

4427 elif test -n "$runpath_var"; then

4428 case "$perm_rpath " in

4429 *" $libdir "*) ;;

4430 *) perm_rpath="$perm_rpath $libdir" ;;

4431 esac

4432 fi

4433 case $host in

4434 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)

4435 testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`

4436 case :$dllsearchpath: in

4437 *":$libdir:"*) ;;

4438 *) dllsearchpath="$dllsearchpath:$libdir";;

4439 esac

4440 case :$dllsearchpath: in

4441 *":$testbindir:"*) ;;

4442 *) dllsearchpath="$dllsearchpath:$testbindir";;

4443 esac

4444 ;;

4445 esac

4446 done

4447 # Substitute the hardcoded libdirs into the rpath.

4448 if test -n "$hardcode_libdir_separator" &&

4449 test -n "$hardcode_libdirs"; then

4450 libdir="$hardcode_libdirs"

4451 eval rpath=\" $hardcode_libdir_flag_spec\"

4452 fi

4453 compile_rpath="$rpath"

4454

4455 rpath=

4456 hardcode_libdirs=

4457 for libdir in $finalize_rpath; do

4458 if test -n "$hardcode_libdir_flag_spec"; then

4459 if test -n "$hardcode_libdir_separator"; then

4460 if test -z "$hardcode_libdirs"; then

4461 hardcode_libdirs="$libdir"

4462 else

4463 # Just accumulate the unique libdirs.

4464 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

4465 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

4466 ;;

4467 *)

4468 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

4469 ;;

4470 esac

4471 fi

4472 else

4473 eval flag=\"$hardcode_libdir_flag_spec\"

4474 rpath="$rpath $flag"

4475 fi

4476 elif test -n "$runpath_var"; then

4477 case "$finalize_perm_rpath " in

4478 *" $libdir "*) ;;

4479 *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;

4480 esac

4481 fi

4482 done

4483 # Substitute the hardcoded libdirs into the rpath.

4484 if test -n "$hardcode_libdir_separator" &&

4485 test -n "$hardcode_libdirs"; then

4486 libdir="$hardcode_libdirs"

4487 eval rpath=\" $hardcode_libdir_flag_spec\"

4488 fi

4489 finalize_rpath="$rpath"

4490

4491 if test -n "$libobjs" && test "$build_old_libs" = yes; then

4492 # Transform all the library objects into standard objects.

4493 compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

4494 finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

4495 fi

4496

4497 dlsyms=

4498 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

4499 if test -n "$NM" && test -n "$global_symbol_pipe"; then

4500 dlsyms="${outputname}S.c"

4501 else

4502 $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2

4503 fi

4504 fi

4505

4506 if test -n "$dlsyms"; then

4507 case $dlsyms in

4508 "") ;;

4509 *.c)

4510 # Discover the nlist of each of the dlfiles.

4511 nlist="$output_objdir/${outputname}.nm"

4512

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

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

4515

4516 # Parse the name list into a source file.

4517 $show "creating $output_objdir/$dlsyms"

4518

4519 test -z "$run" && $echo > "$output_objdir/$dlsyms" "\

4520 /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */

4521 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */

4522

4523 #ifdef __cplusplus

4524 extern \"C\" {

4525 #endif

4526

4527 /* Prevent the only kind of declaration conflicts we can make. */

4528 #define lt_preloaded_symbols some_other_symbol

4529

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

4531 "

4532

4533 if test "$dlself" = yes; then

4534 $show "generating symbol list for \`$output'"

4535

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

4537

4538 # Add our own program objects to the symbol list.

4539 progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

4540 for arg in $progfiles; do

4541 $show "extracting global C symbols from \`$arg'"

4542 $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"

4543 done

4544

4545 if test -n "$exclude_expsyms"; then

4546 $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'

4547 $run eval '$mv "$nlist"T "$nlist"'

4548 fi

4549

4550 if test -n "$export_symbols_regex"; then

4551 $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'

4552 $run eval '$mv "$nlist"T "$nlist"'

4553 fi

4554

4555 # Prepare the list of exported symbols

4556 if test -z "$export_symbols"; then

4557 export_symbols="$output_objdir/$outputname.exp"

4558 $run $rm $export_symbols

4559 $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* $.*$$/\1/p' "'< "$nlist" > "$export_symbols"'

4560 case $host in

4561 *cygwin* | *mingw* )

4562 $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'

4563 $run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'

4564 ;;

4565 esac

4566 else

4567 $run eval "${SED} -e 's/$[].[*^$]$/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'

4568 $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'

4569 $run eval 'mv "$nlist"T "$nlist"'

4570 case $host in

4571 *cygwin* | *mingw* )

4572 $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'

4573 $run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'

4574 ;;

4575 esac

4576 fi

4577 fi

4578

4579 for arg in $dlprefiles; do

4580 $show "extracting global C symbols from \`$arg'"

4581 name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`

4582 $run eval '$echo ": $name " >> "$nlist"'

4583 $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"

4584 done

4585

4586 if test -z "$run"; then

4587 # Make sure we have at least an empty file.

4588 test -f "$nlist" || : > "$nlist"

4589

4590 if test -n "$exclude_expsyms"; then

4591 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T

4592 $mv "$nlist"T "$nlist"

4593 fi

4594

4595 # Try sorting and uniquifying the output.

4596 if grep -v "^: " < "$nlist" |

4597 if sort -k 3 </dev/null >/dev/null 2>&1; then

4598 sort -k 3

4599 else

4600 sort +2

4601 fi |

4602 uniq > "$nlist"S; then

4603 :

4604 else

4605 grep -v "^: " < "$nlist" > "$nlist"S

4606 fi

4607

4608 if test -f "$nlist"S; then

4609 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'

4610 else

4611 $echo '/* NONE */' >> "$output_objdir/$dlsyms"

4612 fi

4613

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

4615

4616 #undef lt_preloaded_symbols

4617

4618 #if defined (__STDC__) && __STDC__

4619 # define lt_ptr void *

4620 #else

4621 # define lt_ptr char *

4622 # define const

4623 #endif

4624

4625 /* The mapping between symbol names and symbols. */

4626 "

4627

4628 case $host in

4629 *cygwin* | *mingw* )

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

4631 /* DATA imports from DLLs on WIN32 can't be const, because

4632 runtime relocations are performed -- see ld's documentation

4633 on pseudo-relocs */

4634 struct {

4635 "

4636 ;;

4637 * )

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

4639 const struct {

4640 "

4641 ;;

4642 esac

4643

4644

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

4646 const char *name;

4647 lt_ptr address;

4648 }

4649 lt_preloaded_symbols[] =

4650 {\

4651 "

4652

4653 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"

4654

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

4656 {0, (lt_ptr) 0}

4657 };

4658

4659 /* This works around a problem in FreeBSD linker */

4660 #ifdef FREEBSD_WORKAROUND

4661 static const void *lt_preloaded_setup() {

4662 return lt_preloaded_symbols;

4663 }

4664 #endif

4665

4666 #ifdef __cplusplus

4667 }

4668 #endif\

4669 "

4670 fi

4671

4672 pic_flag_for_symtable=

4673 case $host in

4674 # compiling the symbol table file with pic_flag works around

4675 # a FreeBSD bug that causes programs to crash when -lm is

4676 # linked before any other PIC object. But we must not use

4677 # pic_flag when linking with -static. The problem exists in

4678 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.

4679 *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)

4680 case "$compile_command " in

4681 *" -static "*) ;;

4682 *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;

4683 esac;;

4684 *-*-hpux*)

4685 case "$compile_command " in

4686 *" -static "*) ;;

4687 *) pic_flag_for_symtable=" $pic_flag";;

4688 esac

4689 esac

4690

4691 # Now compile the dynamic symbol file.

4692 $show "(cd $output_objdir && $LTCC $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"

4693 $run eval '(cd $output_objdir && $LTCC $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?

4694

4695 # Clean up the generated files.

4696 $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"

4697 $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"

4698

4699 # Transform the symbol file into the correct name.

4700 case $host in

4701 *cygwin* | *mingw* )

4702 if test -f "$output_objdir/${outputname}.def" ; then

4703 compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`

4704 finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`

4705 else

4706 compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`

4707 finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`

4708 fi

4709 ;;

4710 * )

4711 compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`

4712 finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`

4713 ;;

4714 esac

4715 ;;

4716 *)

4717 $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2

4718 exit $EXIT_FAILURE

4719 ;;

4720 esac

4721 else

4722 # We keep going just in case the user didn't refer to

4723 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe

4724 # really was required.

4725

4726 # Nullify the symbol file.

4727 compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`

4728 finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`

4729 fi

4730

4731 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then

4732 # Replace the output file specification.

4733 compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`

4734 link_command="$compile_command$compile_rpath"

4735

4736 # We have no uninstalled library dependencies, so finalize right now.

4737 $show "$link_command"

4738 $run eval "$link_command"

4739 exit_status=$?

4740

4741 # Delete the generated files.

4742 if test -n "$dlsyms"; then

4743 $show "$rm $output_objdir/${outputname}S.${objext}"

4744 $run $rm "$output_objdir/${outputname}S.${objext}"

4745 fi

4746

4747 exit $exit_status

4748 fi

4749

4750 if test -n "$shlibpath_var"; then

4751 # We should set the shlibpath_var

4752 rpath=

4753 for dir in $temp_rpath; do

4754 case $dir in

4755 [\\/]* | [A-Za-z]:[\\/]*)

4756 # Absolute path.

4757 rpath="$rpath$dir:"

4758 ;;

4759 *)

4760 # Relative path: add a thisdir entry.

4761 rpath="$rpath\$thisdir/$dir:"

4762 ;;

4763 esac

4764 done

4765 temp_rpath="$rpath"

4766 fi

4767

4768 if test -n "$compile_shlibpath$finalize_shlibpath"; then

4769 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"

4770 fi

4771 if test -n "$finalize_shlibpath"; then

4772 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"

4773 fi

4774

4775 compile_var=

4776 finalize_var=

4777 if test -n "$runpath_var"; then

4778 if test -n "$perm_rpath"; then

4779 # We should set the runpath_var.

4780 rpath=

4781 for dir in $perm_rpath; do

4782 rpath="$rpath$dir:"

4783 done

4784 compile_var="$runpath_var=\"$rpath\$$runpath_var\" "

4785 fi

4786 if test -n "$finalize_perm_rpath"; then

4787 # We should set the runpath_var.

4788 rpath=

4789 for dir in $finalize_perm_rpath; do

4790 rpath="$rpath$dir:"

4791 done

4792 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "

4793 fi

4794 fi

4795

4796 if test "$no_install" = yes; then

4797 # We don't need to create a wrapper script.

4798 link_command="$compile_var$compile_command$compile_rpath"

4799 # Replace the output file specification.

4800 link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`

4801 # Delete the old output file.

4802 $run $rm $output

4803 # Link the executable and exit

4804 $show "$link_command"

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

4806 exit $EXIT_SUCCESS

4807 fi

4808

4809 if test "$hardcode_action" = relink; then

4810 # Fast installation is not supported

4811 link_command="$compile_var$compile_command$compile_rpath"

4812 relink_command="$finalize_var$finalize_command$finalize_rpath"

4813

4814 $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2

4815 $echo "$modename: \`$output' will be relinked during installation" 1>&2

4816 else

4817 if test "$fast_install" != no; then

4818 link_command="$finalize_var$compile_command$finalize_rpath"

4819 if test "$fast_install" = yes; then

4820 relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`

4821 else

4822 # fast_install is set to needless

4823 relink_command=

4824 fi

4825 else

4826 link_command="$compile_var$compile_command$compile_rpath"

4827 relink_command="$finalize_var$finalize_command$finalize_rpath"

4828 fi

4829 fi

4830

4831 # Replace the output file specification.

4832 link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`

4833

4834 # Delete the old output files.

4835 $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname

4836

4837 $show "$link_command"

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

4839

4840 # Now create the wrapper script.

4841 $show "creating $output"

4842

4843 # Quote the relink command for shipping.

4844 if test -n "$relink_command"; then

4845 # Preserve any variables that may affect compiler behavior

4846 for var in $variables_saved_for_relink; do

4847 if eval test -z \"\${$var+set}\"; then

4848 relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"

4849 elif eval var_value=\$$var; test -z "$var_value"; then

4850 relink_command="$var=; export $var; $relink_command"

4851 else

4852 var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`

4853 relink_command="$var=\"$var_value\"; export $var; $relink_command"

4854 fi

4855 done

4856 relink_command="(cd `pwd`; $relink_command)"

4857 relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`

4858 fi

4859

4860 # Quote $echo for shipping.

4861 if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then

4862 case $progpath in

4863 [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;

4864 *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;

4865 esac

4866 qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`

4867 else

4868 qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`

4869 fi

4870

4871 # Only actually do things if our run command is non-null.

4872 if test -z "$run"; then

4873 # win32 will think the script is a binary if it has

4874 # a .exe suffix, so we strip it off here.

4875 case $output in

4876 *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;

4877 esac

4878 # test for cygwin because mv fails w/o .exe extensions

4879 case $host in

4880 *cygwin*)

4881 exeext=.exe

4882 outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;

4883 *) exeext= ;;

4884 esac

4885 case $host in

4886 *cygwin* | *mingw* )

4887 output_name=`basename $output`

4888 output_path=`dirname $output`

4889 cwrappersource="$output_path/$objdir/lt-$output_name.c"

4890 cwrapper="$output_path/$output_name.exe"

4891 $rm $cwrappersource $cwrapper

4892 trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15

4893

4894 cat > $cwrappersource <<EOF

4895

4896 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname

4897 Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP

4898

4899 The $output program cannot be directly executed until all the libtool

4900 libraries that it depends on are installed.

4901

4902 This wrapper executable should never be moved out of the build directory.

4903 If it is, it will not operate correctly.

4904

4905 Currently, it simply execs the wrapper *script* "/bin/sh $output",

4906 but could eventually absorb all of the scripts functionality and

4907 exec $objdir/$outputname directly.

4908 */

4909 EOF

4910 cat >> $cwrappersource<<"EOF"

4911 #include <stdio.h>

4912 #include <stdlib.h>

4913 #include <unistd.h>

4914 #include <malloc.h>

4915 #include <stdarg.h>

4916 #include <assert.h>

4917 #include <string.h>

4918 #include <ctype.h>

4919 #include <sys/stat.h>

4920

4921 #if defined(PATH_MAX)

4922 # define LT_PATHMAX PATH_MAX

4923 #elif defined(MAXPATHLEN)

4924 # define LT_PATHMAX MAXPATHLEN

4925 #else

4926 # define LT_PATHMAX 1024

4927 #endif

4928

4929 #ifndef DIR_SEPARATOR

4930 # define DIR_SEPARATOR '/'

4931 # define PATH_SEPARATOR ':'

4932 #endif

4933

4934 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \

4935 defined (__OS2__)

4936 # define HAVE_DOS_BASED_FILE_SYSTEM

4937 # ifndef DIR_SEPARATOR_2

4938 # define DIR_SEPARATOR_2 '\\'

4939 # endif

4940 # ifndef PATH_SEPARATOR_2

4941 # define PATH_SEPARATOR_2 ';'

4942 # endif

4943 #endif

4944

4945 #ifndef DIR_SEPARATOR_2

4946 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)

4947 #else /* DIR_SEPARATOR_2 */

4948 # define IS_DIR_SEPARATOR(ch) \

4949 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))

4950 #endif /* DIR_SEPARATOR_2 */

4951

4952 #ifndef PATH_SEPARATOR_2

4953 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)

4954 #else /* PATH_SEPARATOR_2 */

4955 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)

4956 #endif /* PATH_SEPARATOR_2 */

4957

4958 #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))

4959 #define XFREE(stale) do { \

4960 if (stale) { free ((void *) stale); stale = 0; } \

4961 } while (0)

4962

4963 /* -DDEBUG is fairly common in CFLAGS. */

4964 #undef DEBUG

4965 #if defined DEBUGWRAPPER

4966 # define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)

4967 #else

4968 # define DEBUG(format, ...)

4969 #endif

4970

4971 const char *program_name = NULL;

4972

4973 void * xmalloc (size_t num);

4974 char * xstrdup (const char *string);

4975 const char * base_name (const char *name);

4976 char * find_executable(const char *wrapper);

4977 int check_executable(const char *path);

4978 char * strendzap(char *str, const char *pat);

4979 void lt_fatal (const char *message, ...);

4980

4981 int

4982 main (int argc, char *argv[])

4983 {

4984 char **newargz;

4985 int i;

4986

4987 program_name = (char *) xstrdup (base_name (argv[0]));

4988 DEBUG("(main) argv[0] : %s\n",argv[0]);

4989 DEBUG("(main) program_name : %s\n",program_name);

4990 newargz = XMALLOC(char *, argc+2);

4991 EOF

4992

4993 cat >> $cwrappersource <<EOF

4994 newargz[0] = (char *) xstrdup("$SHELL");

4995 EOF

4996

4997 cat >> $cwrappersource <<"EOF"

4998 newargz[1] = find_executable(argv[0]);

4999 if (newargz[1] == NULL)

5000 lt_fatal("Couldn't find %s", argv[0]);

5001 DEBUG("(main) found exe at : %s\n",newargz[1]);

5002 /* we know the script has the same name, without the .exe */

5003 /* so make sure newargz[1] doesn't end in .exe */

5004 strendzap(newargz[1],".exe");

5005 for (i = 1; i < argc; i++)

5006 newargz[i+1] = xstrdup(argv[i]);

5007 newargz[argc+1] = NULL;

5008

5009 for (i=0; i<argc+1; i++)

5010 {

5011 DEBUG("(main) newargz[%d] : %s\n",i,newargz[i]);

5012 ;

5013 }

5014

5015 EOF

5016

5017 case $host_os in

5018 mingw*)

5019 cat >> $cwrappersource <<EOF

5020 execv("$SHELL",(char const **)newargz);

5021 EOF

5022 ;;

5023 *)

5024 cat >> $cwrappersource <<EOF

5025 execv("$SHELL",newargz);

5026 EOF

5027 ;;

5028 esac

5029

5030 cat >> $cwrappersource <<"EOF"

5031 return 127;

5032 }

5033

5034 void *

5035 xmalloc (size_t num)

5036 {

5037 void * p = (void *) malloc (num);

5038 if (!p)

5039 lt_fatal ("Memory exhausted");

5040

5041 return p;

5042 }

5043

5044 char *

5045 xstrdup (const char *string)

5046 {

5047 return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL

5048 ;

5049 }

5050

5051 const char *

5052 base_name (const char *name)

5053 {

5054 const char *base;

5055

5056 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)

5057 /* Skip over the disk name in MSDOS pathnames. */

5058 if (isalpha ((unsigned char)name[0]) && name[1] == ':')

5059 name += 2;

5060 #endif

5061

5062 for (base = name; *name; name++)

5063 if (IS_DIR_SEPARATOR (*name))

5064 base = name + 1;

5065 return base;

5066 }

5067

5068 int

5069 check_executable(const char * path)

5070 {

5071 struct stat st;

5072

5073 DEBUG("(check_executable) : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");

5074 if ((!path) || (!*path))

5075 return 0;

5076

5077 if ((stat (path, &st) >= 0) &&

5078 (

5079 /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */

5080 #if defined (S_IXOTH)

5081 ((st.st_mode & S_IXOTH) == S_IXOTH) ||

5082 #endif

5083 #if defined (S_IXGRP)

5084 ((st.st_mode & S_IXGRP) == S_IXGRP) ||

5085 #endif

5086 ((st.st_mode & S_IXUSR) == S_IXUSR))

5087 )

5088 return 1;

5089 else

5090 return 0;

5091 }

5092

5093 /* Searches for the full path of the wrapper. Returns

5094 newly allocated full path name if found, NULL otherwise */

5095 char *

5096 find_executable (const char* wrapper)

5097 {

5098 int has_slash = 0;

5099 const char* p;

5100 const char* p_next;

5101 /* static buffer for getcwd */

5102 char tmp[LT_PATHMAX + 1];

5103 int tmp_len;

5104 char* concat_name;

5105

5106 DEBUG("(find_executable) : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");

5107

5108 if ((wrapper == NULL) || (*wrapper == '\0'))

5109 return NULL;

5110

5111 /* Absolute path? */

5112 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)

5113 if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')

5114 {

5115 concat_name = xstrdup (wrapper);

5116 if (check_executable(concat_name))

5117 return concat_name;

5118 XFREE(concat_name);

5119 }

5120 else

5121 {

5122 #endif

5123 if (IS_DIR_SEPARATOR (wrapper[0]))

5124 {

5125 concat_name = xstrdup (wrapper);

5126 if (check_executable(concat_name))

5127 return concat_name;

5128 XFREE(concat_name);

5129 }

5130 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)

5131 }

5132 #endif

5133

5134 for (p = wrapper; *p; p++)

5135 if (*p == '/')

5136 {

5137 has_slash = 1;

5138 break;

5139 }

5140 if (!has_slash)

5141 {

5142 /* no slashes; search PATH */

5143 const char* path = getenv ("PATH");

5144 if (path != NULL)

5145 {

5146 for (p = path; *p; p = p_next)

5147 {

5148 const char* q;

5149 size_t p_len;

5150 for (q = p; *q; q++)

5151 if (IS_PATH_SEPARATOR(*q))

5152 break;

5153 p_len = q - p;

5154 p_next = (*q == '\0' ? q : q + 1);

5155 if (p_len == 0)

5156 {

5157 /* empty path: current directory */

5158 if (getcwd (tmp, LT_PATHMAX) == NULL)

5159 lt_fatal ("getcwd failed");

5160 tmp_len = strlen(tmp);

5161 concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);

5162 memcpy (concat_name, tmp, tmp_len);

5163 concat_name[tmp_len] = '/';

5164 strcpy (concat_name + tmp_len + 1, wrapper);

5165 }

5166 else

5167 {

5168 concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);

5169 memcpy (concat_name, p, p_len);

5170 concat_name[p_len] = '/';

5171 strcpy (concat_name + p_len + 1, wrapper);

5172 }

5173 if (check_executable(concat_name))

5174 return concat_name;

5175 XFREE(concat_name);

5176 }

5177 }

5178 /* not found in PATH; assume curdir */

5179 }

5180 /* Relative path | not found in path: prepend cwd */

5181 if (getcwd (tmp, LT_PATHMAX) == NULL)

5182 lt_fatal ("getcwd failed");

5183 tmp_len = strlen(tmp);

5184 concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);

5185 memcpy (concat_name, tmp, tmp_len);

5186 concat_name[tmp_len] = '/';

5187 strcpy (concat_name + tmp_len + 1, wrapper);

5188

5189 if (check_executable(concat_name))

5190 return concat_name;

5191 XFREE(concat_name);

5192 return NULL;

5193 }

5194

5195 char *

5196 strendzap(char *str, const char *pat)

5197 {

5198 size_t len, patlen;

5199

5200 assert(str != NULL);

5201 assert(pat != NULL);

5202

5203 len = strlen(str);

5204 patlen = strlen(pat);

5205

5206 if (patlen <= len)

5207 {

5208 str += len - patlen;

5209 if (strcmp(str, pat) == 0)

5210 *str = '\0';

5211 }

5212 return str;

5213 }

5214

5215 static void

5216 lt_error_core (int exit_status, const char * mode,

5217 const char * message, va_list ap)

5218 {

5219 fprintf (stderr, "%s: %s: ", program_name, mode);

5220 vfprintf (stderr, message, ap);

5221 fprintf (stderr, ".\n");

5222

5223 if (exit_status >= 0)

5224 exit (exit_status);

5225 }

5226

5227 void

5228 lt_fatal (const char *message, ...)

5229 {

5230 va_list ap;

5231 va_start (ap, message);

5232 lt_error_core (EXIT_FAILURE, "FATAL", message, ap);

5233 va_end (ap);

5234 }

5235 EOF

5236 # we should really use a build-platform specific compiler

5237 # here, but OTOH, the wrappers (shell script and this C one)

5238 # are only useful if you want to execute the "real" binary.

5239 # Since the "real" binary is built for $host, then this

5240 # wrapper might as well be built for $host, too.

5241 $run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource

5242 ;;

5243 esac

5244 $rm $output

5245 trap "$rm $output; exit $EXIT_FAILURE" 1 2 15

5246

5247 $echo > $output "\

5248 #! $SHELL

5249

5250 # $output - temporary wrapper script for $objdir/$outputname

5251 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP

5252 #

5253 # The $output program cannot be directly executed until all the libtool

5254 # libraries that it depends on are installed.

5255 #

5256 # This wrapper script should never be moved out of the build directory.

5257 # If it is, it will not operate correctly.

5258

5259 # Sed substitution that helps us do robust quoting. It backslashifies

5260 # metacharacters that are still active within double-quoted strings.

5261 Xsed='${SED} -e 1s/^X//'

5262 sed_quote_subst='$sed_quote_subst'

5263

5264 # The HP-UX ksh and POSIX shell print the target directory to stdout

5265 # if CDPATH is set.

5266 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH

5267

5268 relink_command=\"$relink_command\"

5269

5270 # This environment variable determines our operation mode.

5271 if test \"\$libtool_install_magic\" = \"$magic\"; then

5272 # install mode needs the following variable:

5273 notinst_deplibs='$notinst_deplibs'

5274 else

5275 # When we are sourced in execute mode, \$file and \$echo are already set.

5276 if test \"\$libtool_execute_magic\" != \"$magic\"; then

5277 echo=\"$qecho\"

5278 file=\"\$0\"

5279 # Make sure echo works.

5280 if test \"X\$1\" = X--no-reexec; then

5281 # Discard the --no-reexec flag, and continue.

5282 shift

5283 elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then

5284 # Yippee, \$echo works!

5285 :

5286 else

5287 # Restart under the correct shell, and then maybe \$echo will work.

5288 exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}

5289 fi

5290 fi\

5291 "

5292 $echo >> $output "\

5293

5294 # Find the directory that this script lives in.

5295 thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`

5296 test \"x\$thisdir\" = \"x\$file\" && thisdir=.

5297

5298 # Follow symbolic links until we get to the real thisdir.

5299 file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`

5300 while test -n \"\$file\"; do

5301 destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`

5302

5303 # If there was a directory component, then change thisdir.

5304 if test \"x\$destdir\" != \"x\$file\"; then

5305 case \"\$destdir\" in

5306 [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;

5307 *) thisdir=\"\$thisdir/\$destdir\" ;;

5308 esac

5309 fi

5310

5311 file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`

5312 file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`

5313 done

5314

5315 # Try to get the absolute directory name.

5316 absdir=\`cd \"\$thisdir\" && pwd\`

5317 test -n \"\$absdir\" && thisdir=\"\$absdir\"

5318 "

5319

5320 if test "$fast_install" = yes; then

5321 $echo >> $output "\

5322 program=lt-'$outputname'$exeext

5323 progdir=\"\$thisdir/$objdir\"

5324

5325 if test ! -f \"\$progdir/\$program\" || \\

5326 { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\

5327 test \"X\$file\" != \"X\$progdir/\$program\"; }; then

5328

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

5330

5331 if test ! -d \"\$progdir\"; then

5332 $mkdir \"\$progdir\"

5333 else

5334 $rm \"\$progdir/\$file\"

5335 fi"

5336

5337 $echo >> $output "\

5338

5339 # relink executable if necessary

5340 if test -n \"\$relink_command\"; then

5341 if relink_command_output=\`eval \$relink_command 2>&1\`; then :

5342 else

5343 $echo \"\$relink_command_output\" >&2

5344 $rm \"\$progdir/\$file\"

5345 exit $EXIT_FAILURE

5346 fi

5347 fi

5348

5349 $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||

5350 { $rm \"\$progdir/\$program\";

5351 $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }

5352 $rm \"\$progdir/\$file\"

5353 fi"

5354 else

5355 $echo >> $output "\

5356 program='$outputname'

5357 progdir=\"\$thisdir/$objdir\"

5358 "

5359 fi

5360

5361 $echo >> $output "\

5362

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

5364

5365 # Export our shlibpath_var if we have one.

5366 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

5367 $echo >> $output "\

5368 # Add our own library path to $shlibpath_var

5369 $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"

5370

5371 # Some systems cannot cope with colon-terminated $shlibpath_var

5372 # The second colon is a workaround for a bug in BeOS R4 sed

5373 $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`

5374

5375 export $shlibpath_var

5376 "

5377 fi

5378

5379 # fixup the dll searchpath if we need to.

5380 if test -n "$dllsearchpath"; then

5381 $echo >> $output "\

5382 # Add the dll search path components to the executable PATH

5383 PATH=$dllsearchpath:\$PATH

5384 "

5385 fi

5386

5387 $echo >> $output "\

5388 if test \"\$libtool_execute_magic\" != \"$magic\"; then

5389 # Run the actual program with our arguments.

5390 "

5391 case $host in

5392 # Backslashes separate directories on plain windows

5393 *-*-mingw | *-*-os2*)

5394 $echo >> $output "\

5395 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}

5396 "

5397 ;;

5398

5399 *)

5400 $echo >> $output "\

5401 exec \"\$progdir/\$program\" \${1+\"\$@\"}

5402 "

5403 ;;

5404 esac

5405 $echo >> $output "\

5406 \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"

5407 exit $EXIT_FAILURE

5408 fi

5409 else

5410 # The program doesn't exist.

5411 \$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2

5412 \$echo \"This script is just a wrapper for \$program.\" 1>&2

5413 $echo \"See the $PACKAGE documentation for more information.\" 1>&2

5414 exit $EXIT_FAILURE

5415 fi

5416 fi\

5417 "

5418 chmod +x $output

5419 fi

5420 exit $EXIT_SUCCESS

5421 ;;

5422 esac

5423

5424 # See if we need to build an old-fashioned archive.

5425 for oldlib in $oldlibs; do

5426

5427 if test "$build_libtool_libs" = convenience; then

5428 oldobjs="$libobjs_save"

5429 addlibs="$convenience"

5430 build_libtool_libs=no

5431 else

5432 if test "$build_libtool_libs" = module; then

5433 oldobjs="$libobjs_save"

5434 build_libtool_libs=no

5435 else

5436 oldobjs="$old_deplibs $non_pic_objects"

5437 fi

5438 addlibs="$old_convenience"

5439 fi

5440

5441 if test -n "$addlibs"; then

5442 gentop="$output_objdir/${outputname}x"

5443 generated="$generated $gentop"

5444

5445 func_extract_archives $gentop $addlibs

5446 oldobjs="$oldobjs $func_extract_archives_result"

5447 fi

5448

5449 # Do each command in the archive commands.

5450 if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then

5451 cmds=$old_archive_from_new_cmds

5452 else

5453 # POSIX demands no paths to be encoded in archives. We have

5454 # to avoid creating archives with duplicate basenames if we

5455 # might have to extract them afterwards, e.g., when creating a

5456 # static archive out of a convenience library, or when linking

5457 # the entirety of a libtool archive into another (currently

5458 # not supported by libtool).

5459 if (for obj in $oldobjs

5460 do

5461 $echo "X$obj" | $Xsed -e 's%^.*/%%'

5462 done | sort | sort -uc >/dev/null 2>&1); then

5463 :

5464 else

5465 $echo "copying selected object files to avoid basename conflicts..."

5466

5467 if test -z "$gentop"; then

5468 gentop="$output_objdir/${outputname}x"

5469 generated="$generated $gentop"

5470

5471 $show "${rm}r $gentop"

5472 $run ${rm}r "$gentop"

5473 $show "$mkdir $gentop"

5474 $run $mkdir "$gentop"

5475 exit_status=$?

5476 if test "$exit_status" -ne 0 && test ! -d "$gentop"; then

5477 exit $exit_status

5478 fi

5479 fi

5480

5481 save_oldobjs=$oldobjs

5482 oldobjs=

5483 counter=1

5484 for obj in $save_oldobjs

5485 do

5486 objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`

5487 case " $oldobjs " in

5488 " ") oldobjs=$obj ;;

5489 *[\ /]"$objbase "*)

5490 while :; do

5491 # Make sure we don't pick an alternate name that also

5492 # overlaps.

5493 newobj=lt$counter-$objbase

5494 counter=`expr $counter + 1`

5495 case " $oldobjs " in

5496 *[\ /]"$newobj "*) ;;

5497 *) if test ! -f "$gentop/$newobj"; then break; fi ;;

5498 esac

5499 done

5500 $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"

5501 $run ln "$obj" "$gentop/$newobj" ||

5502 $run cp "$obj" "$gentop/$newobj"

5503 oldobjs="$oldobjs $gentop/$newobj"

5504 ;;

5505 *) oldobjs="$oldobjs $obj" ;;

5506 esac

5507 done

5508 fi

5509

5510 eval cmds=\"$old_archive_cmds\"

5511

5512 if len=`expr "X$cmds" : ".*"` &&

5513 test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then

5514 cmds=$old_archive_cmds

5515 else

5516 # the command line is too long to link in one step, link in parts

5517 $echo "using piecewise archive linking..."

5518 save_RANLIB=$RANLIB

5519 RANLIB=:

5520 objlist=

5521 concat_cmds=

5522 save_oldobjs=$oldobjs

5523

5524 # Is there a better way of finding the last object in the list?

5525 for obj in $save_oldobjs

5526 do

5527 last_oldobj=$obj

5528 done

5529 for obj in $save_oldobjs

5530 do

5531 oldobjs="$objlist $obj"

5532 objlist="$objlist $obj"

5533 eval test_cmds=\"$old_archive_cmds\"

5534 if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&

5535 test "$len" -le "$max_cmd_len"; then

5536 :

5537 else

5538 # the above command should be used before it gets too long

5539 oldobjs=$objlist

5540 if test "$obj" = "$last_oldobj" ; then

5541 RANLIB=$save_RANLIB

5542 fi

5543 test -z "$concat_cmds" || concat_cmds=$concat_cmds~

5544 eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"

5545 objlist=

5546 fi

5547 done

5548 RANLIB=$save_RANLIB

5549 oldobjs=$objlist

5550 if test "X$oldobjs" = "X" ; then

5551 eval cmds=\"\$concat_cmds\"

5552 else

5553 eval cmds=\"\$concat_cmds~\$old_archive_cmds\"

5554 fi

5555 fi

5556 fi

5557 save_ifs="$IFS"; IFS='~'

5558 for cmd in $cmds; do

5559 eval cmd=\"$cmd\"

5560 IFS="$save_ifs"

5561 $show "$cmd"

5562 $run eval "$cmd" || exit $?

5563 done

5564 IFS="$save_ifs"

5565 done

5566

5567 if test -n "$generated"; then

5568 $show "${rm}r$generated"

5569 $run ${rm}r$generated

5570 fi

5571

5572 # Now create the libtool archive.

5573 case $output in

5574 *.la)

5575 old_library=

5576 test "$build_old_libs" = yes && old_library="$libname.$libext"

5577 $show "creating $output"

5578

5579 # Preserve any variables that may affect compiler behavior

5580 for var in $variables_saved_for_relink; do

5581 if eval test -z \"\${$var+set}\"; then

5582 relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"

5583 elif eval var_value=\$$var; test -z "$var_value"; then

5584 relink_command="$var=; export $var; $relink_command"

5585 else

5586 var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`

5587 relink_command="$var=\"$var_value\"; export $var; $relink_command"

5588 fi

5589 done

5590 # Quote the link command for shipping.

5591 relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"

5592 relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`

5593 if test "$hardcode_automatic" = yes ; then

5594 relink_command=

5595 fi

5596

5597

5598 # Only create the output if not a dry run.

5599 if test -z "$run"; then

5600 for installed in no yes; do

5601 if test "$installed" = yes; then

5602 if test -z "$install_libdir"; then

5603 break

5604 fi

5605 output="$output_objdir/$outputname"i

5606 # Replace all uninstalled libtool libraries with the installed ones

5607 newdependency_libs=

5608 for deplib in $dependency_libs; do

5609 case $deplib in

5610 *.la)

5611 name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`

5612 eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`

5613 if test -z "$libdir"; then

5614 $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2

5615 exit $EXIT_FAILURE

5616 fi

5617 newdependency_libs="$newdependency_libs $libdir/$name"

5618 ;;

5619 *) newdependency_libs="$newdependency_libs $deplib" ;;

5620 esac

5621 done

5622 dependency_libs="$newdependency_libs"

5623 newdlfiles=

5624 for lib in $dlfiles; do

5625 name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`

5626 eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`

5627 if test -z "$libdir"; then

5628 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2

5629 exit $EXIT_FAILURE

5630 fi

5631 newdlfiles="$newdlfiles $libdir/$name"

5632 done

5633 dlfiles="$newdlfiles"

5634 newdlprefiles=

5635 for lib in $dlprefiles; do

5636 name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`

5637 eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`

5638 if test -z "$libdir"; then

5639 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2

5640 exit $EXIT_FAILURE

5641 fi

5642 newdlprefiles="$newdlprefiles $libdir/$name"

5643 done

5644 dlprefiles="$newdlprefiles"

5645 else

5646 newdlfiles=

5647 for lib in $dlfiles; do

5648 case $lib in

5649 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

5650 *) abs=`pwd`"/$lib" ;;

5651 esac

5652 newdlfiles="$newdlfiles $abs"

5653 done

5654 dlfiles="$newdlfiles"

5655 newdlprefiles=

5656 for lib in $dlprefiles; do

5657 case $lib in

5658 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

5659 *) abs=`pwd`"/$lib" ;;

5660 esac

5661 newdlprefiles="$newdlprefiles $abs"

5662 done

5663 dlprefiles="$newdlprefiles"

5664 fi

5665 $rm $output

5666 # place dlname in correct position for cygwin

5667 tdlname=$dlname

5668 case $host,$output,$installed,$module,$dlname in

5669 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;

5670 esac

5671 $echo > $output "\

5672 # $outputname - a libtool library file

5673 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP

5674 #

5675 # Please DO NOT delete this file!

5676 # It is necessary for linking the library.

5677

5678 # The name that we can dlopen(3).

5679 dlname='$tdlname'

5680

5681 # Names of this library.

5682 library_names='$library_names'

5683

5684 # The name of the static archive.

5685 old_library='$old_library'

5686

5687 # Libraries that this one depends upon.

5688 dependency_libs='$dependency_libs'

5689

5690 # Version information for $libname.

5691 current=$current

5692 age=$age

5693 revision=$revision

5694

5695 # Is this an already installed library?

5696 installed=$installed

5697

5698 # Should we warn about portability when linking against -modules?

5699 shouldnotlink=$module

5700

5701 # Files to dlopen/dlpreopen

5702 dlopen='$dlfiles'

5703 dlpreopen='$dlprefiles'

5704

5705 # Directory that this library needs to be installed in:

5706 libdir='$install_libdir'"

5707 if test "$installed" = no && test "$need_relink" = yes; then

5708 $echo >> $output "\

5709 relink_command=\"$relink_command\""

5710 fi

5711 done

5712 fi

5713

5714 # Do a symbolic link so that the libtool archive can be found in

5715 # LD_LIBRARY_PATH before the program is installed.

5716 $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"

5717 $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?

5718 ;;

5719 esac

5720 exit $EXIT_SUCCESS

5721 ;;

5722

5723 # libtool install mode

5724 install)

5725 modename="$modename: install"

5726

5727 # There may be an optional sh(1) argument at the beginning of

5728 # install_prog (especially on Windows NT).

5729 if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||

5730 # Allow the use of GNU shtool's install command.

5731 $echo "X$nonopt" | grep shtool > /dev/null; then

5732 # Aesthetically quote it.

5733 arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`

5734 case $arg in

5735 *[\[\~\#\^\&\*\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")

5736 arg="\"$arg\""

5737 ;;

5738 esac

5739 install_prog="$arg "

5740 arg="$1"

5741 shift

5742 else

5743 install_prog=

5744 arg=$nonopt

5745 fi

5746

5747 # The real first argument should be the name of the installation program.

5748 # Aesthetically quote it.

5749 arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`

5750 case $arg in

5751 *[\[\~\#\^\&\*\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")

5752 arg="\"$arg\""

5753 ;;

5754 esac

5755 install_prog="$install_prog$arg"

5756

5757 # We need to accept at least all the BSD install flags.

5758 dest=

5759 files=

5760 opts=

5761 prev=

5762 install_type=

5763 isdir=no

5764 stripme=

5765 for arg

5766 do

5767 if test -n "$dest"; then

5768 files="$files $dest"

5769 dest=$arg

5770 continue

5771 fi

5772

5773 case $arg in

5774 -d) isdir=yes ;;

5775 -f)

5776 case " $install_prog " in

5777 *[\\\ /]cp\ *) ;;

5778 *) prev=$arg ;;

5779 esac

5780 ;;

5781 -g | -m | -o) prev=$arg ;;

5782 -s)

5783 stripme=" -s"

5784 continue

5785 ;;

5786 -*)

5787 ;;

5788 *)

5789 # If the previous option needed an argument, then skip it.

5790 if test -n "$prev"; then

5791 prev=

5792 else

5793 dest=$arg

5794 continue

5795 fi

5796 ;;

5797 esac

5798

5799 # Aesthetically quote the argument.

5800 arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`

5801 case $arg in

5802 *[\[\~\#\^\&\*\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")

5803 arg="\"$arg\""

5804 ;;

5805 esac

5806 install_prog="$install_prog $arg"

5807 done

5808

5809 if test -z "$install_prog"; then

5810 $echo "$modename: you must specify an install program" 1>&2

5811 $echo "$help" 1>&2

5812 exit $EXIT_FAILURE

5813 fi

5814

5815 if test -n "$prev"; then

5816 $echo "$modename: the \`$prev' option requires an argument" 1>&2

5817 $echo "$help" 1>&2

5818 exit $EXIT_FAILURE

5819 fi

5820

5821 if test -z "$files"; then

5822 if test -z "$dest"; then

5823 $echo "$modename: no file or destination specified" 1>&2

5824 else

5825 $echo "$modename: you must specify a destination" 1>&2

5826 fi

5827 $echo "$help" 1>&2

5828 exit $EXIT_FAILURE

5829 fi

5830

5831 # Strip any trailing slash from the destination.

5832 dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`

5833

5834 # Check to see that the destination is a directory.

5835 test -d "$dest" && isdir=yes

5836 if test "$isdir" = yes; then

5837 destdir="$dest"

5838 destname=

5839 else

5840 destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`

5841 test "X$destdir" = "X$dest" && destdir=.

5842 destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`

5843

5844 # Not a directory, so check to see that there is only one file specified.

5845 set dummy $files

5846 if test "$#" -gt 2; then

5847 $echo "$modename: \`$dest' is not a directory" 1>&2

5848 $echo "$help" 1>&2

5849 exit $EXIT_FAILURE

5850 fi

5851 fi

5852 case $destdir in

5853 [\\/]* | [A-Za-z]:[\\/]*) ;;

5854 *)

5855 for file in $files; do

5856 case $file in

5857 *.lo) ;;

5858 *)

5859 $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2

5860 $echo "$help" 1>&2

5861 exit $EXIT_FAILURE

5862 ;;

5863 esac

5864 done

5865 ;;

5866 esac

5867

5868 # This variable tells wrapper scripts just to set variables rather

5869 # than running their programs.

5870 libtool_install_magic="$magic"

5871

5872 staticlibs=

5873 future_libdirs=

5874 current_libdirs=

5875 for file in $files; do

5876

5877 # Do each installation.

5878 case $file in

5879 *.$libext)

5880 # Do the static libraries later.

5881 staticlibs="$staticlibs $file"

5882 ;;

5883

5884 *.la)

5885 # Check to see that this really is a libtool archive.

5886 if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :

5887 else

5888 $echo "$modename: \`$file' is not a valid libtool archive" 1>&2

5889 $echo "$help" 1>&2

5890 exit $EXIT_FAILURE

5891 fi

5892

5893 library_names=

5894 old_library=

5895 relink_command=

5896 # If there is no directory component, then add one.

5897 case $file in

5898 */* | *\\*) . $file ;;

5899 *) . ./$file ;;

5900 esac

5901

5902 # Add the libdir to current_libdirs if it is the destination.

5903 if test "X$destdir" = "X$libdir"; then

5904 case "$current_libdirs " in

5905 *" $libdir "*) ;;

5906 *) current_libdirs="$current_libdirs $libdir" ;;

5907 esac

5908 else

5909 # Note the libdir as a future libdir.

5910 case "$future_libdirs " in

5911 *" $libdir "*) ;;

5912 *) future_libdirs="$future_libdirs $libdir" ;;

5913 esac

5914 fi

5915

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

5917 test "X$dir" = "X$file/" && dir=

5918 dir="$dir$objdir"

5919

5920 if test -n "$relink_command"; then

5921 # Determine the prefix the user has applied to our future dir.

5922 inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`

5923

5924 # Don't allow the user to place us outside of our expected

5925 # location b/c this prevents finding dependent libraries that

5926 # are installed to the same prefix.

5927 # At present, this check doesn't affect windows .dll's that

5928 # are installed into $libdir/../bin (currently, that works fine)

5929 # but it's something to keep an eye on.

5930 if test "$inst_prefix_dir" = "$destdir"; then

5931 $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2

5932 exit $EXIT_FAILURE

5933 fi

5934

5935 if test -n "$inst_prefix_dir"; then

5936 # Stick the inst_prefix_dir data into the link command.

5937 relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`

5938 else

5939 relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`

5940 fi

5941

5942 $echo "$modename: warning: relinking \`$file'" 1>&2

5943 $show "$relink_command"

5944 if $run eval "$relink_command"; then :

5945 else

5946 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2

5947 exit $EXIT_FAILURE

5948 fi

5949 fi

5950

5951 # See the names of the shared library.

5952 set dummy $library_names

5953 if test -n "$2"; then

5954 realname="$2"

5955 shift

5956 shift

5957

5958 srcname="$realname"

5959 test -n "$relink_command" && srcname="$realname"T

5960

5961 # Install the shared library and build the symlinks.

5962 $show "$install_prog $dir/$srcname $destdir/$realname"

5963 $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?

5964 if test -n "$stripme" && test -n "$striplib"; then

5965 $show "$striplib $destdir/$realname"

5966 $run eval "$striplib $destdir/$realname" || exit $?

5967 fi

5968

5969 if test "$#" -gt 0; then

5970 # Delete the old symlinks, and create new ones.

5971 # Try `ln -sf' first, because the `ln' binary might depend on

5972 # the symlink we replace! Solaris /bin/ln does not understand -f,

5973 # so we also need to try rm && ln -s.

5974 for linkname

5975 do

5976 if test "$linkname" != "$realname"; then

5977 $show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"

5978 $run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"

5979 fi

5980 done

5981 fi

5982

5983 # Do each command in the postinstall commands.

5984 lib="$destdir/$realname"

5985 cmds=$postinstall_cmds

5986 save_ifs="$IFS"; IFS='~'

5987 for cmd in $cmds; do

5988 IFS="$save_ifs"

5989 eval cmd=\"$cmd\"

5990 $show "$cmd"

5991 $run eval "$cmd" || {

5992 lt_exit=$?

5993

5994 # Restore the uninstalled library and exit

5995 if test "$mode" = relink; then

5996 $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'

5997 fi

5998

5999 exit $lt_exit

6000 }

6001 done

6002 IFS="$save_ifs"

6003 fi

6004

6005 # Install the pseudo-library for information purposes.

6006 name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`

6007 instname="$dir/$name"i

6008 $show "$install_prog $instname $destdir/$name"

6009 $run eval "$install_prog $instname $destdir/$name" || exit $?

6010

6011 # Maybe install the static library, too.

6012 test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"

6013 ;;

6014

6015 *.lo)

6016 # Install (i.e. copy) a libtool object.

6017

6018 # Figure out destination file name, if it wasn't already specified.

6019 if test -n "$destname"; then

6020 destfile="$destdir/$destname"

6021 else

6022 destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`

6023 destfile="$destdir/$destfile"

6024 fi

6025

6026 # Deduce the name of the destination old-style object file.

6027 case $destfile in

6028 *.lo)

6029 staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`

6030 ;;

6031 *.$objext)

6032 staticdest="$destfile"

6033 destfile=

6034 ;;

6035 *)

6036 $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2

6037 $echo "$help" 1>&2

6038 exit $EXIT_FAILURE

6039 ;;

6040 esac

6041

6042 # Install the libtool object if requested.

6043 if test -n "$destfile"; then

6044 $show "$install_prog $file $destfile"

6045 $run eval "$install_prog $file $destfile" || exit $?

6046 fi

6047

6048 # Install the old object if enabled.

6049 if test "$build_old_libs" = yes; then

6050 # Deduce the name of the old-style object file.

6051 staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`

6052

6053 $show "$install_prog $staticobj $staticdest"

6054 $run eval "$install_prog \$staticobj \$staticdest" || exit $?

6055 fi

6056 exit $EXIT_SUCCESS

6057 ;;

6058

6059 *)

6060 # Figure out destination file name, if it wasn't already specified.

6061 if test -n "$destname"; then

6062 destfile="$destdir/$destname"

6063 else

6064 destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`

6065 destfile="$destdir/$destfile"

6066 fi

6067

6068 # If the file is missing, and there is a .exe on the end, strip it

6069 # because it is most likely a libtool script we actually want to

6070 # install

6071 stripped_ext=""

6072 case $file in

6073 *.exe)

6074 if test ! -f "$file"; then

6075 file=`$echo $file|${SED} 's,.exe$,,'`

6076 stripped_ext=".exe"

6077 fi

6078 ;;

6079 esac

6080

6081 # Do a test to see if this is really a libtool program.

6082 case $host in

6083 *cygwin*|*mingw*)

6084 wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`

6085 ;;

6086 *)

6087 wrapper=$file

6088 ;;

6089 esac

6090 if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then

6091 notinst_deplibs=

6092 relink_command=

6093

6094 # Note that it is not necessary on cygwin/mingw to append a dot to

6095 # foo even if both foo and FILE.exe exist: automatic-append-.exe

6096 # behavior happens only for exec(3), not for open(2)! Also, sourcing

6097 # `FILE.' does not work on cygwin managed mounts.

6098 #

6099 # If there is no directory component, then add one.

6100 case $wrapper in

6101 */* | *\\*) . ${wrapper} ;;

6102 *) . ./${wrapper} ;;

6103 esac

6104

6105 # Check the variables that should have been set.

6106 if test -z "$notinst_deplibs"; then

6107 $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2

6108 exit $EXIT_FAILURE

6109 fi

6110

6111 finalize=yes

6112 for lib in $notinst_deplibs; do

6113 # Check to see that each library is installed.

6114 libdir=

6115 if test -f "$lib"; then

6116 # If there is no directory component, then add one.

6117 case $lib in

6118 */* | *\\*) . $lib ;;

6119 *) . ./$lib ;;

6120 esac

6121 fi

6122 libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test

6123 if test -n "$libdir" && test ! -f "$libfile"; then

6124 $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2

6125 finalize=no

6126 fi

6127 done

6128

6129 relink_command=

6130 # Note that it is not necessary on cygwin/mingw to append a dot to

6131 # foo even if both foo and FILE.exe exist: automatic-append-.exe

6132 # behavior happens only for exec(3), not for open(2)! Also, sourcing

6133 # `FILE.' does not work on cygwin managed mounts.

6134 #

6135 # If there is no directory component, then add one.

6136 case $wrapper in

6137 */* | *\\*) . ${wrapper} ;;

6138 *) . ./${wrapper} ;;

6139 esac

6140

6141 outputname=

6142 if test "$fast_install" = no && test -n "$relink_command"; then

6143 if test "$finalize" = yes && test -z "$run"; then

6144 tmpdir=`func_mktempdir`

6145 file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`

6146 outputname="$tmpdir/$file"

6147 # Replace the output file specification.

6148 relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`

6149

6150 $show "$relink_command"

6151 if $run eval "$relink_command"; then :

6152 else

6153 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2

6154 ${rm}r "$tmpdir"

6155 continue

6156 fi

6157 file="$outputname"

6158 else

6159 $echo "$modename: warning: cannot relink \`$file'" 1>&2

6160 fi

6161 else

6162 # Install the binary that we compiled earlier.

6163 file=`$echo "X$file$stripped_ext" | $Xsed -e "s%$[^/]*$$%$objdir/\1%"`

6164 fi

6165 fi

6166

6167 # remove .exe since cygwin /usr/bin/install will append another

6168 # one anyway

6169 case $install_prog,$host in

6170 */usr/bin/install*,*cygwin*)

6171 case $file:$destfile in

6172 *.exe:*.exe)

6173 # this is ok

6174 ;;

6175 *.exe:*)

6176 destfile=$destfile.exe

6177 ;;

6178 *:*.exe)

6179 destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`

6180 ;;

6181 esac

6182 ;;

6183 esac

6184 $show "$install_prog$stripme $file $destfile"

6185 $run eval "$install_prog\$stripme \$file \$destfile" || exit $?

6186 test -n "$outputname" && ${rm}r "$tmpdir"

6187 ;;

6188 esac

6189 done

6190

6191 for file in $staticlibs; do

6192 name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`

6193

6194 # Set up the ranlib parameters.

6195 oldlib="$destdir/$name"

6196

6197 $show "$install_prog $file $oldlib"

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

6199

6200 if test -n "$stripme" && test -n "$old_striplib"; then

6201 $show "$old_striplib $oldlib"

6202 $run eval "$old_striplib $oldlib" || exit $?

6203 fi

6204

6205 # Do each command in the postinstall commands.

6206 cmds=$old_postinstall_cmds

6207 save_ifs="$IFS"; IFS='~'

6208 for cmd in $cmds; do

6209 IFS="$save_ifs"

6210 eval cmd=\"$cmd\"

6211 $show "$cmd"

6212 $run eval "$cmd" || exit $?

6213 done

6214 IFS="$save_ifs"

6215 done

6216

6217 if test -n "$future_libdirs"; then

6218 $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2

6219 fi

6220

6221 if test -n "$current_libdirs"; then

6222 # Maybe just do a dry run.

6223 test -n "$run" && current_libdirs=" -n$current_libdirs"

6224 exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'

6225 else

6226 exit $EXIT_SUCCESS

6227 fi

6228 ;;

6229

6230 # libtool finish mode

6231 finish)

6232 modename="$modename: finish"

6233 libdirs="$nonopt"

6234 admincmds=

6235

6236 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then

6237 for dir

6238 do

6239 libdirs="$libdirs $dir"

6240 done

6241

6242 for libdir in $libdirs; do

6243 if test -n "$finish_cmds"; then

6244 # Do each command in the finish commands.

6245 cmds=$finish_cmds

6246 save_ifs="$IFS"; IFS='~'

6247 for cmd in $cmds; do

6248 IFS="$save_ifs"

6249 eval cmd=\"$cmd\"

6250 $show "$cmd"

6251 $run eval "$cmd" || admincmds="$admincmds

6252 $cmd"

6253 done

6254 IFS="$save_ifs"

6255 fi

6256 if test -n "$finish_eval"; then

6257 # Do the single finish_eval.

6258 eval cmds=\"$finish_eval\"

6259 $run eval "$cmds" || admincmds="$admincmds

6260 $cmds"

6261 fi

6262 done

6263 fi

6264

6265 # Exit here if they wanted silent mode.

6266 test "$show" = : && exit $EXIT_SUCCESS

6267

6268 $echo "X----------------------------------------------------------------------" | $Xsed

6269 $echo "Libraries have been installed in:"

6270 for libdir in $libdirs; do

6271 $echo " $libdir"

6272 done

6273 $echo

6274 $echo "If you ever happen to want to link against installed libraries"

6275 $echo "in a given directory, LIBDIR, you must either use libtool, and"

6276 $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"

6277 $echo "flag during linking and do at least one of the following:"

6278 if test -n "$shlibpath_var"; then

6279 $echo " - add LIBDIR to the \`$shlibpath_var' environment variable"

6280 $echo " during execution"

6281 fi

6282 if test -n "$runpath_var"; then

6283 $echo " - add LIBDIR to the \`$runpath_var' environment variable"

6284 $echo " during linking"

6285 fi

6286 if test -n "$hardcode_libdir_flag_spec"; then

6287 libdir=LIBDIR

6288 eval flag=\"$hardcode_libdir_flag_spec\"

6289

6290 $echo " - use the \`$flag' linker flag"

6291 fi

6292 if test -n "$admincmds"; then

6293 $echo " - have your system administrator run these commands:$admincmds"

6294 fi

6295 if test -f /etc/ld.so.conf; then

6296 $echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"

6297 fi

6298 $echo

6299 $echo "See any operating system documentation about shared libraries for"

6300 $echo "more information, such as the ld(1) and ld.so(8) manual pages."

6301 $echo "X----------------------------------------------------------------------" | $Xsed

6302 exit $EXIT_SUCCESS

6303 ;;

6304

6305 # libtool execute mode

6306 execute)

6307 modename="$modename: execute"

6308

6309 # The first argument is the command name.

6310 cmd="$nonopt"

6311 if test -z "$cmd"; then

6312 $echo "$modename: you must specify a COMMAND" 1>&2

6313 $echo "$help"

6314 exit $EXIT_FAILURE

6315 fi

6316

6317 # Handle -dlopen flags immediately.

6318 for file in $execute_dlfiles; do

6319 if test ! -f "$file"; then

6320 $echo "$modename: \`$file' is not a file" 1>&2

6321 $echo "$help" 1>&2

6322 exit $EXIT_FAILURE

6323 fi

6324

6325 dir=

6326 case $file in

6327 *.la)

6328 # Check to see that this really is a libtool archive.

6329 if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :

6330 else

6331 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2

6332 $echo "$help" 1>&2

6333 exit $EXIT_FAILURE

6334 fi

6335

6336 # Read the libtool library.

6337 dlname=

6338 library_names=

6339

6340 # If there is no directory component, then add one.

6341 case $file in

6342 */* | *\\*) . $file ;;

6343 *) . ./$file ;;

6344 esac

6345

6346 # Skip this library if it cannot be dlopened.

6347 if test -z "$dlname"; then

6348 # Warn if it was a shared library.

6349 test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"

6350 continue

6351 fi

6352

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

6354 test "X$dir" = "X$file" && dir=.

6355

6356 if test -f "$dir/$objdir/$dlname"; then

6357 dir="$dir/$objdir"

6358 else

6359 $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2

6360 exit $EXIT_FAILURE

6361 fi

6362 ;;

6363

6364 *.lo)

6365 # Just add the directory containing the .lo file.

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

6367 test "X$dir" = "X$file" && dir=.

6368 ;;

6369

6370 *)

6371 $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2

6372 continue

6373 ;;

6374 esac

6375

6376 # Get the absolute pathname.

6377 absdir=`cd "$dir" && pwd`

6378 test -n "$absdir" && dir="$absdir"

6379

6380 # Now add the directory to shlibpath_var.

6381 if eval "test -z \"\$$shlibpath_var\""; then

6382 eval "$shlibpath_var=\"\$dir\""

6383 else

6384 eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""

6385 fi

6386 done

6387

6388 # This variable tells wrapper scripts just to set shlibpath_var

6389 # rather than running their programs.

6390 libtool_execute_magic="$magic"

6391

6392 # Check if any of the arguments is a wrapper script.

6393 args=

6394 for file

6395 do

6396 case $file in

6397 -*) ;;

6398 *)

6399 # Do a test to see if this is really a libtool program.

6400 if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

6401 # If there is no directory component, then add one.

6402 case $file in

6403 */* | *\\*) . $file ;;

6404 *) . ./$file ;;

6405 esac

6406

6407 # Transform arg to wrapped name.

6408 file="$progdir/$program"

6409 fi

6410 ;;

6411 esac

6412 # Quote arguments (to preserve shell metacharacters).

6413 file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`

6414 args="$args \"$file\""

6415 done

6416

6417 if test -z "$run"; then

6418 if test -n "$shlibpath_var"; then

6419 # Export the shlibpath_var.

6420 eval "export $shlibpath_var"

6421 fi

6422

6423 # Restore saved environment variables

6424 if test "${save_LC_ALL+set}" = set; then

6425 LC_ALL="$save_LC_ALL"; export LC_ALL

6426 fi

6427 if test "${save_LANG+set}" = set; then

6428 LANG="$save_LANG"; export LANG

6429 fi

6430

6431 # Now prepare to actually exec the command.

6432 exec_cmd="\$cmd$args"

6433 else

6434 # Display what would be done.

6435 if test -n "$shlibpath_var"; then

6436 eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""

6437 $echo "export $shlibpath_var"

6438 fi

6439 $echo "$cmd$args"

6440 exit $EXIT_SUCCESS

6441 fi

6442 ;;

6443

6444 # libtool clean and uninstall mode

6445 clean | uninstall)

6446 modename="$modename: $mode"

6447 rm="$nonopt"

6448 files=

6449 rmforce=

6450 exit_status=0

6451

6452 # This variable tells wrapper scripts just to set variables rather

6453 # than running their programs.

6454 libtool_install_magic="$magic"

6455

6456 for arg

6457 do

6458 case $arg in

6459 -f) rm="$rm $arg"; rmforce=yes ;;

6460 -*) rm="$rm $arg" ;;

6461 *) files="$files $arg" ;;

6462 esac

6463 done

6464

6465 if test -z "$rm"; then

6466 $echo "$modename: you must specify an RM program" 1>&2

6467 $echo "$help" 1>&2

6468 exit $EXIT_FAILURE

6469 fi

6470

6471 rmdirs=

6472

6473 origobjdir="$objdir"

6474 for file in $files; do

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

6476 if test "X$dir" = "X$file"; then

6477 dir=.

6478 objdir="$origobjdir"

6479 else

6480 objdir="$dir/$origobjdir"

6481 fi

6482 name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`

6483 test "$mode" = uninstall && objdir="$dir"

6484

6485 # Remember objdir for removal later, being careful to avoid duplicates

6486 if test "$mode" = clean; then

6487 case " $rmdirs " in

6488 *" $objdir "*) ;;

6489 *) rmdirs="$rmdirs $objdir" ;;

6490 esac

6491 fi

6492

6493 # Don't error if the file doesn't exist and rm -f was used.

6494 if (test -L "$file") >/dev/null 2>&1 \

6495 || (test -h "$file") >/dev/null 2>&1 \

6496 || test -f "$file"; then

6497 :

6498 elif test -d "$file"; then

6499 exit_status=1

6500 continue

6501 elif test "$rmforce" = yes; then

6502 continue

6503 fi

6504

6505 rmfiles="$file"

6506

6507 case $name in

6508 *.la)

6509 # Possibly a libtool archive, so verify it.

6510 if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

6511 . $dir/$name

6512

6513 # Delete the libtool libraries and symlinks.

6514 for n in $library_names; do

6515 rmfiles="$rmfiles $objdir/$n"

6516 done

6517 test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"

6518

6519 case "$mode" in

6520 clean)

6521 case " $library_names " in

6522 # " " in the beginning catches empty $dlname

6523 *" $dlname "*) ;;

6524 *) rmfiles="$rmfiles $objdir/$dlname" ;;

6525 esac

6526 test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"

6527 ;;

6528 uninstall)

6529 if test -n "$library_names"; then

6530 # Do each command in the postuninstall commands.

6531 cmds=$postuninstall_cmds

6532 save_ifs="$IFS"; IFS='~'

6533 for cmd in $cmds; do

6534 IFS="$save_ifs"

6535 eval cmd=\"$cmd\"

6536 $show "$cmd"

6537 $run eval "$cmd"

6538 if test "$?" -ne 0 && test "$rmforce" != yes; then

6539 exit_status=1

6540 fi

6541 done

6542 IFS="$save_ifs"

6543 fi

6544

6545 if test -n "$old_library"; then

6546 # Do each command in the old_postuninstall commands.

6547 cmds=$old_postuninstall_cmds

6548 save_ifs="$IFS"; IFS='~'

6549 for cmd in $cmds; do

6550 IFS="$save_ifs"

6551 eval cmd=\"$cmd\"

6552 $show "$cmd"

6553 $run eval "$cmd"

6554 if test "$?" -ne 0 && test "$rmforce" != yes; then

6555 exit_status=1

6556 fi

6557 done

6558 IFS="$save_ifs"

6559 fi

6560 # FIXME: should reinstall the best remaining shared library.

6561 ;;

6562 esac

6563 fi

6564 ;;

6565

6566 *.lo)

6567 # Possibly a libtool object, so verify it.

6568 if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

6569

6570 # Read the .lo file

6571 . $dir/$name

6572

6573 # Add PIC object to the list of files to remove.

6574 if test -n "$pic_object" \

6575 && test "$pic_object" != none; then

6576 rmfiles="$rmfiles $dir/$pic_object"

6577 fi

6578

6579 # Add non-PIC object to the list of files to remove.

6580 if test -n "$non_pic_object" \

6581 && test "$non_pic_object" != none; then

6582 rmfiles="$rmfiles $dir/$non_pic_object"

6583 fi

6584 fi

6585 ;;

6586

6587 *)

6588 if test "$mode" = clean ; then

6589 noexename=$name

6590 case $file in

6591 *.exe)

6592 file=`$echo $file|${SED} 's,.exe$,,'`

6593 noexename=`$echo $name|${SED} 's,.exe$,,'`

6594 # $file with .exe has already been added to rmfiles,

6595 # add $file without .exe

6596 rmfiles="$rmfiles $file"

6597 ;;

6598 esac

6599 # Do a test to see if this is a libtool program.

6600 if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

6601 relink_command=

6602 . $dir/$noexename

6603

6604 # note $name still contains .exe if it was in $file originally

6605 # as does the version of $file that was added into $rmfiles

6606 rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"

6607 if test "$fast_install" = yes && test -n "$relink_command"; then

6608 rmfiles="$rmfiles $objdir/lt-$name"

6609 fi

6610 if test "X$noexename" != "X$name" ; then

6611 rmfiles="$rmfiles $objdir/lt-${noexename}.c"

6612 fi

6613 fi

6614 fi

6615 ;;

6616 esac

6617 $show "$rm $rmfiles"

6618 $run $rm $rmfiles || exit_status=1

6619 done

6620 objdir="$origobjdir"

6621

6622 # Try to remove the ${objdir}s in the directories where we deleted files

6623 for dir in $rmdirs; do

6624 if test -d "$dir"; then

6625 $show "rmdir $dir"

6626 $run rmdir $dir >/dev/null 2>&1

6627 fi

6628 done

6629

6630 exit $exit_status

6631 ;;

6632

6633 "")

6634 $echo "$modename: you must specify a MODE" 1>&2

6635 $echo "$generic_help" 1>&2

6636 exit $EXIT_FAILURE

6637 ;;

6638 esac

6639

6640 if test -z "$exec_cmd"; then

6641 $echo "$modename: invalid operation mode \`$mode'" 1>&2

6642 $echo "$generic_help" 1>&2

6643 exit $EXIT_FAILURE

6644 fi

6645 fi # test -z "$show_help"

6646

6647 if test -n "$exec_cmd"; then

6648 eval exec $exec_cmd

6649 exit $EXIT_FAILURE

6650 fi

6651

6652 # We need to display help for each of the modes.

6653 case $mode in

6654 "") $echo \

6655 "Usage: $modename [OPTION]... [MODE-ARG]...

6656

6657 Provide generalized library-building support services.

6658

6659 --config show all configuration variables

6660 --debug enable verbose shell tracing

6661 -n, --dry-run display commands without modifying any files

6662 --features display basic configuration information and exit

6663 --finish same as \`--mode=finish'

6664 --help display this help message and exit

6665 --mode=MODE use operation mode MODE [default=inferred from MODE-ARGS]

6666 --quiet same as \`--silent'

6667 --silent don't print informational messages

6668 --tag=TAG use configuration variables from tag TAG

6669 --version print version information

6670

6671 MODE must be one of the following:

6672

6673 clean remove files from the build directory

6674 compile compile a source file into a libtool object

6675 execute automatically set library path, then run a program

6676 finish complete the installation of libtool libraries

6677 install install libraries or executables

6678 link create a library or an executable

6679 uninstall remove libraries from an installed directory

6680

6681 MODE-ARGS vary depending on the MODE. Try \`$modename --help --mode=MODE' for

6682 a more detailed description of MODE.

6683

6684 Report bugs to <bug-libtool@gnu.org>."

6685 exit $EXIT_SUCCESS

6686 ;;

6687

6688 clean)

6689 $echo \

6690 "Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...

6691

6692 Remove files from the build directory.

6693

6694 RM is the name of the program to use to delete files associated with each FILE

6695 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed

6696 to RM.

6697

6698 If FILE is a libtool library, object or program, all the files associated

6699 with it are deleted. Otherwise, only FILE itself is deleted using RM."

6700 ;;

6701

6702 compile)

6703 $echo \

6704 "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE

6705

6706 Compile a source file into a libtool library object.

6707

6708 This mode accepts the following additional options:

6709

6710 -o OUTPUT-FILE set the output file name to OUTPUT-FILE

6711 -prefer-pic try to building PIC objects only

6712 -prefer-non-pic try to building non-PIC objects only

6713 -static always build a \`.o' file suitable for static linking

6714

6715 COMPILE-COMMAND is a command to be used in creating a \`standard' object file

6716 from the given SOURCEFILE.

6717

6718 The output file name is determined by removing the directory component from

6719 SOURCEFILE, then substituting the C source code suffix \`.c' with the

6720 library object suffix, \`.lo'."

6721 ;;

6722

6723 execute)

6724 $echo \

6725 "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...

6726

6727 Automatically set library path, then run a program.

6728

6729 This mode accepts the following additional options:

6730

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

6732

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

6734 flags.

6735

6736 If any of the ARGS are libtool executable wrappers, then they are translated

6737 into their corresponding uninstalled binary, and any of their required library

6738 directories are added to the library path.

6739

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

6741 ;;

6742

6743 finish)

6744 $echo \

6745 "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...

6746

6747 Complete the installation of libtool libraries.

6748

6749 Each LIBDIR is a directory that contains libtool libraries.

6750

6751 The commands that this mode executes may require superuser privileges. Use

6752 the \`--dry-run' option if you just want to see what would be executed."

6753 ;;

6754

6755 install)

6756 $echo \

6757 "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...

6758

6759 Install executables or libraries.

6760

6761 INSTALL-COMMAND is the installation command. The first component should be

6762 either the \`install' or \`cp' program.

6763

6764 The rest of the components are interpreted as arguments to that command (only

6765 BSD-compatible install options are recognized)."

6766 ;;

6767

6768 link)

6769 $echo \

6770 "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...

6771

6772 Link object files or libraries together to form another library, or to

6773 create an executable program.

6774

6775 LINK-COMMAND is a command using the C compiler that you would use to create

6776 a program from several object files.

6777

6778 The following components of LINK-COMMAND are treated specially:

6779

6780 -all-static do not do any dynamic linking at all

6781 -avoid-version do not add a version suffix if possible

6782 -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime

6783 -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols

6784 -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)

6785 -export-symbols SYMFILE

6786 try to export only the symbols listed in SYMFILE

6787 -export-symbols-regex REGEX

6788 try to export only the symbols matching REGEX

6789 -LLIBDIR search LIBDIR for required installed libraries

6790 -lNAME OUTPUT-FILE requires the installed library libNAME

6791 -module build a library that can dlopened

6792 -no-fast-install disable the fast-install mode

6793 -no-install link a not-installable executable

6794 -no-undefined declare that a library does not refer to external symbols

6795 -o OUTPUT-FILE create OUTPUT-FILE from the specified objects

6796 -objectlist FILE Use a list of object files found in FILE to specify objects

6797 -precious-files-regex REGEX

6798 don't remove output files matching REGEX

6799 -release RELEASE specify package release information

6800 -rpath LIBDIR the created library will eventually be installed in LIBDIR

6801 -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries

6802 -static do not do any dynamic linking of libtool libraries

6803 -version-info CURRENT[:REVISION[:AGE]]

6804 specify library version info [each variable defaults to 0]

6805

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

6807

6808 Every other argument is treated as a filename. Files ending in \`.la' are

6809 treated as uninstalled libtool libraries, other files are standard or library

6810 object files.

6811

6812 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,

6813 only library objects (\`.lo' files) may be specified, and \`-rpath' is

6814 required, except when creating a convenience library.

6815

6816 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created

6817 using \`ar' and \`ranlib', or on Windows using \`lib'.

6818

6819 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file

6820 is created, otherwise an executable program is created."

6821 ;;

6822

6823 uninstall)

6824 $echo \

6825 "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...

6826

6827 Remove libraries from an installation directory.

6828

6829 RM is the name of the program to use to delete files associated with each FILE

6830 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed

6831 to RM.

6832

6833 If FILE is a libtool library, all the files associated with it are deleted.

6834 Otherwise, only FILE itself is deleted using RM."

6835 ;;

6836

6837 *)

6838 $echo "$modename: invalid operation mode \`$mode'" 1>&2

6839 $echo "$help" 1>&2

6840 exit $EXIT_FAILURE

6841 ;;

6842 esac

6843

6844 $echo

6845 $echo "Try \`$modename --help' for more information about other modes."

6846

6847 exit $?

6848

6849 # The TAGs below are defined such that we never get into a situation

6850 # in which we disable both kinds of libraries. Given conflicting

6851 # choices, we go for a static library, that is the most portable,

6852 # since we can't tell whether shared libraries were disabled because

6853 # the user asked for that or because the platform doesn't support

6854 # them. This is particularly important on AIX, because we don't

6855 # support having both static and shared libraries enabled at the same

6856 # time on that platform, so we default to a shared-only configuration.

6857 # If a disable-shared tag is given, we'll fallback to a static-only

6858 # configuration. But we'll never go from static-only to shared-only.

6859

6860 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared

6861 disable_libs=shared

6862 # ### END LIBTOOL TAG CONFIG: disable-shared

6863

6864 # ### BEGIN LIBTOOL TAG CONFIG: disable-static

6865 disable_libs=static

6866 # ### END LIBTOOL TAG CONFIG: disable-static

6867

6868 # Local Variables:

6869 # mode:shell-script

6870 # sh-indentation:2

6871 # End:

Mercurial > hg > index.fcgi > gift-gnutella > gift-gnutella-0.0.11-1pba

view ltmain.sh @ 0:d39e1d0d75b6