OpenXM_contrib/gmp/ltmain.sh - diff

Return to ltmain.sh CVS log

Up to [local] / OpenXM_contrib / gmp

Diff for /OpenXM_contrib/gmp/Attic/ltmain.sh between version 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 2000/09/09 14:12:14

version 1.1.1.2, 2003/08/25 16:05:59

Line 1

# ltmain.sh - Provide generalized library-building support services.

# NOTE: Changing this file will not affect anything until you rerun ltconfig.

# NOTE: Changing this file will not affect anything until you rerun configure.

# Free Software Foundation, Inc.

# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996

# This program is free software; you can redistribute it and/or modify

Line 54 modename="$progname"

Line 55 modename="$progname"

# Constants.

PROGRAM=ltmain.sh

PACKAGE=libtool

VERSION=1.3c

VERSION=1.4c

TIMESTAMP=" (1.696 2000/03/14 20:22:42)"

TIMESTAMP=" (1.1066 2001/09/30 10:20:29)"

default_mode=

help="Try \`$progname --help' for more information."

Line 83 if test "${LANG+set}" = set; then

Line 84 if test "${LANG+set}" = set; then

save_LANG="$LANG"; LANG=C; export LANG

if test "$LTCONFIG_VERSION" != "$VERSION"; then

# Make sure IFS has a sensible default

echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2

: ${IFS=" "}

echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2

exit 1

if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then

echo "$modename: not configured to build any kind of library" 1>&2

Line 108 lo2o="s/\\.lo\$/.${objext}/"

Line 106 lo2o="s/\\.lo\$/.${objext}/"

o2lo="s/\\.${objext}\$/.lo/"

# Parse our command line options once, thoroughly.

while test $# -gt 0

while test "$#" -gt 0

arg="$1"

shift

case "$arg" in

case $arg in

-*=*) 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

case "$prev" in

case $prev in

execute_dlfiles)

eval "$prev=\"\$$prev \$arg\""

execute_dlfiles="$execute_dlfiles $arg"

;;

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

;;

esac

;;

eval "$prev=\$arg"

;;

Line 135 do

Line 160 do

# Have we seen a non-optional argument yet?

case "$arg" in

case $arg in

--help)

show_help=yes

;;

--version)

echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"

echo

echo "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."

exit 0

;;

--config)

sed -e '1,/^### BEGIN LIBTOOL CONFIG/d' -e '/^### END LIBTOOL CONFIG/,$d' $0

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

exit 0

;;

Line 183 do

Line 217 do

show=:

;;

--tag) prevopt="--tag" prev=tag ;;

--tag=*)

set tag "$optarg" ${1+"$@"}

shift

prev=tag

;;

-dlopen)

prevopt="-dlopen"

prev=execute_dlfiles

Line 207 if test -n "$prevopt"; then

Line 248 if test -n "$prevopt"; then

exit 1

# 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=

if test -z "$show_help"; then

# Infer the operation mode.

if test -z "$mode"; then

case "$nonopt" in

case $nonopt in

*cc | *++ | gcc* | *-gcc*)

mode=link

for arg

case "$arg" in

case $arg in

-c)

mode=compile

break

Line 261 if test -z "$show_help"; then

Line 307 if test -z "$show_help"; then

help="Try \`$modename --help --mode=$mode' for more information."

# These modes are in order of execution frequency so that they run quickly.

case "$mode" in

case $mode in

# libtool compile mode

compile)

modename="$modename: compile"

Line 275 if test -z "$show_help"; then

Line 321 if test -z "$show_help"; then

user_target=no

for arg

case "$prev" in

case $prev in

"") ;;

xcompiler)

# Aesthetically quote the previous argument.

prev=

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

case "$arg" in

case $arg in

# Double-quote args containing other shell metacharacters.

# Many Bourne shells cannot handle close brackets correctly

# in scan sets, so we specify it separately.

Line 302 if test -z "$show_help"; then

Line 348 if test -z "$show_help"; then

esac

# Accept any command-line options.

case "$arg" in

case $arg in

-o)

if test "$user_target" != "no"; then

$echo "$modename: you cannot specify \`-o' more than once" 1>&2

Line 316 if test -z "$show_help"; then

Line 362 if test -z "$show_help"; then

continue

;;

-prefer-pic)

pic_mode=yes

continue

;;

-prefer-non-pic)

pic_mode=no

continue

;;

-Xcompiler)

prev=xcompiler

continue

Line 324 if test -z "$show_help"; then

Line 380 if test -z "$show_help"; then

-Wc,*)

args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`

lastarg=

IFS="${IFS= }"; save_ifs="$IFS"; IFS=','

save_ifs="$IFS"; IFS=','

for arg in $args; do

IFS="$save_ifs"

# 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

case $arg in

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

arg="\"$arg\""

;;

Line 351 if test -z "$show_help"; then

Line 407 if test -z "$show_help"; then

;;

esac

case "$user_target" in

case $user_target in

next)

# The next one is the -o target name

user_target=yes

Line 379 if test -z "$show_help"; then

Line 435 if test -z "$show_help"; then

# Double-quote args containing other shell metacharacters.

# Many Bourne shells cannot handle close brackets correctly

# in scan sets, so we specify it separately.

case "$lastarg" in

case $lastarg in

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

lastarg="\"$lastarg\""

;;

Line 393 if test -z "$show_help"; then

Line 449 if test -z "$show_help"; then

done

case "$user_target" in

case $user_target in

set)

;;

no)

Line 408 if test -z "$show_help"; then

Line 464 if test -z "$show_help"; then

# Recognize several different file suffixes.

# If the user specifies -o file.o, it is replaced with file.lo

xform='[cCFSfmso]'

xform='[cCFSifmso]'

case "$libobj" in

case $libobj in

*.ada) xform=ada ;;

*.adb) xform=adb ;;

*.ads) xform=ads ;;

*.asm) xform=asm ;;

*.c++) xform=c++ ;;

*.cc) xform=cc ;;

*.ii) xform=ii ;;

*.class) xform=class ;;

*.cpp) xform=cpp ;;

*.cxx) xform=cxx ;;

*.f90) xform=f90 ;;

*.for) xform=for ;;

*.java) xform=java ;;

esac

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

case "$libobj" in

case $libobj in

*.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;

$echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2

Line 432 if test -z "$show_help"; then

Line 491 if test -z "$show_help"; then

;;

esac

# 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

"$CC "*) ;;

# Blanks in the command may have been stripped by the calling shell,

# but not from the CC environment variable when ltconfig was run.

"`$echo $CC` "*) ;;

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 "*)

# 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

;;

"`$echo $CC` "*)

tagname=$z

break

;;

esac

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"

;;

esac

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/

lobj=${xdir}$objdir/$objname

if test -z "$base_compile"; then

$echo "$modename: you must specify a compilation command" 1>&2

$echo "$help" 1>&2

Line 440 if test -z "$show_help"; then

Line 552 if test -z "$show_help"; then

# Delete any leftover library objects.

if test "$build_old_libs" = yes; then

removelist="$obj $libobj"

removelist="$obj $lobj $libobj ${libobj}T"

else

removelist="$libobj"

removelist="$lobj $libobj ${libobj}T"

$run $rm $removelist

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

# 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

if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then

# non-PIC code in shared libraries is not supported

pic_mode=default

# Calculate the filename of the output object if compiler does

# not support -o with -c

if test "$compiler_c_o" = no; then

output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\..*$%%'`.${objext}

output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}

lockfile="$output_obj.lock"

removelist="$removelist $output_obj $lockfile"

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

else

output_obj=

need_locks=no

lockfile=

Line 463 if test -z "$show_help"; then

Line 587 if test -z "$show_help"; then

# 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

until ln "$0" "$lockfile" 2>/dev/null; do

until $run ln "$0" "$lockfile" 2>/dev/null; do

$show "Waiting for $lockfile to be removed"

sleep 2

done

Line 490 compiler."

Line 614 compiler."

eval srcfile=\"$fix_srcfile_path\"

$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

# 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

if test "$pic_mode" != no; then

# All platforms use -DPIC, to notify preprocessed assembler code.

command="$base_compile $srcfile $pic_flag"

command="$base_compile $srcfile $pic_flag -DPIC"

else

# Don't build PIC code

command="$base_compile $srcfile"

if test "$build_old_libs" = yes; then

lo_libobj="$libobj"

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

if test "X$dir" = "X$libobj"; then

dir="$objdir"

else

dir="$dir/$objdir"

libobj="$dir/"`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`

if test -d "$dir"; then

if test ! -d "${xdir}$objdir"; then

$show "$rm $libobj"

$show "$mkdir ${xdir}$objdir"

$run $rm $libobj

$run $mkdir ${xdir}$objdir

else

status=$?

$show "$mkdir $dir"

if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then

$run $mkdir $dir

exit $status

status=$?

if test $status -ne 0 && test ! -d $dir; then

exit $status

if test "$compiler_o_lo" = yes; then

output_obj="$libobj"

if test -z "$output_obj"; then

command="$command -o $output_obj"

# Place PIC objects in $objdir

elif test "$compiler_c_o" = yes; then

command="$command -o $lobj"

output_obj="$obj"

command="$command -o $output_obj"

$run $rm "$output_obj"

$run $rm "$lobj" "$output_obj" 2>/dev/null

$show "$command"

if $run eval "$command"; then :

else

Line 541 compiler."

Line 664 compiler."

if test "$need_locks" = warn &&

test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then

test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then

echo "\

*** ERROR, $lockfile contains:

`cat $lockfile 2>/dev/null`

Line 561 compiler."

Line 684 compiler."

# Just move the object if needed, then go on to compile the next one

