# 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

#

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

basename="s,^.*/,,g"

# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh

# is ksh but when the shell is invoked as "sh" and the current value of

# the _XPG environment variable is not equal to 1 (one), the special

# positional parameter $0, within a function call, is the name of the

# function.

progpath="$0"

# The name of this program:

progname=`echo "$progpath" | $SED $basename`

modename="$progname"

# Global variables:

EXIT_SUCCESS=0

EXIT_FAILURE=1

PROGRAM=ltmain.sh

PACKAGE=libtool

VERSION=1.5.22

TIMESTAMP=" (1.1220.2.365 2005/12/18 22:14:06)"

# See if we are running on zsh, and set the options which allow our

# commands through without removal of \ escapes.

if test -n "${ZSH_VERSION+set}" ; then

setopt NO_GLOB_SUBST

fi

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

fi

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

# used as fallback echo

shift

cat <<EOF

$*

EOF

fi

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.

case `echo X|tr X '\101'` in

A) # ASCII based system

# \n is not interpreted correctly by Solaris 8 /usr/ucb/tr

SP2NL='tr \040 \012'

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

*) # EBCDIC based system

SP2NL='tr \100 \n'

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

;;

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

lt_nl='

'

IFS=" $lt_nl"

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

fi

# Global variables.

mode=$default_mode

nonopt=

prev=

prevopt=

run=

show="$echo"

show_help=

execute_dlfiles=

duplicate_deps=no

preserve_args=

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

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

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

# Shell function definitions:

# This seems to be the best place for them

# func_mktempdir [string]

# Make a temporary directory that won't clash with other running

# libtool processes, and avoids race conditions if possible. If

# given, STRING is the basename for that directory.

func_mktempdir ()

{

my_template="${TMPDIR-/tmp}/${1-$progname}"

if test "$run" = ":"; then

# Return a directory name, but don't create it in dry-run mode

my_tmpdir="${my_template}-$$"

else

# If mktemp works, use that first and foremost

my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`

if test ! -d "$my_tmpdir"; then

# Failing that, at least try and use $RANDOM to avoid a race

my_tmpdir="${my_template}-${RANDOM-0}$$"

save_mktempdir_umask=`umask`

umask 0077

$mkdir "$my_tmpdir"

umask $save_mktempdir_umask

fi

# If we're not in dry-run mode, bomb out on failure

test -d "$my_tmpdir" || {

$echo "cannot create temporary directory \`$my_tmpdir'" 1>&2

exit $EXIT_FAILURE

}

fi

$echo "X$my_tmpdir" | $Xsed

}

# func_win32_libid arg

# return the library type of file 'arg'

#

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

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

$SED -n -e '1,100{/ I /{s,.*,import,;p;q;};}'`

case $win32_nmres in

import*) win32_libid_type="x86 archive import";;

*) win32_libid_type="x86 archive static";;

esac

fi

;;

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

}

# func_infer_tag arg

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

# arg is usually of the form 'gcc ...'

func_infer_tag ()

