# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003

# 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

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

#

# As a special exception to the GNU General Public License, if you

# distribute this file as part of a program that contains a

# configuration script generated by Autoconf, you may include it under

# the same distribution terms that you use for the rest of that program.

# Check that we have a working $echo.

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

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

shift

elif test "X$1" = X--fallback-echo; then

# Avoid inline document here, it may be left over

:

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

# Yippee, $echo works!

:

else

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

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

fi

if test "X$1" = X--fallback-echo; then

# used as fallback echo

shift

cat <<EOF

$*

EOF

exit 0

fi

# The name of this program.

modename="$progname"

# Constants.

PROGRAM=ltmain.sh

PACKAGE=libtool

VERSION=1.5

TIMESTAMP=" (1.1220.2.1 2003/04/14 22:48:00)"

default_mode=

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

magic="%%%MAGIC variable%%%"

mkdir="mkdir"

mv="mv -f"

rm="rm -f"

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

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

# test EBCDIC or ASCII

case `echo A|od -x` in

*[Cc]1*) # EBCDIC based system

SP2NL="tr '\100' '\n'"

NL2SP="tr '\r\n' '\100\100'"

;;

*) # Assume ASCII based system

SP2NL="tr '\040' '\012'"

NL2SP="tr '\015\012' '\040\040'"

;;

esac

# NLS nuisances.

# Only set LANG and LC_ALL to C if already set.

# These must not be set unconditionally because not all systems understand

# e.g. LANG=C (notably SCO).

# We save the old values to restore during execute mode.

if test "${LC_ALL+set}" = set; then

save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL

fi

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

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

fi

# Make sure IFS has a sensible default

: ${IFS=" "}

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

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

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

exit 1

fi

# Global variables.

mode=$default_mode

nonopt=

prev=

prevopt=

run=

show="$echo"

show_help=

execute_dlfiles=

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

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

#####################################

# Shell function definitions:

# This seems to be the best place for them

# Need a lot of goo to handle *both* DLLs and import libs

# Has to be a shell function in order to 'eat' the argument

# that is supplied when $file_magic_command is called.

win32_libid () {

win32_libid_type="unknown"

win32_fileres=`file -L $1 2>/dev/null`

case $win32_fileres in

*ar\ archive\ import\ library*) # definitely import

win32_libid_type="x86 archive import"

;;

*ar\ archive*) # could be an import, or static

if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \

grep -E 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then

win32_nmres=`eval $NM -f posix -A $1 | \

sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`

if test "X$win32_nmres" = "Ximport" ; then

win32_libid_type="x86 archive import"

else

win32_libid_type="x86 archive static"

fi

fi

;;

*DLL*)

win32_libid_type="x86 DLL"

;;

*executable*) # but shell scripts are "executable" too...

case $win32_fileres in

*MS\ Windows\ PE\ Intel*)

win32_libid_type="x86 DLL"

;;

esac

;;

esac

$echo $win32_libid_type

}

# End of Shell function definitions

#####################################

do

arg="$1"

shift

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

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

fi

;;

esac

;;

*)

eval "$prev=\$arg"

;;

esac

prev=

prevopt=

continue

fi

# Have we seen a non-optional argument yet?

--help)

show_help=yes

;;

--version)

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

$echo

$echo "Copyright (C) 2003 Free Software Foundation, Inc."

$echo "This is free software; see the source for copying conditions. There is NO"

$echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."

exit 0

;;

--config)

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

;;

--debug)

set -x

;;

--dry-run | -n)

run=:

;;

--features)

fi

if test "$build_old_libs" = yes; then

fi

exit 0

;;

--finish) mode="finish" ;;

--mode) prevopt="--mode" prev=mode ;;

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

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

--quiet | --silent)

show=:

;;

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

--tag=*)

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

shift

prev=tag

;;

-dlopen)

prevopt="-dlopen"

prev=execute_dlfiles

;;

-*)

$echo "$modename: unrecognized option \`$arg'" 1>&2

$echo "$help" 1>&2

exit 1

;;

*)

nonopt="$arg"

break

;;

esac

done

if test -n "$prevopt"; then

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

$echo "$help" 1>&2

exit 1

fi

# 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

$echo "*** Warning: inferring the mode of operation is deprecated." 1>&2

$echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2

case $nonopt in

*cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)

mode=link

for arg

do

-c)

mode=compile

break

;;

esac

done

;;

*db | *dbx | *strace | *truss)

mode=execute

;;

*install*|cp|mv)

mode=install

;;

*rm)

mode=uninstall

;;

*)

# If we have no mode, but dlfiles were specified, then do execute mode.

test -n "$execute_dlfiles" && mode=execute

# Just use the default operation mode.

if test -z "$mode"; then

if test -n "$nonopt"; then

$echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2

else

$echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2

fi

fi

;;

esac

fi