if test x"$output_obj" != x"$libobj"; then

if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then

$show "$mv $output_obj $libobj"

$show "$mv $output_obj $lobj"

if $run $mv $output_obj $libobj; then :

if $run $mv $output_obj $lobj; then :

else

error=$?

$run $rm $removelist

Line 571 compiler."

Line 694 compiler."

# If we have no pic_flag, then copy the object into place and finish.

# Append the name of the PIC object to the libtool object file.

if (test -z "$pic_flag" || test "$pic_mode" != default) &&

test -z "$run" && cat >> ${libobj}T <<EOF

test "$build_old_libs" = yes; then

pic_object='$objdir/$objname'

# Rename the .lo from within objdir to obj

if test -f $obj; then

$show $rm $obj

$run $rm $obj

$show "$mv $libobj $obj"

EOF

if $run $mv $libobj $obj; then :

else

error=$?

$run $rm $removelist

exit $error

xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`

if test "X$xdir" = "X$obj"; then

xdir="."

else

xdir="$xdir"

baseobj=`$echo "X$obj" | $Xsed -e "s%.*/%%"`

libobj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`

# Now arrange that obj and lo_libobj become the same file

$show "(cd $xdir && $LN_S $baseobj $libobj)"

if $run eval '(cd $xdir && $LN_S $baseobj $libobj)'; then

exit 0

else

error=$?

$run $rm $removelist

exit $error

# Allow error messages only from the first compilation.

suppress_output=' >/dev/null 2>&1'

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

# Only build a position-dependent object if we build old libraries.

Line 617 compiler."

Line 717 compiler."

# Don't build PIC code

command="$base_compile $srcfile"

else

# All platforms use -DPIC, to notify preprocessed assembler code.

command="$base_compile $srcfile $pic_flag"

command="$base_compile $srcfile $pic_flag -DPIC"

if test "$compiler_c_o" = yes; then

command="$command -o $obj"

output_obj="$obj"

# Suppress compiler output if we already did a PIC compilation.

command="$command$suppress_output"

$run $rm "$output_obj"

$run $rm "$obj" "$output_obj" 2>/dev/null

$show "$command"

if $run eval "$command"; then :

else

Line 636 compiler."

Line 734 compiler."

if test "$need_locks" = warn &&

test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then

test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then

echo "\

*** ERROR, $lockfile contains:

`cat $lockfile 2>/dev/null`

Line 656 compiler."

Line 754 compiler."

# Just move the object if needed

if test x"$output_obj" != x"$obj"; then

if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then

$show "$mv $output_obj $obj"

if $run $mv $output_obj $obj; then :

else

Line 666 compiler."

Line 764 compiler."

# Create an invalid libtool object if no PIC, so that we do not

# Append the name of the non-PIC object the libtool object file.

# accidentally link it into a program.

# Only append if the libtool object file exists.

if test "$build_libtool_libs" != yes; then

test -z "$run" && cat >> ${libobj}T <<EOF

$show "echo timestamp > $libobj"

# Name of the non-PIC object.

$run eval "echo timestamp > \$libobj" || exit $?

non_pic_object='$objname'

else

# Move the .lo from within objdir

EOF

$show "$mv $libobj $lo_libobj"

else

if $run $mv $libobj $lo_libobj; then :

# Append the name of the non-PIC object the libtool object file.

else

# Only append if the libtool object file exists.

error=$?

test -z "$run" && cat >> ${libobj}T <<EOF

$run $rm $removelist

# Name of the non-PIC object.

exit $error

non_pic_object=none

EOF

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

# Unlock the critical section if it was locked

if test "$need_locks" != no; then

$rm "$lockfile"

$run $rm "$lockfile"

exit 0

Line 694 compiler."

Line 794 compiler."

# libtool link mode

link | relink)

modename="$modename: link"

case "$host" in

case $host in

*-*-cygwin* | *-*-mingw* | *-*-os2*)

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

# 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

Line 714 compiler."

Line 814 compiler."

;;

esac

libtool_args="$nonopt"

base_compile="$nonopt"

compile_command="$nonopt"

finalize_command="$nonopt"

Line 743 compiler."

Line 844 compiler."

module=no

no_install=no

objs=

non_pic_objects=

prefer_static_libs=no

preload=no

prev=

Line 758 compiler."

Line 860 compiler."

# We need to know -static, to get the right output filenames.

for arg

case "$arg" in

case $arg in

-all-static | -static)

if test "X$arg" = "X-all-static"; then

if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then

Line 784 compiler."

Line 886 compiler."

test -n "$old_archive_from_new_cmds" && build_old_libs=yes

# Go through the arguments, transforming them on the way.

while test $# -gt 0; do

while test "$#" -gt 0; do

arg="$1"

base_compile="$base_compile $arg"

shift

case "$arg" in

case $arg in

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

qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test

;;

Line 797 compiler."

Line 900 compiler."

# If the previous option needs an argument, assign it.

if test -n "$prev"; then

case "$prev" in

case $prev in

output)

compile_command="$compile_command @OUTPUT@"

finalize_command="$finalize_command @OUTPUT@"

;;

esac

case "$prev" in

case $prev in

dlfiles|dlprefiles)

if test "$preload" = no; then

# Add the symbol object into the linking commands.

Line 812 compiler."

Line 915 compiler."

finalize_command="$finalize_command @SYMFILE@"

preload=yes

case "$arg" in

case $arg in

*.la | *.lo) ;; # We handle these cases below.

force)

if test "$dlself" = no; then

Line 864 compiler."

Line 967 compiler."

prev=

continue

;;

objectlist)

if test -f "$arg"; then

save_arg=$arg

moreargs=

for fil in `cat $save_arg`

# moreargs="$moreargs $fil"

arg=$fil

# A libtool-controlled object.

# Check to see that this really is a libtool object.

if (sed -e '2q' $arg | egrep "^# 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

# Extract subdirectory from the argument.

xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`

if test "X$xdir" = "X$arg"; then

xdir=

else

xdir="$xdir/"

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

# CHECK ME: I think I busted this. -Ossama

if test "$prev" = dlprefiles; then

# Preload the old-style object.

dlprefiles="$dlprefiles $pic_object"

prev=

# A PIC object.

libobjs="$libobjs $pic_object"

arg="$pic_object"

# 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"

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/"

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"

done

else

$echo "$modename: link input file \`$save_arg' does not exist"

exit 1

arg=$save_arg

prev=

continue

;;

rpath | xrpath)

# We need an absolute path.

case "$arg" in

case $arg in

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

$echo "$modename: only absolute run-paths are allowed" 1>&2

Line 908 compiler."

Line 1118 compiler."

continue

;;

esac

fi # test -n "$prev"

prevarg="$arg"

case "$arg" in

case $arg in

-all-static)

if test -n "$link_static_flag"; then

compile_command="$compile_command $link_static_flag"

Line 949 compiler."

Line 1159 compiler."

-export-symbols | -export-symbols-regex)

if test -n "$export_symbols" || test -n "$export_symbols_regex"; then

$echo "$modename: not more than one -exported-symbols argument allowed"

$echo "$modename: more than one -exported-symbols argument is not allowed"

exit 1

if test "X$arg" = "X-export-symbols"; then

Line 960 compiler."

Line 1170 compiler."

continue

;;

# 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

no/*-*-irix* | /*-*-irix*)

compile_command="$compile_command $arg"

finalize_command="$finalize_command $arg"

;;

esac

continue

;;

-L*)

dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`

# We need an absolute path.

case "$dir" in

case $dir in

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

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

Line 981 compiler."

Line 1203 compiler."

lib_search_path="$lib_search_path $dir"

;;

esac

case "$host" in

case $host in

*-*-cygwin* | *-*-mingw* | *-*-os2*)

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

case ":$dllsearchpath:" in

case :$dllsearchpath: in

*":$dir:"*) ;;

*) dllsearchpath="$dllsearchpath:$dir";;

esac

Line 993 compiler."

Line 1215 compiler."

;;

-l*)

if test "$arg" = "-lc"; then

if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then

case "$host" in

case $host in

*-*-cygwin* | *-*-mingw* | *-*-os2* | *-*-beos*)

*-*-cygwin* | *-*-pw32* | *-*-beos*)

# These systems don't actually have c library (as such)

# These systems don't actually have a C or math library (as such)

continue

;;

esac

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

elif test "$arg" = "-lm"; then

# These systems don't actually have a C library (as such)

case "$host" in

test "X$arg" = "X-lc" && continue

*-*-cygwin* | *-*-beos*)

# These systems don't actually have math library (as such)

continue

;;

*-*-openbsd*)

# Do not include libc due to us having libc/libc_r.

test "X$arg" = "X-lc" && continue

;;

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

# Rhapsody C and math libraries are in the System framework

deplibs="$deplibs -framework System"

continue

esac

elif test "X$arg" = "X-lc_r"; then

case $host in

*-*-openbsd*)

# Do not include libc_r directly, use -pthread flag.

continue

;;

esac

deplibs="$deplibs $arg"

continue

Line 1023 compiler."

Line 1257 compiler."

;;

-no-install)

case "$host" in

case $host in

*-*-cygwin* | *-*-mingw* | *-*-os2*)

*-*-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 ;;

no_install=yes

;;

esac

continue

;;

Line 1043 compiler."

Line 1275 compiler."

continue

;;

-objectlist)

prev=objectlist

continue

;;

-o) prev=output ;;

-release)

Line 1063 compiler."

Line 1300 compiler."

-R*)

dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`

# We need an absolute path.

case "$dir" in

case $dir in

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

$echo "$modename: only absolute run-paths are allowed" 1>&2

Line 1078 compiler."

Line 1315 compiler."

;;

-static)

# If we have no pic_flag, then this is the same as -all-static.

# The effects of -static are defined in a previous loop.

if test -z "$pic_flag" && test -n "$link_static_flag"; then

# We used to do the same as -all-static on platforms that

compile_command="$compile_command $link_static_flag"

# didn't have a PIC flag, but the assumption that the effects

finalize_command="$finalize_command $link_static_flag"

# would be equivalent was wrong. It would break on at least

# Digital Unix and AIX.

continue

;;

Line 1099 compiler."

Line 1336 compiler."

-Wc,*)

args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`

arg=

IFS="${IFS= }"; save_ifs="$IFS"; IFS=','

save_ifs="$IFS"; IFS=','

for flag in $args; do

IFS="$save_ifs"

case "$flag" in

case $flag in

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

flag="\"$flag\""

;;

Line 1117 compiler."

Line 1354 compiler."

-Wl,*)

args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`

arg=

IFS="${IFS= }"; save_ifs="$IFS"; IFS=','

save_ifs="$IFS"; IFS=','

for flag in $args; do

IFS="$save_ifs"

case "$flag" in

case $flag in

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

flag="\"$flag\""

;;

Line 1148 compiler."

Line 1385 compiler."

# 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

case $arg in

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

arg="\"$arg\""

;;

Line 1161 compiler."

Line 1398 compiler."

;;

*.lo)

# A library object.

# A libtool-controlled object.

if test "$prev" = dlfiles; then

# This file was specified with -dlopen.

# Check to see that this really is a libtool object.

if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then

if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

dlfiles="$dlfiles $arg"

pic_object=

prev=

non_pic_object=

continue

else

# Read the .lo file

# If libtool objects are unsupported, then we need to preload.

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

prev=dlprefiles

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

if test "$prev" = dlprefiles; then

# Extract subdirectory from the argument.

# Preload the old-style object.

xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`

dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e "$lo2o"`

if test "X$xdir" = "X$arg"; then

prev=

xdir=

else

xdir="$xdir/"

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

# CHECK ME: I think I busted this. -Ossama

if test "$prev" = dlprefiles; then

# Preload the old-style object.

dlprefiles="$dlprefiles $pic_object"

prev=

# A PIC object.

libobjs="$libobjs $pic_object"

arg="$pic_object"

# 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"

else

libobjs="$libobjs $arg"

# 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/"

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"

;;

Line 1212 compiler."

Line 1519 compiler."

# 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

case $arg in

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

arg="\"$arg\""

;;

esac

;;

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"

done

done # argument parsing loop

if test -n "$prev"; then

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

Line 1233 compiler."

Line 1540 compiler."

exit 1

# 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

"$CC "*) ;;

# Blanks in the command may have been stripped by the calling shell,

# but not from the CC environment variable when ltconfig was run.

"`$echo $CC` "*) ;;

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 "*)

# The compiler in $compile_command matches

# the one in the tagged configuration.

# Assume this is the tagged configuration we want.

tagname=$z

break

;;

"`$echo $CC` "*)

tagname=$z

break

;;

esac

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"

;;

esac

if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then

eval arg=\"$export_dynamic_flag_spec\"

compile_command="$compile_command $arg"

Line 1246 compiler."

Line 1597 compiler."

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\'\`

eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`

else

shlib_search_path=

eval sys_lib_search_path=\"$sys_lib_search_path_spec\"

eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"

lib_search_path="$lib_search_path $sys_lib_search_path $shlib_search_path"

output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`

if test "X$output_objdir" = "X$output"; then

Line 1261 compiler."

Line 1611 compiler."

output_objdir="$output_objdir/$objdir"

# Create the object directory.

if test ! -d $output_objdir; then

if test ! -d "$output_objdir"; then

$show "$mkdir $output_objdir"

$run $mkdir $output_objdir

status=$?

if test $status -ne 0 && test ! -d $output_objdir; then

if test "$status" -ne 0 && test ! -d "$output_objdir"; then

exit $status

case "$output" in

# 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)

*.$libext) linkmode=oldlib ;;

linkmode=oldlib ;;

*.lo | *.$objext) linkmode=obj ;;

*.lo | *.$objext)

*.la) linkmode=lib ;;

linkmode=obj ;;

*) linkmode=prog ;; # Anything else should be a program.

*.la)

linkmode=lib ;;

*) # Anything else should be a program.

linkmode=prog ;;

esac

specialdeplibs=

libs=

# Find all interdependent deplibs that

# Find all interdependent deplibs by searching for libraries

# are linked more than once (e.g. -la -lb -la)

# that are linked more than once (e.g. -la -lb -la)

for deplib in $deplibs; do

case "$libs " in

*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

esac

libs="$libs $deplib"

done

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=

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

pre_post_deps=

deplibs=

newdependency_libs=

uninst_path= # paths that contain uninstalled libtool libraries

newlib_search_path=

new_lib_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="link"

passes="conv link"

for file in $dlfiles $dlprefiles; do

case "$file" in

case $file in

*.la) ;;

$echo "$modename: libraries can \`-dlopen' only libtool libraries" 1>&2

$echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2

exit 1

;;

esac

Line 1320 compiler."

Line 1685 compiler."

alldeplibs=no

newdlfiles=

newdlprefiles=

link_against_libtool_libs=

passes="conv scan dlopen dlpreopen link"

passes="scan dlopen dlpreopen link"

;;

*) passes="link"

*) passes="conv"

;;

esac

for pass in $passes; do

if test $linkmode = prog; then

if test "$linkmode,$pass" = "lib,link" ||

test "$linkmode,$pass" = "prog,scan"; then

libs="$deplibs"

deplibs=

if test "$linkmode" = prog; then

case $pass in

dlopen) libs="$dlfiles" ;;

dlpreopen) libs="$dlprefiles" ;;

link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;

esac

if test $pass = dlopen; then

if test "$pass" = dlopen; then

# Collect dlpreopened libraries

save_deplibs="$deplibs"

deplibs=

Line 1342 compiler."

Line 1711 compiler."

for deplib in $libs; do

lib=

found=no

case "$deplib" in

case $deplib in

-l*)

if test $linkmode != lib && test $linkmode != prog; then

if test "$linkmode" != lib && test "$linkmode" != prog; then

$echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2

continue

if test "$pass" = conv; then

deplibs="$deplib $deplibs"

continue

name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`

for searchdir in $lib_search_path; do

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

Line 1358 compiler."

Line 1731 compiler."

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"

test $linkmode = lib && newdependency_libs="$deplib $newdependency_libs"

test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

continue

;;

;; # -l

-L*)

case $linkmode in

lib)

deplibs="$deplib $deplibs"

test "$pass" = conv && continue

newdependency_libs="$deplib $newdependency_libs"

new_lib_search_path="$new_lib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`

newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`

;;

prog)

if test $pass = scan; then

if test "$pass" = conv; then

deplibs="$deplib $deplibs"

new_lib_search_path="$new_lib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`

continue

if test "$pass" = scan; then

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"

Line 1387 compiler."

Line 1766 compiler."

$echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2

;;

esac

esac # linkmode

continue

;;

;; # -L

-R*)

if test "$linkmode,$pass" = "prog,link"; then

if test "$pass" = link; then

dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`

# Make sure the xrpath contains only unique directories.

case "$xrpath " in

Line 1399 compiler."

Line 1778 compiler."

*) xrpath="$xrpath $dir" ;;

esac

deplibs="$deplib $deplibs"

continue

;;

*.la) lib="$deplib" ;;

*.$libext)

if test "$pass" = conv; then

deplibs="$deplib $deplibs"

continue

case $linkmode in

lib)

if test "$deplibs_check_method" != pass_all; then

echo

echo "*** Warning: This library needs some functionality provided by $deplib."

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 "*** 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."

else

echo

echo "*** Warning: Linking the shared library $output against the"

Line 1420 compiler."

Line 1806 compiler."

continue

;;

prog)

if test $pass != link; then

if test "$pass" != link; then

deplibs="$deplib $deplibs"

else

compile_deplibs="$deplib $compile_deplibs"

Line 1428 compiler."

Line 1814 compiler."

continue

;;

esac

esac # linkmode

;;

;; # *.$libext

*.lo | *.$objext)

if test $linkmode = prog; then

if test "$pass" = conv; then

if test $pass = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; 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"

Line 1448 compiler."

Line 1836 compiler."

alldeplibs=yes

continue

;;

esac

esac # case $deplib

if test $found = yes || test -f "$lib"; then :

if test "$found" = yes || test -f "$lib"; then :

else

$echo "$modename: cannot find the library \`$lib'" 1>&2

exit 1

Line 1476 compiler."

Line 1864 compiler."

installed=yes

# Read the .la file

case "$lib" in

case $lib in

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

*) . ./$lib ;;

esac

if test $linkmode = lib || test "$linkmode,$pass" = "prog,scan"; then

if test "$linkmode,$pass" = "lib,link" ||

test "$linkmode,$pass" = "prog,scan" ||

{ test "$linkmode" != prog && test "$linkmode" != lib; }; then

test -n "$dlopen" && dlfiles="$dlfiles $dlopen"

test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"

if test $linkmode != lib && test $linkmode != prog; then

if test "$pass" = conv; then

# only check for convenience libraries

# Only check for convenience libraries

if test -z "$old_library"; then

deplibs="$lib $deplibs"

$echo "$modename: cannot find name of link library for \`$lib'" 1>&2

if test -z "$libdir"; then

exit 1

if test -z "$old_library"; then

$echo "$modename: cannot find name of link library for \`$lib'" 1>&2

if test -n "$libdir"; then

exit 1

# 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"

case "$tmp_libs " in

*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

esac

tmp_libs="$tmp_libs $deplib"

done

elif test "$linkmode" != prog && test "$linkmode" != lib; then

$echo "$modename: \`$lib' is not a convenience library" 1>&2

exit 1

# 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"

continue

fi # $pass = conv

# Get the name of the library we link against.

linklib=

Line 1513 compiler."

Line 1913 compiler."

# This library was specified with -dlopen.

if test $pass = dlopen; then

if test "$pass" = dlopen; then

if test -z "$libdir"; then

$echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2

exit 1

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 statically,

# If there is no dlname, no dlopen support or we're linking

# we need to preload.

# statically, we need to preload. We also need to preload any

dlprefiles="$dlprefiles $lib"

# dependent libraries so libltdl's deplib preloader doesn't

# bomb out in the load deplibs phase.

dlprefiles="$dlprefiles $lib $dependency_libs"

else

newdlfiles="$newdlfiles $lib"

continue

fi # $pass = dlopen

# We need an absolute path.

case "$ladir" in

case $ladir in

[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;

abs_ladir=`cd "$ladir" && pwd`

Line 1553 compiler."

Line 1959 compiler."

dir="$ladir/$objdir"

absdir="$abs_ladir/$objdir"

# Remove this search path later

uninst_path="$uninst_path $abs_ladir"

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.

if test $pass = dlpreopen; then

if test "$pass" = dlpreopen; then

if test -z "$libdir"; then

$echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2

exit 1

# Prefer using a static library (so that no silly _DYNAMIC symbols

# are required to link).

if test -n "$old_library"; then

newdlprefiles="$newdlprefiles $dir/$old_library"

# Otherwise, use the dlname, so that lt_dlopen finds it.

elif test -n "$dlname"; then

newdlprefiles="$newdlprefiles $dir/$dlname"

else

newdlprefiles="$newdlprefiles $dir/$linklib"

fi # $pass = dlpreopen

if test -z "$libdir"; then

# Link the convenience library

if test "$linkmode" = lib; then

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

deplibs="$lib $deplibs" # used for prog,scan pass

continue

if test $linkmode = prog && test $pass != link; then

if test "$linkmode" = prog && test "$pass" != link; then

new_lib_search_path="$new_lib_search_path $ladir"

newlib_search_path="$newlib_search_path $ladir"

deplibs="$lib $deplibs"

linkalldeplibs=no

if test "$link_all_deplibs" != no || test "$fast_install" != no || \

if test "$link_all_deplibs" != no || test -z "$library_names" ||

test "$build_libtool_libs" = no || test -z "$library_names"; then

test "$build_libtool_libs" = no; then

linkalldeplibs=yes

tmp_libs=

for deplib in $dependency_libs; do

case "$deplib" in

case $deplib in

-L*) new_lib_search_path="$new_lib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test

-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?

if test $linkalldeplibs = yes; then

if test "$linkalldeplibs" = yes; then

deplibs="$deplib $deplibs"

else

# Need to hardcode shared library paths

Line 1595 compiler."

Line 2021 compiler."

*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

esac

tmp_libs="$tmp_libs $deplib"

done

done # for deplib

continue

fi # $linkmode = prog...

if test -z "$libdir"; then

# It is a libtool convenience library, so add in its objects.

convenience="$convenience $dir/$old_library"

old_convenience="$old_convenience $dir/$old_library"

if test $linkmode = lib; then

deplibs="$dir/$old_library $deplibs"

tmp_libs=

for deplib in $dependency_libs; do

newdependency_libs="$deplib $newdependency_libs"

case "$tmp_libs " in

*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

esac

tmp_libs="$tmp_libs $deplib"

done

elif test "$linkmode,$pass" = "prog,link"; then

compile_deplibs="$dir/$old_library $compile_deplibs"

finalize_deplibs="$dir/$old_library $finalize_deplibs"

continue

if test "$linkmode,$pass" = "prog,link"; then

if test -n "$library_names" &&

{ test "$hardcode_into_libs" != all || test "$alldeplibs" != yes; } &&

{ test "$prefer_static_libs" = no || test -z "$old_library"; }; then

# We need to hardcode the library path

if test -n "$shlibpath_var"; then

Line 1646 compiler."

Line 2050 compiler."

esac

;;

esac

case " $sys_lib_dlsearch_path " in

*" $libdir "*) ;;

Line 1656 compiler."

Line 2059 compiler."

esac

;;

esac

fi # $linkmode,$pass = prog,link...

if test "$alldeplibs" = yes &&

{ test "$deplibs_check_method" = pass_all ||

{ test "$build_libtool_libs" = yes &&

test -n "$library_names"; }; }; then

# Do we only need to link against static libraries?

# We only need to search for static libraries

continue

link_static=no # Whether this library is linked statically

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

link_against_libtool_libs="$link_against_libtool_libs $lib"

if test "$installed" = no; then

test "X$installed" = xno && need_relink=yes

notinst_deplibs="$notinst_deplibs $lib"

need_relink=yes

# This is a shared library

if test $linkmode = lib && test "$hardcode_into_libs" = all; then

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.

Line 1703 compiler."

Line 2109 compiler."

realname="$2"

shift; shift

libname=`eval \\$echo \"$libname_spec\"`

if test -n "$soname_spec"; then

# 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

*cygwin*)

major=`expr $current - $age`

versuffix="-$major"

;;

esac

eval soname=\"$soname_spec\"

else

soname="$realname"

# Make a new name for the extract_expsyms_cmds to use

soroot="$soname"

soname=`echo $soroot | sed -e 's/^.*\///'`

newlib="libimp-`echo $soname | sed 's/^lib//;s/\.dll$//'`.a"

# 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'"

IFS="${IFS= }"; save_ifs="$IFS"; IFS='~'

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

eval cmds=\"$extract_expsyms_cmds\"

for cmd in $cmds; do

IFS="$save_ifs"

Line 1729 compiler."

Line 2147 compiler."

# Create $newlib

if test -f "$output_objdir/$newlib"; then :; else

$show "generating import library for \`$soname'"

IFS="${IFS= }"; save_ifs="$IFS"; IFS='~'

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

eval cmds=\"$old_archive_from_expsyms_cmds\"

for cmd in $cmds; do

IFS="$save_ifs"

Line 1741 compiler."

Line 2159 compiler."

# make sure the library variables are pointing to the new library

dir=$output_objdir

linklib=$newlib

fi # test -n "$old_archive_from_expsyms_cmds"

if test $linkmode = prog || test "$mode" != relink; then

if test "$linkmode" = prog || test "$mode" != relink; then

add_shlibpath=

add_dir=

add=

lib_linked=yes

case "$hardcode_action" in

case $hardcode_action in

immediate | unsupported)

if test "$hardcode_direct" = no; then

add="$dir/$linklib"

elif test "$hardcode_minus_L" = no; then

case "$host" in

case $host in

*-*-sunos*) add_shlibpath="$dir" ;;

esac

add_dir="-L$dir"

Line 1787 compiler."

Line 2205 compiler."

if test -n "$add_shlibpath"; then

case ":$compile_shlibpath:" in

case :$compile_shlibpath: in

*":$add_shlibpath:"*) ;;

*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;

esac

if test $linkmode = prog; then

if test "$linkmode" = prog; then

test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"

test -n "$add" && compile_deplibs="$add $compile_deplibs"

else

Line 1801 compiler."

Line 2219 compiler."

if test "$hardcode_direct" != yes && \

test "$hardcode_minus_L" != yes && \

test "$hardcode_shlibpath_var" = yes; then

case ":$finalize_shlibpath:" in

case :$finalize_shlibpath: in

*":$libdir:"*) ;;

*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;

esac

Line 1809 compiler."

Line 2227 compiler."

if test $linkmode = prog || test "$mode" = relink; then

if test "$linkmode" = prog || test "$mode" = relink; then

add_shlibpath=

add_dir=

add=

Line 1820 compiler."

Line 2238 compiler."

add_dir="-L$libdir"

add="-l$name"

elif test "$hardcode_shlibpath_var" = yes; then

case ":$finalize_shlibpath:" in

case :$finalize_shlibpath: in

*":$libdir:"*) ;;

*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;

esac

Line 1831 compiler."

Line 2249 compiler."

add="-l$name"

if test $linkmode = prog; then

if test "$linkmode" = prog; then

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"

test -n "$add" && deplibs="$add $deplibs"

elif test $linkmode = prog; then

elif test "$linkmode" = prog; then

# 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.

Line 1856 compiler."

Line 2274 compiler."

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.

echo

echo "*** Warning: This library needs some functionality provided by $lib."

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."

if test "$module" = yes; then

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."

if test -z "$global_symbol_pipe"; then

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."

if test "$build_old_libs" = no; then

build_libtool_libs=module

build_old_libs=yes

else

build_libtool_libs=no

else

convenience="$convenience $dir/$old_library"

old_convenience="$old_convenience $dir/$old_library"

deplibs="$dir/$old_library $deplibs"

link_static=yes

fi # link shared/static library?

if test $linkmode = lib; then

if test "$linkmode" = lib; then

if test -n "$dependency_libs" &&

{ test "$hardcode_into_libs" = no || test $build_old_libs = yes ||

{ test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes ||

test $link_static = yes; }; then

test "$link_static" = yes; }; then

# Extract -R from dependency_libs

temp_deplibs=

for libdir in $dependency_libs; do

case "$libdir" in

case $libdir in