{

if test -n "$available_tags" && test -z "$tagname"; then

CC_quoted=

for arg in $CC; do

case $arg in

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

arg="\"$arg\""

;;

esac

CC_quoted="$CC_quoted $arg"

done

case $@ 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` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;

# 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$" < "$progpath" > /dev/null; then

# Evaluate the configuration.

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

CC_quoted=

for arg in $CC; do

# Double-quote args containing other shell metacharacters.

case $arg in

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

arg="\"$arg\""

;;

esac

CC_quoted="$CC_quoted $arg"

done

case "$@ " in

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

# 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 $EXIT_FAILURE

# else

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

fi

;;

esac

fi

}

# func_extract_an_archive dir oldlib

func_extract_an_archive ()

{

f_ex_an_ar_dir="$1"; shift

f_ex_an_ar_oldlib="$1"

$show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"

$run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?

if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then

:

else

$echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2

exit $EXIT_FAILURE

fi

}

func_extract_archives ()

{

my_gentop="$1"; shift

my_oldlibs=${1+"$@"}

my_oldobjs=""

my_xlib=""

my_xabs=""

my_xdir=""

my_status=""

$show "${rm}r $my_gentop"

$run ${rm}r "$my_gentop"

$show "$mkdir $my_gentop"

$run $mkdir "$my_gentop"

my_status=$?

if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then

exit $my_status

fi

for my_xlib in $my_oldlibs; do

# Extract the objects.

case $my_xlib in

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

*) my_xabs=`pwd`"/$my_xlib" ;;

esac

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

my_xdir="$my_gentop/$my_xlib"

$show "${rm}r $my_xdir"

$run ${rm}r "$my_xdir"

$show "$mkdir $my_xdir"

$run $mkdir "$my_xdir"

exit_status=$?

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

exit $exit_status

fi

case $host in

*-darwin*)

$show "Extracting $my_xabs"

# Do not bother doing anything if just a dry run

if test -z "$run"; then

darwin_orig_dir=`pwd`

cd $my_xdir || exit $?

darwin_archive=$my_xabs

darwin_curdir=`pwd`

darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`

if test -n "$darwin_arches"; then

darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`

darwin_arch=

$show "$darwin_base_archive has multiple architectures $darwin_arches"

for darwin_arch in $darwin_arches ; do

mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"

lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"

cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"

done # $darwin_arches

## Okay now we have a bunch of thin objects, gotta fatten them up :)

darwin_file=

darwin_files=

for darwin_file in $darwin_filelist; do

darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`

lipo -create -output "$darwin_file" $darwin_files

done # $darwin_filelist

cd "$darwin_orig_dir"

else

cd "$darwin_orig_dir"

func_extract_an_archive "$my_xdir" "$my_xabs"

fi # $darwin_arches

fi # $run

;;

*)

func_extract_an_archive "$my_xdir" "$my_xabs"

;;

esac

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

done

func_extract_archives_result="$my_oldobjs"

}

# End of Shell function definitions

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

# Darwin sucks

eval std_shrext=\"$shrext_cmds\"

disable_libs=no

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

;;

esac

case $tagname in

CC)

# Don't test for the "default" C tag, as we know, it's there, but

# not specially marked.

;;

*)

taglist="$taglist $tagname"

# Evaluate the configuration.

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

;;

--config)

# Now print the configurations for the tags.

for tagname in $taglist; do

;;

--debug)

;;

--dry-run | -n)

run=:

;;

--features)

fi

if test "$build_old_libs" = yes; then

;;

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

preserve_args="$preserve_args --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

;;

*)

nonopt="$arg"

break

;;

esac

done

if test -n "$prevopt"; then

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

$echo "$help" 1>&2

fi

case $disable_libs in

no)

;;

shared)

build_libtool_libs=no

build_old_libs=yes

;;

static)

build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`

;;

esac

# 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

*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

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

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

fi

arg_mode=target

continue

;;

-static | -prefer-pic | -prefer-non-pic)

later="$later $arg"

continue

;;

-no-suppress)

suppress_opt=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=','

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

# in scan sets, and some SunOS ksh mistreat backslash-escaping

# in scan sets (worked around with variable expansion),

# and furthermore cannot handle '|' '&' '(' ')' in scan sets

# at all, so we specify them 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"

*)

# 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

;;

esac

func_infer_tag $base_compile

for arg in $later; do

case $arg in

-static)

build_old_libs=yes

continue

;;

-prefer-pic)

pic_mode=yes

continue

;;

-prefer-non-pic)

pic_mode=no

continue

;;

esac

qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`

case $qlibobj in

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

qlibobj="\"$qlibobj\"" ;;

esac

test "X$libobj" != "X$qlibobj" \

&& $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"' &()|`$[]' \

&& $echo "$modename: libobj name \`$libobj' may not contain shell special characters."