# Only execute mode is allowed to have -dlopen flags.

if test -n "$execute_dlfiles" && test "$mode" != execute; then

$echo "$modename: unrecognized option \`-dlopen'" 1>&2

$echo "$help" 1>&2

exit 1

fi

# Change the help message to a mode-specific one.

generic_help="$help"

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

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

# libtool compile mode

compile)

modename="$modename: compile"

# Get the compilation command and the source file.

base_compile=

arg_mode=normal

libobj=

for arg

do

case "$arg_mode" in

arg )

# do not "continue". Instead, add this to base_compile

lastarg="$arg"

arg_mode=normal

;;

continue

;;

normal )

# Accept any command-line options.

case $arg in

-o)

if test -n "$libobj" ; then

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

exit 1

fi

arg_mode=target

continue

;;

-static)

build_old_libs=yes

continue

;;

-prefer-pic)

pic_mode=yes

continue

;;

-prefer-non-pic)

pic_mode=no

continue

;;

-Xcompiler)

arg_mode=arg # the next one goes into the "base_compile" arg list

continue # The current "srcfile" will either be retained or

;; # replaced later. I would guess that would be a bug.

-Wc,*)

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

lastarg=

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

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

arg="\"$arg\""

;;

esac

lastarg="$lastarg $arg"

done

IFS="$save_ifs"

lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`

# Add the arguments to base_compile.

base_compile="$base_compile $lastarg"

continue

;;

* )

# Accept the current argument as the source file.

# The previous "srcfile" becomes the current argument.

#

lastarg="$srcfile"

srcfile="$arg"

;;

esac # case $arg

;;

esac # case $arg_mode

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

# Many Bourne shells cannot handle close brackets correctly

# in scan sets, so we specify it separately.

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

lastarg="\"$lastarg\""

;;

esac

base_compile="$base_compile $lastarg"

done # for arg

case $arg_mode in

arg)

$echo "$modename: you must specify an argument for -Xcompile"

exit 1

$echo "$modename: you must specify a target with \`-o'" 1>&2

exit 1

;;

*)

# Get the name of the library object.

[ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`

;;

esac

# Recognize several different file suffixes.

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

xform='[cCFSifmso]'

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

esac

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

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

*)

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

exit 1

;;

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

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

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

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

# Blanks at the start of $base_compile will cause this to fail

# if we don't check for them as well.

*)

for z in $available_tags; do

if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then

# Evaluate the configuration.

eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"

case "$base_compile " in

"$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*)

# The compiler in the base compile command matches

# the one in the tagged configuration.

# Assume this is the tagged configuration we want.

tagname=$z

break

;;

esac

fi

done

# If $tagname still isn't set, then no tagged configuration

# was found and let the user know that the "--tag" command

# line option must be used.

if test -z "$tagname"; then

$echo "$modename: unable to infer tagged configuration"

$echo "$modename: specify a tag with \`--tag'" 1>&2

exit 1

# else

# $echo "$modename: using $tagname tagged configuration"

fi

;;

esac

fi

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

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

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

xdir=

else

xdir=$xdir/

fi

lobj=${xdir}$objdir/$objname

if test -z "$base_compile"; then

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

$echo "$help" 1>&2

exit 1

fi

# Delete any leftover library objects.

if test "$build_old_libs" = yes; then

fi

$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

fi

# Calculate the filename of the output object if compiler does

# not support -o with -c

if test "$compiler_c_o" = no; then

lockfile="$output_obj.lock"

removelist="$removelist $output_obj $lockfile"

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

else

need_locks=no

lockfile=

fi

# Lock this critical section if it is needed

# We use this script file to make the link, it avoids creating a new file

if test "$need_locks" = yes; then

$show "Waiting for $lockfile to be removed"

sleep 2

done

elif test "$need_locks" = warn; then

if test -f "$lockfile"; then

*** ERROR, $lockfile exists and contains:

`cat $lockfile 2>/dev/null`

This indicates that another process is trying to use the same

temporary object file, and libtool could not work around it because