-R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`

case " $xrpath " in

*" $temp_xrpath "*) ;;

Line 1890 compiler."

Line 2327 compiler."

dependency_libs="$temp_deplibs"

new_lib_search_path="$new_lib_search_path $absdir"

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

Line 1903 compiler."

Line 2340 compiler."

tmp_libs="$tmp_libs $deplib"

done

if test $link_all_deplibs != no; then

if test "$link_all_deplibs" != no; then

# Add the search paths of all dependency libraries

for deplib in $dependency_libs; do

case "$deplib" in

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

case $dir in

[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;

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

Line 1943 compiler."

Line 2380 compiler."

*) deplibs="$deplibs $path" ;;

esac

done

fi # link_all_deplibs != no

fi # linkmode = lib

done

done # for deplib in $libs

dependency_libs="$newdependency_libs"

if test $pass = dlpreopen; then

if test "$pass" = dlpreopen; then

# Link the dlpreopened libraries before other libraries

deplibs="$deplibs $save_deplibs"

for deplib in $save_deplibs; do

elif test $pass != dlopen; then

deplibs="$deplib $deplibs"

# Make sure lib_search_path contains only unique directories.

lib_search_path=

for dir in $new_lib_search_path; do

case "$lib_search_path " in

*" $dir "*) ;;

*) lib_search_path="$lib_search_path $dir" ;;

esac

done

lib_search_path="$lib_search_path $sys_lib_search_path"

if test "$pass" != dlopen; then

if test "$pass" != conv; then

# 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=

if test "$linkmode,$pass" != "prog,link"; then

vars="deplibs"

Line 1967 compiler."

Line 2409 compiler."

vars="compile_deplibs finalize_deplibs"

for var in $vars dependency_libs; do

# Make sure that $var contains only unique libraries

# Add libraries to $var in reverse order

# and add them in reverse order

eval tmp_libs=\"\$$var\"

new_libs=

for deplib in $tmp_libs; do

case "$deplib" in

# 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:

case $deplib in

-L*) new_libs="$deplib $new_libs" ;;

# 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.

case " $specialdeplibs " in

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

Line 1989 compiler."

Line 2450 compiler."

done

tmp_libs=

for deplib in $new_libs; do

case "$deplib" in

case $deplib in

-L*)

case " $tmp_libs " in

*" $deplib "*) ;;

Line 2000 compiler."

Line 2461 compiler."

esac

done

eval $var=\"$tmp_libs\"

done

done # for var

done

done # for pass

if test $linkmode = prog; then

if test "$linkmode" = prog; then

dlfiles="$newdlfiles"

dlprefiles="$newdlprefiles"

Line 2046 compiler."

Line 2507 compiler."

lib)

# Make sure we only generate libraries of the form `libNAME.la'.

case "$outputname" in

case $outputname in

lib*)

name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`

eval libname=\"$libname_spec\"

Line 2084 compiler."

Line 2545 compiler."

set dummy $rpath

if test $# -gt 2; then

if test "$#" -gt 2; then

$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2

install_libdir="$2"

Line 2093 compiler."

Line 2554 compiler."

if test -z "$rpath"; then

if test "$build_libtool_libs" = yes; then

# Building a libtool convenience library.

libext=al

# Some compilers have problems with a `.al' extension so

# convenience libraries should have the same extension an

# archive normally would.

oldlibs="$output_objdir/$libname.$libext $oldlibs"

build_libtool_libs=convenience

build_old_libs=yes

Line 2109 compiler."

Line 2572 compiler."

else

# Parse the version information argument.

IFS="${IFS= }"; save_ifs="$IFS"; IFS=':'

save_ifs="$IFS"; IFS=':'

set dummy $vinfo 0 0 0

IFS="$save_ifs"

Line 2124 compiler."

Line 2587 compiler."

age="$4"

# Check that each of the things are valid numbers.

case "$current" in

case $current in

0 | [1-9] | [1-9][0-9]*) ;;

0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;

$echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2

$echo "$modename: \`$vinfo' is not valid version information" 1>&2

Line 2133 compiler."

Line 2596 compiler."

;;

esac

case "$revision" in

case $revision in

0 | [1-9] | [1-9][0-9]*) ;;

0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;

$echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2

$echo "$modename: \`$vinfo' is not valid version information" 1>&2

Line 2142 compiler."

Line 2605 compiler."

;;

esac

case "$age" in

case $age in

0 | [1-9] | [1-9][0-9]*) ;;

0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;

$echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2

$echo "$modename: \`$vinfo' is not valid version information" 1>&2

Line 2151 compiler."

Line 2614 compiler."

;;

esac

if test $age -gt $current; then

if test "$age" -gt "$current"; then

$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

Line 2161 compiler."

Line 2624 compiler."

major=

versuffix=

verstring=

case "$version_type" in

case $version_type in

none) ;;

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";

;;

irix)

major=`expr $current - $age + 1`

versuffix="$major.$revision"

verstring="sgi$major.$revision"

# Add in all the interfaces that we are compatible with.

loop=$revision

while test $loop != 0; do

while test "$loop" -ne 0; do

iface=`expr $revision - $loop`

loop=`expr $loop - 1`

verstring="sgi$major.$iface:$verstring"

done

# Before this point, $major must not contain `.'.

major=.$major

versuffix="$major.$revision"

;;

linux)

Line 2190 compiler."

Line 2676 compiler."

# Add in all the interfaces that we are compatible with.

loop=$age

while test $loop != 0; do

while test "$loop" -ne 0; do

iface=`expr $current - $loop`

loop=`expr $loop - 1`

verstring="$verstring:${iface}.0"

Line 2205 compiler."

Line 2691 compiler."

versuffix=".$current.$revision"

;;

freebsd-aout)

major=".$current"

versuffix=".$current.$revision";

;;

freebsd-elf)

major=".$current"

versuffix=".$current";

;;

windows)

# Like Linux, but with '-' rather than '.', since we only

# Use '-' rather than '.', since we only want one

# want one extension on Windows 95.

# extension on DOS 8.3 filesystems.

major=`expr $current - $age`

versuffix="-$major-$age-$revision"

versuffix="-$major"

;;

Line 2232 compiler."

Line 2708 compiler."

# Clear the version info if we defaulted, and they specified a release.

if test -z "$vinfo" && test -n "$release"; then

major=

verstring="0.0"

case $version_type in

darwin)

# we can't check for "0.0" in archive_cmds due to quoting

# problems, so we reset it completely

verstring=

;;

verstring="0.0"

;;

esac

if test "$need_version" = no; then

versuffix=

else

Line 2261 compiler."

Line 2746 compiler."

if test "$mode" != relink; then

# Remove our outputs.

# Remove our outputs, but don't remove object files since they

$show "${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*"

# may have been created when compiling PIC objects.

$run ${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*

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

# Now set the variables for building old libraries.

Line 2275 compiler."

Line 2775 compiler."

# Eliminate all temporary directories.

for path in $uninst_path; do

for path in $notinst_path; do

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'`

Line 2291 compiler."

Line 2791 compiler."

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

esac

done

if test "$hardcode_into_libs" = no || test $build_old_libs = yes; then

if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then

dependency_libs="$temp_xrpath $dependency_libs"

Line 2318 compiler."

Line 2818 compiler."

if test "$build_libtool_libs" = yes; then

if test -n "$rpath"; then

case "$host" in

case $host in

*-*-cygwin* | *-*-mingw* | *-*-os2* | *-*-beos*)

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

# these systems don't actually have a c library (as such)!

;;

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

# Add libc to deplibs on all other systems.

# Rhapsody C library is in the System framework

deplibs="$deplibs -lc"

deplibs="$deplibs -framework System"

;;

*-*-netbsd*)

# Don't link with libc until the a.out ld.so is fixed.

;;

*-*-openbsd*)

# Do not include libc due to us having libc/libc_r.

test "X$arg" = "X-lc" && continue

;;

# Add libc to deplibs on all other systems if necessary.

if test "$build_libtool_need_lc" = "yes"; then

deplibs="$deplibs -lc"

;;

esac

Line 2343 compiler."

Line 2856 compiler."

major=""

newdeplibs=

droppeddeps=no

case "$deplibs_check_method" in

case $deplibs_check_method in

pass_all)

# Don't check for shared/static. Everything works.

# This might be a little naive. We might want to check

Line 2362 compiler."

Line 2875 compiler."

int main() { return 0; }

EOF

$rm conftest

$CC -o conftest conftest.c $deplibs

$LTCC -o conftest conftest.c $deplibs

if test $? -eq 0 ; then

if test "$?" -eq 0 ; then

ldd_output=`ldd conftest`

for i in $deplibs; do

name="`expr $i : '-l$.*$'`"

# If $name is empty we are operating on a -L argument.

if test "$name" != "" ; then

if test "$name" != "" -a "$name" -ne "0"; then

libname=`eval \\$echo \"$libname_spec\"`

deplib_matches=`eval \\$echo \"$library_names_spec\"`

set dummy $deplib_matches

Line 2378 EOF

Line 2891 EOF

else

droppeddeps=yes

echo

echo "*** Warning: This library needs some functionality provided by $i."

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 "*** 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."

else

newdeplibs="$newdeplibs $i"

Line 2393 EOF

Line 2908 EOF

for i in $deplibs; do

name="`expr $i : '-l$.*$'`"

# If $name is empty we are operating on a -L argument.

if test "$name" != "" ; then

if test "$name" != "" -a "$name" != "0"; then

$rm conftest

$CC -o conftest conftest.c $i

$LTCC -o conftest conftest.c $i

# Did it work?

if test $? -eq 0 ; then

if test "$?" -eq 0 ; then

ldd_output=`ldd conftest`

libname=`eval \\$echo \"$libname_spec\"`

deplib_matches=`eval \\$echo \"$library_names_spec\"`

Line 2408 EOF

Line 2923 EOF

else

droppeddeps=yes

echo

echo "*** Warning: This library needs some functionality provided by $i."

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 "*** 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."

else

droppeddeps=yes

Line 2433 EOF

Line 2950 EOF

for a_deplib in $deplibs; do

name="`expr $a_deplib : '-l$.*$'`"

# If $name is empty we are operating on a -L argument.

if test "$name" != "" ; then

if test "$name" != "" -a "$name" != "0"; then

libname=`eval \\$echo \"$libname_spec\"`

for i in $lib_search_path; do

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

# Follow soft links.

Line 2451 EOF

Line 2968 EOF

potlib="$potent_lib"

while test -h "$potlib" 2>/dev/null; do

potliblink=`ls -ld $potlib | sed 's/.* -> //'`

case "$potliblink" in

case $potliblink in

[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;

*) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;

esac

Line 2468 EOF

Line 2985 EOF

if test -n "$a_deplib" ; then

droppeddeps=yes

echo

echo "*** Warning: This library needs some functionality provided by $a_deplib."

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 "*** 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"

else

# Add a -L argument.

Line 2479 EOF

Line 3003 EOF

done # Gone through all deplibs.

;;

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

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

done

if test -n "$a_deplib" ; then

droppeddeps=yes

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"

else

# Add a -L argument.

newdeplibs="$newdeplibs $a_deplib"

done # Gone through all deplibs.

;;

none | unknown | *)

newdeplibs=""

if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \

Line 2501 EOF

Line 3067 EOF

libname=$libname_save

name=$name_save

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

if test "$droppeddeps" = yes; then

if test "$module" = yes; then

echo

Line 2526 EOF

Line 3099 EOF

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."

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

# Done checking deplibs!

Line 2539 EOF

Line 3127 EOF

# Test again, we may have decided not to build it any more

if test "$build_libtool_libs" = yes; then

if test "$hardcode_into_libs" != no; then

if test "$hardcode_into_libs" = yes; then

# Hardcode the library paths

hardcode_libdirs=

dep_rpath=

Line 2552 EOF

Line 3140 EOF

hardcode_libdirs="$libdir"

else

# Just accumulate the unique libdirs.

case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

;;

Line 2605 EOF

Line 3193 EOF

else

soname="$realname"

if test -z "$dlname"; then

dlname=$soname

lib="$output_objdir/$realname"

for link

Line 2612 EOF

Line 3203 EOF

linknames="$linknames $link"

done

# Ensure that we have .o objects for linkers which dislike .lo

# (e.g. aix) in case we are running --disable-static

for obj in $libobjs; do

xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`

if test "X$xdir" = "X$obj"; then

xdir="."

else

xdir="$xdir"

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

oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`

if test ! -f $xdir/$oldobj; then

$show "(cd $xdir && ${LN_S} $baseobj $oldobj)"

$run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?

done

# Use standard objects if they are pic

test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

Line 2639 EOF

Line 3213 EOF

export_symbols="$output_objdir/$libname.exp"

$run $rm $export_symbols

eval cmds=\"$export_symbols_cmds\"

IFS="${IFS= }"; save_ifs="$IFS"; IFS='~'

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

for cmd in $cmds; do

IFS="$save_ifs"

$show "$cmd"

Line 2661 EOF

Line 3235 EOF

if test -n "$convenience"; then

if test -n "$whole_archive_flag_spec"; then

save_libobjs=$libobjs

eval libobjs=\"\$libobjs $whole_archive_flag_spec\"

else

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

$show "${rm}r $gentop"

$run ${rm}r "$gentop"

$show "mkdir $gentop"

$show "$mkdir $gentop"

$run mkdir "$gentop"

$run $mkdir "$gentop"

status=$?

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

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

exit $status

generated="$generated $gentop"

for xlib in $convenience; do

# Extract the objects.

case "$xlib" in

case $xlib in

[\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;

*) xabs=`pwd`"/$xlib" ;;

esac

Line 2685 EOF

Line 3260 EOF

$show "${rm}r $xdir"

$run ${rm}r "$xdir"

$show "mkdir $xdir"

$show "$mkdir $xdir"

$run mkdir "$xdir"

$run $mkdir "$xdir"

status=$?

if test $status -ne 0 && test ! -d "$xdir"; then

if test "$status" -ne 0 && test ! -d "$xdir"; then

exit $status

$show "(cd $xdir && $AR x $xabs)"

$run eval "(cd \$xdir && $AR x \$xabs)" || exit $?

libobjs="$libobjs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`

libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`

done

Line 2705 EOF

Line 3280 EOF

# Make a backup of the uninstalled library when relinking

if test "$mode" = relink && test "$hardcode_into_libs" = all; then

if test "$mode" = relink; then

$run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?

Line 2715 EOF

Line 3290 EOF

else

eval cmds=\"$archive_cmds\"

IFS="${IFS= }"; save_ifs="$IFS"; IFS='~'

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 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

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

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\"

last_robj=$output_objdir/$save_output-${k}.$objext

k=`expr $k + 1`

output=$output_objdir/$save_output-${k}.$objext

objlist=$obj

len=1

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\"

# Set up a command to remove the reloadale object files

# after they are used.

i=0

while test "$i" -lt "$k"

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\"

# 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\"

# Append the command to remove the reloadable object files

# to the just-reset $cmds.

eval cmds=\"\$cmds~$rm $delfiles\"

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

for cmd in $cmds; do

IFS="$save_ifs"

$show "$cmd"

Line 2724 EOF

Line 3402 EOF

IFS="$save_ifs"

# Restore the uninstalled library and exit

if test "$mode" = relink && test "$hardcode_into_libs" = all; then

if test "$mode" = relink; then

$run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?

exit 0

Line 2770 EOF

Line 3448 EOF

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

case "$output" in

case $output in

*.lo)

if test -n "$objs$old_deplibs"; then

$echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2

Line 2805 EOF

Line 3483 EOF

gentop="$output_objdir/${obj}x"

$show "${rm}r $gentop"

$run ${rm}r "$gentop"

$show "mkdir $gentop"

$show "$mkdir $gentop"

$run mkdir "$gentop"

$run $mkdir "$gentop"

status=$?

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

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

exit $status

generated="$generated $gentop"

for xlib in $convenience; do

# Extract the objects.

case "$xlib" in

case $xlib in

[\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;

*) xabs=`pwd`"/$xlib" ;;

esac

Line 2824 EOF

Line 3502 EOF

$show "${rm}r $xdir"

$run ${rm}r "$xdir"

$show "mkdir $xdir"

$show "$mkdir $xdir"

$run mkdir "$xdir"

$run $mkdir "$xdir"

status=$?

if test $status -ne 0 && test ! -d "$xdir"; then

if test "$status" -ne 0 && test ! -d "$xdir"; then

exit $status

$show "(cd $xdir && $AR x $xabs)"

$run eval "(cd \$xdir && $AR x \$xabs)" || exit $?

reload_conv_objs="$reload_objs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`

reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`

done

Line 2843 EOF

Line 3521 EOF

output="$obj"

eval cmds=\"$reload_cmds\"

IFS="${IFS= }"; save_ifs="$IFS"; IFS='~'

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

for cmd in $cmds; do

IFS="$save_ifs"

$show "$cmd"

Line 2869 EOF

Line 3547 EOF

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

# accidentally link it into a program.

$show "echo timestamp > $libobj"

# $show "echo timestamp > $libobj"

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

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

exit 0

Line 2879 EOF

Line 3557 EOF

reload_objs="$libobjs $reload_conv_objs"

output="$libobj"

eval cmds=\"$reload_cmds\"

IFS="${IFS= }"; save_ifs="$IFS"; IFS='~'

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

for cmd in $cmds; do

IFS="$save_ifs"

$show "$cmd"

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

done

IFS="$save_ifs"

else

# Just create a symlink.

$show $rm $libobj

$run $rm $libobj

xdir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`

if test "X$xdir" = "X$libobj"; then

xdir="."

else

xdir="$xdir"

baseobj=`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`

oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`

$show "(cd $xdir && $LN_S $oldobj $baseobj)"

$run eval '(cd $xdir && $LN_S $oldobj $baseobj)' || exit $?

if test -n "$gentop"; then

Line 2911 EOF

Line 3575 EOF

;;

prog)

case $host in

*cygwin*) output=`echo $output | sed -e 's,.exe$,,;s,$,.exe,'` ;;

esac

if test -n "$vinfo"; then

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

Line 2926 EOF

Line 3593 EOF

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

compile_command="$compile_command $compile_deplibs"

finalize_command="$finalize_command $finalize_deplibs"

Line 2950 EOF

Line 3625 EOF

hardcode_libdirs="$libdir"

else

# Just accumulate the unique libdirs.

case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

;;

Line 2968 EOF

Line 3643 EOF

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

esac

case "$host" in

case $host in

*-*-cygwin* | *-*-mingw* | *-*-os2*)

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

case ":$dllsearchpath:" in

case :$dllsearchpath: in

*":$libdir:"*) ;;

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

esac

Line 2994 EOF

Line 3669 EOF

hardcode_libdirs="$libdir"

else

# Just accumulate the unique libdirs.

case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

;;

Line 3037 EOF

Line 3712 EOF

if test -n "$dlsyms"; then

case "$dlsyms" in

case $dlsyms in

"") ;;

*.c)

# Discover the nlist of each of the dlfiles.

Line 3131 extern \"C\" {

Line 3806 extern \"C\" {

#undef lt_preloaded_symbols

#if defined (__STDC__) && __STDC__

# define lt_ptr_t void *

# define lt_ptr void *

#else

# define lt_ptr_t char *

# define lt_ptr char *

# define const

#endif

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

const struct {

const char *name;

lt_ptr_t address;

lt_ptr address;

}

lt_preloaded_symbols[] =

sed -n -e 's/^: $[^ ]*$ $/ {\"\1\", (lt_ptr_t) 0},/p' \

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

-e 's/^. $[^ ]*$ $[^ ]*$$/ {"\2", (lt_ptr_t) \&\2},/p' \

< "$nlist" >> "$output_objdir/$dlsyms"

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

{0, (lt_ptr_t) 0}

{0, (lt_ptr) 0}

};

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

Line 3168 static const void *lt_preloaded_setup() {

Line 3841 static const void *lt_preloaded_setup() {

pic_flag_for_symtable=

case "$host" in

case $host in

# 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

Line 3177 static const void *lt_preloaded_setup() {

Line 3850 static const void *lt_preloaded_setup() {

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

case "$compile_command " in

*" -static "*) ;;

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

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

esac;;

*-*-hpux*)

case "$compile_command " in

*" -static "*) ;;

*) pic_flag_for_symtable=" $pic_flag -DPIC";;

*) pic_flag_for_symtable=" $pic_flag";;

esac

# Now compile the dynamic symbol file.

$show "(cd $output_objdir && $CC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"

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

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

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

# Clean up the generated files.

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

Line 3213 static const void *lt_preloaded_setup() {

Line 3886 static const void *lt_preloaded_setup() {

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

if test -z "$link_against_libtool_libs" || test "$build_libtool_libs" != yes; then

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

# Replace the output file specification.

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

link_command="$compile_command$compile_rpath"

Line 3236 static const void *lt_preloaded_setup() {

Line 3909 static const void *lt_preloaded_setup() {

# We should set the shlibpath_var

rpath=

for dir in $temp_rpath; do

case "$dir" in

case $dir in

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

# Absolute path.

rpath="$rpath$dir:"

Line 3291 static const void *lt_preloaded_setup() {

Line 3964 static const void *lt_preloaded_setup() {

exit 0

if test "$hardcode_action" = relink || test "$hardcode_into_libs" = all; then

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"

Line 3327 static const void *lt_preloaded_setup() {

Line 4000 static const void *lt_preloaded_setup() {

# Quote the relink command for shipping.

if test -n "$relink_command"; then

# 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"

done

relink_command="cd `pwd`; $relink_command"

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

# Quote $echo for shipping.

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

case "$0" in

case $0 in

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

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

esac

Line 3349 static const void *lt_preloaded_setup() {

Line 4033 static const void *lt_preloaded_setup() {

case $output in

*.exe) output=`echo $output|sed 's,.exe$,,'` ;;

esac

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

case $host in

*cygwin*) exeext=.exe ;;

*) exeext= ;;

esac

$rm $output

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

Line 3378 relink_command=\"$relink_command\"

Line 4067 relink_command=\"$relink_command\"

# This environment variable determines our operation mode.

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

# install mode needs the following variable:

link_against_libtool_libs='$link_against_libtool_libs'

notinst_deplibs='$notinst_deplibs'

else

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

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

Line 3411 else

Line 4100 else

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

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

case \"\$destdir\" in

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

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

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

esac

Line 3427 else

Line 4116 else

if test "$fast_install" = yes; then

echo >> $output "\

program=lt-'$outputname'

program=lt-'$outputname'$exeext

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

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

Line 3446 else

Line 4135 else

# relink executable if necessary

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

if (eval \$relink_command); then :

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

else

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

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

exit 1

Line 3496 else

Line 4186 else

# Run the actual program with our arguments.

case $host in

*-*-cygwin* | *-*-mingw | *-*-os2*)

# win32 systems need to use the prog path for dll

# lookup to work

*-*-cygwin* | *-*-pw32*)

$echo >> $output "\

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

;;

# Backslashes separate directories on plain windows

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

$echo >> $output "\

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

;;

$echo >> $output "\

# Export the path to the program.

Line 3544 fi\

Line 4242 fi\

oldobjs="$libobjs_save"

build_libtool_libs=no

else

oldobjs="$objs$old_deplibs "`$echo "X$libobjs_save" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`

oldobjs="$objs$old_deplibs $non_pic_objects"

addlibs="$old_convenience"

Line 3553 fi\

Line 4251 fi\

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

$show "${rm}r $gentop"

$run ${rm}r "$gentop"

$show "mkdir $gentop"

$show "$mkdir $gentop"

$run mkdir "$gentop"

$run $mkdir "$gentop"

status=$?

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

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

exit $status

generated="$generated $gentop"

Line 3564 fi\

Line 4262 fi\

# Add in members from convenience archives.

for xlib in $addlibs; do

# Extract the objects.

case "$xlib" in

case $xlib in

[\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;

*) xabs=`pwd`"/$xlib" ;;

esac

Line 3573 fi\

Line 4271 fi\

$show "${rm}r $xdir"

$run ${rm}r "$xdir"

$show "mkdir $xdir"

$show "$mkdir $xdir"

$run mkdir "$xdir"

$run $mkdir "$xdir"

status=$?

if test $status -ne 0 && test ! -d "$xdir"; then

if test "$status" -ne 0 && test ! -d "$xdir"; then

exit $status

$show "(cd $xdir && $AR x $xabs)"

Line 3590 fi\

Line 4288 fi\

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

eval cmds=\"$old_archive_from_new_cmds\"

else

# Ensure that we have .o objects in place in case we decided

eval cmds=\"$old_archive_cmds\"

# not to build a shared library, and have fallen back to building

# static libs even though --disable-static was passed!

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

for oldobj in $oldobjs; do

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

if test ! -f $oldobj; then

xdir=`$echo "X$oldobj" | $Xsed -e 's%/[^/]*$%%'`

else

if test "X$xdir" = "X$oldobj"; then

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

xdir="."

$echo "using piecewise archive linking..."

save_RANLIB=$RANLIB

RANLIB=:

objlist=

concat_cmds=

save_oldobjs=$oldobjs

for obj in $save_oldobjs

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

else

xdir="$xdir"

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

oldobjs=$objlist

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

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

objlist=

baseobj=`$echo "X$oldobj" | $Xsed -e 's%^.*/%%'`

done

obj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`

RANLIB=$save_RANLIB

$show "(cd $xdir && ${LN_S} $obj $baseobj)"

oldobjs=$objlist

$run eval '(cd $xdir && ${LN_S} $obj $baseobj)' || exit $?

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

done

eval cmds=\"$old_archive_cmds\"

IFS="${IFS= }"; save_ifs="$IFS"; IFS='~'

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

for cmd in $cmds; do

IFS="$save_ifs"

$show "$cmd"

Line 3625 fi\

Line 4337 fi\

# Now create the libtool archive.

case "$output" in

case $output in

*.la)

old_library=

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

$show "creating $output"

# 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"

done

# Quote the link command for shipping.

relink_command="cd `pwd`; $SHELL $0 --mode=relink $libtool_args"

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

Line 3646 fi\

Line 4369 fi\

# Replace all uninstalled libtool libraries with the installed ones

newdependency_libs=

for deplib in $dependency_libs; do

case "$deplib" in

case $deplib in

*.la)

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

eval libdir=`sed -n -e 's/^libdir=$.*$$/\1/p' $deplib`

Line 3684 fi\

Line 4407 fi\

dlprefiles="$newdlprefiles"

$rm $output

# place dlname in correct position for cygwin

tdlname=$dlname

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

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

esac

$echo > $output "\

# $outputname - a libtool library file

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

Line 3692 fi\

Line 4420 fi\

# It is necessary for linking the library.

# The name that we can dlopen(3).

dlname='$dlname'

dlname='$tdlname'

# Names of this library.

library_names='$library_names'

Line 3717 dlpreopen='$dlprefiles'

Line 4445 dlpreopen='$dlprefiles'

# Directory that this library needs to be installed in:

libdir='$install_libdir'"

if test "$installed" = no; then

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

$echo >> $output "\

relink_command=\"$relink_command\""

Line 3739 relink_command=\"$relink_command\""

Line 4467 relink_command=\"$relink_command\""

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

# install_prog (especially on Windows NT).

if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh; then

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

# Aesthetically quote it.

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

case "$arg" in

case $arg in

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

arg="\"$arg\""

;;

Line 3758 relink_command=\"$relink_command\""

Line 4488 relink_command=\"$relink_command\""

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

# Aesthetically quote it.

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

case "$arg" in

case $arg in

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

arg="\"$arg\""

;;

Line 3781 relink_command=\"$relink_command\""

Line 4511 relink_command=\"$relink_command\""

continue

case "$arg" in

case $arg in

-d) isdir=yes ;;

-f) prev="-f" ;;

-g) prev="-g" ;;

Line 3806 relink_command=\"$relink_command\""

Line 4536 relink_command=\"$relink_command\""

# Aesthetically quote the argument.

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

case "$arg" in

case $arg in

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

arg="\"$arg\""

;;

Line 3851 relink_command=\"$relink_command\""

Line 4581 relink_command=\"$relink_command\""

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

set dummy $files

if test $# -gt 2; then

if test "$#" -gt 2; then

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

$echo "$help" 1>&2

exit 1

case "$destdir" in

case $destdir in

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

for file in $files; do

case "$file" in

case $file in

*.lo) ;;

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

Line 3883 relink_command=\"$relink_command\""

Line 4613 relink_command=\"$relink_command\""

for file in $files; do

# Do each installation.

case "$file" in

case $file in

*.$libext)

# Do the static libraries later.

staticlibs="$staticlibs $file"

Line 3902 relink_command=\"$relink_command\""

Line 4632 relink_command=\"$relink_command\""