your compiler does not support \`-c' and \`-o' together. If you

repeat this compilation, it may succeed, by chance, but you had better

avoid parallel builds (make -j) in this platform, or get a better

compiler."

$run $rm $removelist

exit 1

fi

fi

if test -n "$fix_srcfile_path"; then

eval srcfile=\"$fix_srcfile_path\"

fi

$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

command="$base_compile $srcfile $pic_flag"

else

# Don't build PIC code

command="$base_compile $srcfile"

fi

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

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

$run $mkdir ${xdir}$objdir

status=$?

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

exit $status

fi

fi

if test -z "$output_obj"; then

# Place PIC objects in $objdir

command="$command -o $lobj"

fi

$run $rm "$lobj" "$output_obj"

$show "$command"

if $run eval "$command"; then :

else

test -n "$output_obj" && $run $rm $removelist

exit 1

fi

if test "$need_locks" = warn &&

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

$echo "\

*** ERROR, $lockfile contains:

`cat $lockfile 2>/dev/null`

but it should contain:

$srcfile

This indicates that another process is trying to use the same

temporary object file, and libtool could not work around it because

your compiler does not support \`-c' and \`-o' together. If you

repeat this compilation, it may succeed, by chance, but you had better

avoid parallel builds (make -j) in this platform, or get a better

compiler."

$run $rm $removelist

exit 1

fi

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

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

$show "$mv $output_obj $lobj"

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

else

error=$?

$run $rm $removelist

exit $error

fi

fi

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

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

pic_object='$objdir/$objname'

# 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

fi

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

if test "$build_old_libs" = yes; then

if test "$pic_mode" != yes; then

# Don't build PIC code

command="$base_compile $srcfile"

else

command="$base_compile $srcfile $pic_flag"

fi

if test "$compiler_c_o" = yes; then

command="$command -o $obj"

fi

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

command="$command$suppress_output"

$show "$command"

if $run eval "$command"; then :

else

$run $rm $removelist

exit 1

fi

if test "$need_locks" = warn &&

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

$echo "\

*** ERROR, $lockfile contains:

`cat $lockfile 2>/dev/null`

but it should contain:

$srcfile

This indicates that another process is trying to use the same

temporary object file, and libtool could not work around it because

your compiler does not support \`-c' and \`-o' together. If you

repeat this compilation, it may succeed, by chance, but you had better

avoid parallel builds (make -j) in this platform, or get a better

compiler."

$run $rm $removelist

exit 1

fi

# Just move the object if needed

$show "$mv $output_obj $obj"

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

else

error=$?

$run $rm $removelist

exit $error

fi

fi

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

# Only append if the libtool object file exists.

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

# Name of the non-PIC object.

non_pic_object='$objname'

EOF

else

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

# Only append if the libtool object file exists.

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

# Name of the non-PIC object.

non_pic_object=none

EOF

fi

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

# Unlock the critical section if it was locked

if test "$need_locks" != no; then

fi

exit 0

;;

# libtool link mode

case $host in

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

# allow_undefined=no

# FIXME: Unfortunately, there are problems with the above when trying

# to make a dll which has undefined symbols, in which case not

# even a static library is built. For now, we need to specify

# -no-undefined on the libtool link line when we can be certain

# that all symbols are satisfied, otherwise we get a static library.

allow_undefined=yes

;;

*)

allow_undefined=yes

;;

esac

libtool_args="$nonopt"

base_compile="$nonopt"

compile_command="$nonopt"

finalize_command="$nonopt"

compile_rpath=

finalize_rpath=

compile_shlibpath=

finalize_shlibpath=

convenience=

old_convenience=

deplibs=

old_deplibs=

compiler_flags=

linker_flags=

dllsearchpath=

lib_search_path=`pwd`

inst_prefix_dir=

avoid_version=no

dlfiles=

dlprefiles=

dlself=no

export_dynamic=no

export_symbols=

export_symbols_regex=

generated=

libobjs=

ltlibs=

module=no

prefer_static_libs=no

preload=no

prev=

prevarg=

release=

rpath=

xrpath=

perm_rpath=

temp_rpath=

thread_safe=no

vinfo=

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

for arg

do

-all-static | -static)

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

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

$echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2

fi

if test -n "$link_static_flag"; then

dlopen_self=$dlopen_self_static

fi

else

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

dlopen_self=$dlopen_self_static

fi

fi

build_libtool_libs=no

build_old_libs=yes

prefer_static_libs=yes

break

;;

esac

done

# See if our shared archives depend on static archives.

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

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

case $arg in

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

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

;;

*) qarg=$arg ;;

esac

libtool_args="$libtool_args $qarg"

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

if test -n "$prev"; then

output)

compile_command="$compile_command @OUTPUT@"

finalize_command="$finalize_command @OUTPUT@"

;;

esac

dlfiles|dlprefiles)

if test "$preload" = no; then

# Add the symbol object into the linking commands.

compile_command="$compile_command @SYMFILE@"

finalize_command="$finalize_command @SYMFILE@"

preload=yes

fi

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

force)

if test "$dlself" = no; then

dlself=needless

export_dynamic=yes

fi

prev=

continue

;;

self)

if test "$prev" = dlprefiles; then

dlself=yes

elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then

dlself=yes

else

dlself=needless

export_dynamic=yes

fi

prev=

continue

;;

*)

if test "$prev" = dlfiles; then

dlfiles="$dlfiles $arg"

else

dlprefiles="$dlprefiles $arg"

fi

prev=

;;

esac

;;

expsyms)

export_symbols="$arg"

if test ! -f "$arg"; then

$echo "$modename: symbol file \`$arg' does not exist"

exit 1

fi

prev=

continue