old_library=

relink_command=

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

case "$file" in

case $file in

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

*) . ./$file ;;

esac

Line 3925 relink_command=\"$relink_command\""

Line 4655 relink_command=\"$relink_command\""

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

dir="$dir$objdir"

if test "$hardcode_into_libs" = all; then

if test -n "$relink_command"; then

if test -z "$relink_command"; then

$echo "$modename: invalid libtool pseudo library \`$file'" 1>&2

exit 1

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

$show "$relink_command"

if $run eval "$relink_command"; then :

Line 3947 relink_command=\"$relink_command\""

Line 4673 relink_command=\"$relink_command\""

shift

srcname="$realname"

test "$hardcode_into_libs" = all && srcname="$realname"T

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

# Install the shared library and build the symlinks.

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

Line 3957 relink_command=\"$relink_command\""

Line 4683 relink_command=\"$relink_command\""

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

if test $# -gt 0; then

if test "$#" -gt 0; then

# Delete the old symlinks, and create new ones.

for linkname

Line 3971 relink_command=\"$relink_command\""

Line 4697 relink_command=\"$relink_command\""

# Do each command in the postinstall commands.

lib="$destdir/$realname"

eval cmds=\"$postinstall_cmds\"

IFS="${IFS= }"; save_ifs="$IFS"; IFS='~'

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

for cmd in $cmds; do

IFS="$save_ifs"

$show "$cmd"

Line 4002 relink_command=\"$relink_command\""

Line 4728 relink_command=\"$relink_command\""

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

case "$destfile" in

case $destfile in

*.lo)

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

;;

Line 4044 relink_command=\"$relink_command\""

Line 4770 relink_command=\"$relink_command\""

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

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

case $host in

link_against_libtool_libs=

*cygwin*|*mingw*)

wrapper=`echo $file | sed -e 's,.exe$,,'`

;;

wrapper=$file

;;

esac

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

notinst_deplibs=

relink_command=

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

case "$file" in

case $file in

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

*/* | *\\*) . $wrapper ;;

*) . ./$file ;;

*) . ./$wrapper ;;

esac

# Check the variables that should have been set.

if test -z "$link_against_libtool_libs"; then

if test -z "$notinst_deplibs"; then

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

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

exit 1

finalize=yes

for lib in $link_against_libtool_libs; do

for lib in $notinst_deplibs; do

# Check to see that each library is installed.

libdir=

if test -f "$lib"; then

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

case "$lib" in

case $lib in

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

*) . ./$lib ;;

esac

Line 4080 relink_command=\"$relink_command\""

Line 4814 relink_command=\"$relink_command\""

relink_command=

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

case "$file" in

case $file in

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

*) . ./$file ;;

esac

Line 4096 relink_command=\"$relink_command\""

Line 4830 relink_command=\"$relink_command\""

$echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2

continue

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

outputname="$tmpdir/$file"

# Replace the output file specification.

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

Line 4117 relink_command=\"$relink_command\""

Line 4852 relink_command=\"$relink_command\""

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

# one anyways

case $install_prog,$host in

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

case $file:$destfile in

*.exe:*.exe)

# this is ok

;;

*.exe:*)

destfile=$destfile.exe

;;

*:*.exe)

destfile=`echo $destfile | sed -e 's,.exe$,,'`

;;

esac

;;

esac

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

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

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

Line 4140 relink_command=\"$relink_command\""

Line 4892 relink_command=\"$relink_command\""

# Do each command in the postinstall commands.

eval cmds=\"$old_postinstall_cmds\"

IFS="${IFS= }"; save_ifs="$IFS"; IFS='~'

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

for cmd in $cmds; do

IFS="$save_ifs"

$show "$cmd"

Line 4156 relink_command=\"$relink_command\""

Line 4908 relink_command=\"$relink_command\""

if test -n "$current_libdirs"; then

# Maybe just do a dry run.

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

exec $SHELL $0 --finish$current_libdirs

exec_cmd='$SHELL $0 --finish$current_libdirs'

exit 1

else

exit 0

;;

# libtool finish mode

Line 4179 relink_command=\"$relink_command\""

Line 4930 relink_command=\"$relink_command\""

if test -n "$finish_cmds"; then

# Do each command in the finish commands.

eval cmds=\"$finish_cmds\"

IFS="${IFS= }"; save_ifs="$IFS"; IFS='~'

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

for cmd in $cmds; do

IFS="$save_ifs"

$show "$cmd"

Line 4208 relink_command=\"$relink_command\""

Line 4959 relink_command=\"$relink_command\""

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 \`-LLIBDIR'"

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

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

if test -n "$shlibpath_var"; then

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

Line 4258 relink_command=\"$relink_command\""

Line 5009 relink_command=\"$relink_command\""

dir=

case "$file" in

case $file in

*.la)

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

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

Line 4273 relink_command=\"$relink_command\""

Line 5024 relink_command=\"$relink_command\""

library_names=

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

case "$file" in

case $file in

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

*) . ./$file ;;

esac

Line 4328 relink_command=\"$relink_command\""

Line 5079 relink_command=\"$relink_command\""

args=

for file

case "$file" in

case $file in

-*) ;;

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

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

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

case "$file" in

case $file in

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

*) . ./$file ;;

esac

Line 4363 relink_command=\"$relink_command\""

Line 5114 relink_command=\"$relink_command\""

LANG="$save_LANG"; export LANG

# Now actually exec the command.

# Now prepare to actually exec the command.

eval "exec \$cmd$args"

exec_cmd="\$cmd$args"

$echo "$modename: cannot exec \$cmd$args"

exit 1

else

# Display what would be done.

if test -n "$shlibpath_var"; then

Line 4384 relink_command=\"$relink_command\""

Line 5132 relink_command=\"$relink_command\""

modename="$modename: $mode"

rm="$nonopt"

files=

rmforce=

exit_status=0

# This variable tells wrapper scripts just to set variables rather

# than running their programs.

Line 4391 relink_command=\"$relink_command\""

Line 5141 relink_command=\"$relink_command\""

for arg

case "$arg" in

case $arg in

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

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

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

esac

Line 4403 relink_command=\"$relink_command\""

Line 5154 relink_command=\"$relink_command\""

exit 1

rmdirs=

for file in $files; do

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

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

Line 4412 relink_command=\"$relink_command\""

Line 5165 relink_command=\"$relink_command\""

objdir="$dir/$objdir"

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

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

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

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

if test "$mode" = clean; then

case " $rmdirs " in

*" $objdir "*) ;;

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

esac

# 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

rmfiles="$file"

case "$name" in

case $name in

*.la)

# Possibly a libtool archive, so verify it.

if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

Line 4427 relink_command=\"$relink_command\""

Line 5200 relink_command=\"$relink_command\""

rmfiles="$rmfiles $objdir/$n"

done

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

test $mode = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"

test "$mode" = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"

if test $mode = uninstall; then

if test "$mode" = uninstall; then

if test -n "$library_names"; then

# Do each command in the postuninstall commands.

eval cmds=\"$postuninstall_cmds\"

IFS="${IFS= }"; save_ifs="$IFS"; IFS='~'

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

for cmd in $cmds; do

IFS="$save_ifs"

$show "$cmd"

$run eval "$cmd"

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

exit_status=1

done

IFS="$save_ifs"

Line 4445 relink_command=\"$relink_command\""

Line 5221 relink_command=\"$relink_command\""

if test -n "$old_library"; then

# Do each command in the old_postuninstall commands.

eval cmds=\"$old_postuninstall_cmds\"

IFS="${IFS= }"; save_ifs="$IFS"; IFS='~'

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

for cmd in $cmds; do

IFS="$save_ifs"

$show "$cmd"

$run eval "$cmd"

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

exit_status=1

done

IFS="$save_ifs"

Line 4459 relink_command=\"$relink_command\""

Line 5238 relink_command=\"$relink_command\""

;;

*.lo)

if test "$build_old_libs" = yes; then

# Possibly a libtool object, so verify it.

oldobj=`$echo "X$name" | $Xsed -e "$lo2o"`

if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

rmfiles="$rmfiles $dir/$oldobj"

# 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"

# 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"

;;

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

if test $mode = clean &&

if test "$mode" = clean &&

(sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

relink_command=

. $dir/$file

Line 4480 relink_command=\"$relink_command\""

Line 5273 relink_command=\"$relink_command\""

;;

esac

$show "$rm $rmfiles"

$run $rm $rmfiles

$run $rm $rmfiles || exit_status=1

done

exit 0

# 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

done

exit $exit_status

;;

"")

Line 4492 relink_command=\"$relink_command\""

Line 5294 relink_command=\"$relink_command\""

;;

esac

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

if test -z "$exec_cmd"; then

$echo "$generic_help" 1>&2

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

exit 1

$echo "$generic_help" 1>&2

exit 1

fi # test -z "$show_help"

if test -n "$exec_cmd"; then

eval exec $exec_cmd

exit 1

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

case "$mode" in

case $mode in

"") $echo \

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

Line 4513 Provide generalized library-building support services.

Line 5322 Provide generalized library-building support services.

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

--quiet same as \`--silent'

--silent don't print informational messages

--tag=TAG use configuration variables from tag TAG

--version print version information

MODE must be one of the following:

Line 4553 Compile a source file into a libtool library object.

Line 5363 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

-prefer-pic try to building PIC objects only

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

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

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

Line 4636 The following components of LINK-COMMAND are treated s

Line 5448 The following components of LINK-COMMAND are treated s

-no-install link a not-installable executable

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

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

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

-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

Line 4685 echo

Line 5498 echo

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

exit 0

# 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

# Local Variables:

# mode:shell-script

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>