/rusxmms/librcc

#! /bin/sh

 

# libtoolT - Provide generalized library-building support services.

# Generated automatically by  (GNU librcc 0.1.0)

# NOTE: Changes made to this file will be lost: look at ltmain.sh.

#

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

# Free Software Foundation, Inc.

#

# This file is part of GNU Libtool:

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

 

# A sed program that does not truncate output.

SED="/bin/sed"

 

# Sed that helps us avoid accidentally triggering echo(1) options like -n.

Xsed="/bin/sed -e s/^X//"

 

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

# if CDPATH is set.

if test "X${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi

 

# The names of the tagged configurations supported by this script.

available_tags=" CXX"

 

# ### BEGIN LIBTOOL CONFIG

 

# Libtool was configured on host Suren:

 

# Shell to use when invoking shell scripts.

SHELL="/bin/sh"

 

# Whether or not to build shared libraries.

build_libtool_libs=yes

 

# Whether or not to build static libraries.

build_old_libs=yes

 

# Whether or not to add -lc for building shared libraries.

build_libtool_need_lc=no

 

# Whether or not to disallow shared libs when runtime libs are static

allow_libtool_libs_with_static_runtimes=no

 

# Whether or not to optimize for fast installation.

fast_install=yes

 

# The host system.

host_alias=

host=i686-pc-linux-gnu

 

# An echo program that does not interpret backslashes.

echo="echo"

 

# The archiver.

AR="ar"

AR_FLAGS="cru"

 

# A C compiler.

LTCC="gcc"

 

# A language-specific compiler.

CC="gcc"

 

# Is the compiler the GNU C compiler?

with_gcc=yes

 

# An ERE matcher.

EGREP="grep -E"

 

# The linker used to build libraries.

LD="/usr/bin/ld"

 

# Whether we need hard or soft links.

LN_S="ln -s"

 

# A BSD-compatible nm program.

NM="/usr/bin/nm -B"

 

# A symbol stripping program

STRIP="strip"

 

# Used to examine libraries when file_magic_cmd begins "file"

MAGIC_CMD=file

 

# Used on cygwin: DLL creation program.

DLLTOOL="dlltool"

 

# Used on cygwin: object dumper.

OBJDUMP="objdump"

 

# Used on cygwin: assembler.

AS="as"

 

# The name of the directory that contains temporary libtool files.

objdir=.libs

 

# How to create reloadable object files.

reload_flag=" -r"

reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs"

 

# How to pass a linker flag through the compiler.

wl="-Wl,"

 

# Object file suffix (normally "o").

objext="o"

 

# Old archive suffix (normally "a").

libext="a"

 

# Shared library suffix (normally ".so").

shrext_cmds='.so'

 

# Executable file suffix (normally "").

exeext=""

 

# Additional compiler flags for building library objects.

pic_flag=" -fPIC -DPIC"

pic_mode=default

 

# What is the maximum length of a command?

max_cmd_len=32768

 

# Does compiler simultaneously support -c and -o options?

compiler_c_o="yes"

 

# Must we lock files when doing compilation ?

need_locks="no"

 

# Do we need the lib prefix for modules?

need_lib_prefix=no

 

# Do we need a version for libraries?

need_version=no

 

# Whether dlopen is supported.

dlopen_support=unknown

 

# Whether dlopen of programs is supported.

dlopen_self=unknown

 

# Whether dlopen of statically linked programs is supported.

dlopen_self_static=unknown

 

# Compiler flag to prevent dynamic linking.

link_static_flag="-static"

 

# Compiler flag to turn off builtin functions.

no_builtin_flag=" -fno-builtin"

 

# Compiler flag to allow reflexive dlopens.

export_dynamic_flag_spec="\${wl}--export-dynamic"

 

# Compiler flag to generate shared objects directly from archives.

whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive"

 

# Compiler flag to generate thread-safe objects.

thread_safe_flag_spec=""

 

# Library versioning type.

version_type=linux

 

# Format of library name prefix.

libname_spec="lib\$name"

 

# List of archive names.  First name is the real one, the rest are links.

# The last name is the one that the linker finds with -lNAME.

library_names_spec="\${libname}\${release}\${shared_ext}\$versuffix \${libname}\${release}\${shared_ext}\$major \$libname\${shared_ext}"

 

# The coded name of the library, if different from the real name.

soname_spec="\${libname}\${release}\${shared_ext}\$major"

 

# Commands used to build and install an old-style archive.

RANLIB="ranlib"

old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs\$old_deplibs~\$RANLIB \$oldlib"

old_postinstall_cmds="\$RANLIB \$oldlib~chmod 644 \$oldlib"

old_postuninstall_cmds=""

 

# Create an old-style archive from a shared archive.

old_archive_from_new_cmds=""

 

# Create a temporary old-style archive to link instead of a shared archive.

old_archive_from_expsyms_cmds=""

 

# Commands used to build and install a shared archive.

archive_cmds="\$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib"

archive_expsym_cmds="\$echo \\\"{ global:\\\" > \$output_objdir/\$libname.ver~

cat \$export_symbols | sed -e \\\"s/\\\\(.*\\\\)/\\\\1;/\\\" >> \$output_objdir/\$libname.ver~

\$echo \\\"local: *; };\\\" >> \$output_objdir/\$libname.ver~

        \$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-version-script \${wl}\$output_objdir/\$libname.ver -o \$lib"

postinstall_cmds=""

postuninstall_cmds=""

 

# Commands used to build a loadable module (assumed same as above if empty)

module_cmds=""

module_expsym_cmds=""

 

# Commands to strip libraries.

old_striplib="strip --strip-debug"

striplib="strip --strip-unneeded"

 

# Dependencies to place before the objects being linked to create a

# shared library.

predep_objects=""

 

# Dependencies to place after the objects being linked to create a

# shared library.

postdep_objects=""

 

# Dependencies to place before the objects being linked to create a

# shared library.

predeps=""

 

# Dependencies to place after the objects being linked to create a

# shared library.

postdeps=""

 

# The library search path used internally by the compiler when linking

# a shared library.

compiler_lib_search_path=""

 

# Method to check whether dependent libraries are shared objects.

deplibs_check_method="pass_all"

 

# Command to use when deplibs_check_method == file_magic.

file_magic_cmd="\$MAGIC_CMD"

 

# Flag that allows shared libraries with undefined symbols to be built.

allow_undefined_flag=""

 

# Flag that forces no undefined symbols.

no_undefined_flag=""

 

# Commands used to finish a libtool library installation in a directory.

finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir"

 

# Same as above, but a single script fragment to be evaled but not shown.

finish_eval=""

 

# Take the output of nm and produce a listing of raw symbols and C names.

global_symbol_pipe="sed -n -e 's/^.*[   ]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[       ][      ]*\\(\\)\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 \\2\\3 \\3/p'"

 

# Transform the output of nm in a proper C declaration

global_symbol_to_cdecl="sed -n -e 's/^. .* \\(.*\\)\$/extern int \\1;/p'"

 

# Transform the output of nm in a C name address pair

global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\) \$/  {\\\"\\1\\\", (lt_ptr) 0},/p' -e 's/^[BCDEGRST] \\([^ ]*\\) \\([^ ]*\\)\$/  {\"\\2\", (lt_ptr) \\&\\2},/p'"

 

# This is the shared library runtime path variable.

runpath_var=LD_RUN_PATH

 

# This is the shared library path variable.

shlibpath_var=LD_LIBRARY_PATH

 

# Is shlibpath searched before the hard-coded library search path?

shlibpath_overrides_runpath=no

 

# How to hardcode a shared library path into an executable.

hardcode_action=immediate

 

# Whether we should hardcode library paths into libraries.

hardcode_into_libs=yes

 

# Flag to hardcode $libdir into a binary during linking.

# This must work even if $libdir does not exist.

hardcode_libdir_flag_spec="\${wl}--rpath \${wl}\$libdir"

 

# If ld is used when linking, flag to hardcode $libdir into

# a binary during linking. This must work even if $libdir does

# not exist.

hardcode_libdir_flag_spec_ld=""

 

# Whether we need a single -rpath flag with a separated argument.

hardcode_libdir_separator=""

 

# Set to yes if using DIR/libNAME during linking hardcodes DIR into the

# resulting binary.

hardcode_direct=no

 

# Set to yes if using the -LDIR flag during linking hardcodes DIR into the

# resulting binary.

hardcode_minus_L=no

 

# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into

# the resulting binary.

hardcode_shlibpath_var=unsupported

 

# Set to yes if building a shared library automatically hardcodes DIR into the library

# and all subsequent libraries and executables linked against it.

hardcode_automatic=no

 

# Variables whose values should be saved in libtool wrapper scripts and

# restored at relink time.

variables_saved_for_relink="PATH  LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"

 

# Whether libtool must link a program against all its dependency libraries.

link_all_deplibs=unknown

 

# Compile-time system search path for libraries

sys_lib_search_path_spec="/lib /usr/lib /usr/X11R6/lib /usr/local/lib /usr/X11R6/lib /usr/lib/qt3/lib /root/opccli/libopc"

 

# Run-time system search path for libraries

sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/X11R6/lib /usr/X11R6/lib /usr/lib/qt3/lib /root/opccli/libopc"

 

# Fix the shell variable $srcfile for the compiler.

fix_srcfile_path=""

 

# Set to yes if exported symbols are required.

always_export_symbols=no

 

# The commands to list exported symbols.

export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols"

 

# The commands to extract the exported symbol list from a shared archive.

extract_expsyms_cmds=""

 

# Symbols that should not be listed in the preloaded symbols.

exclude_expsyms="_GLOBAL_OFFSET_TABLE_"

 

# Symbols that must always be exported.

include_expsyms=""

 

# ### END LIBTOOL CONFIG

 

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

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

#

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

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

 

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"

 

# define SED for historic ltconfig's generated by Libtool 1.3

test -z "$SED" && SED=sed

 

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

TIMESTAMP=" (1.1220.2.95 2004/04/11 05:50:42)"

 

 

# 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 "$progpath" --no-reexec ${1+"$@"}

fi

 

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

  # used as fallback echo

  shift

  cat <<EOF

$*

EOF

  exit $EXIT_SUCCESS

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.

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

sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'

# test EBCDIC or ASCII

case `echo A|tr A '\301'` in

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

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

 

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

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

}

 

 

# 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

}

# End of Shell function definitions

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

 

# Darwin sucks

#eval std_shrext=\"$shrext_cmds\"

 

# And fixing for Darwin sucks for everybody else

if test -z "$shrext_cmds" && test -n "$shrext"; then

        eval shrext_cmds=\"$shrext\"

fi

eval std_shrext=\"$shrext_cmds\"

 

# This value is evaluated to 32768, so place it here as a compatilibity hack

# because older libtool.m4 didn't define this variable

test -z "$max_cmd_len" && max_cmd_len=32768

 

# Parse our command line options once, thoroughly.

while test "$#" -gt 0

do

  arg="$1"

  shift

 

  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

    execute_dlfiles)

      execute_dlfiles="$execute_dlfiles $arg"

      ;;

    tag)

      tagname="$arg"

      preserve_args="${preserve_args}=$arg"

 

      # Check whether tagname contains only valid characters

      case $tagname in

      *[!-_A-Za-z0-9,/]*)

        $echo "$progname: invalid tag name: $tagname" 1>&2

        exit $EXIT_FAILURE

        ;;

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

          taglist="$taglist $tagname"

          # Evaluate the configuration.

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

        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?

  case $arg in

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

    ;;

 

  --config)

    ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath

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

    done

    exit $EXIT_SUCCESS

    ;;

 

  --debug)

    $echo "$progname: enabling shell trace mode"

    set -x

    preserve_args="$preserve_args $arg"

    ;;

 

  --dry-run | -n)

    run=:

    ;;

 

  --features)

    $echo "host: $host"

    if test "$build_libtool_libs" = yes; then

      $echo "enable shared libraries"

    else

      $echo "disable shared libraries"

    fi

    if test "$build_old_libs" = yes; then

      $echo "enable static libraries"

    else

      $echo "disable static libraries"

    fi

    exit $EXIT_SUCCESS

    ;;

 

  --finish) mode="finish" ;;

 

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

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

 

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

 

  --quiet | --silent)

    show=:

    preserve_args="$preserve_args $arg"

    ;;

 

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

  --tag=*)

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

    shift

    prev=tag

    preserve_args="$preserve_args --tag"

    ;;

 

  -dlopen)

    prevopt="-dlopen"

    prev=execute_dlfiles

    ;;

 

  -*)

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

    $echo "$help" 1>&2

    exit $EXIT_FAILURE

    ;;

 

  *)

    nonopt="$arg"

    break

    ;;

  esac

done

 

if test -n "$prevopt"; then

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

  $echo "$help" 1>&2

  exit $EXIT_FAILURE

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

        case $arg in

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

  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.

  case $mode in

  # libtool compile mode

  compile)

    modename="$modename: compile"

    # Get the compilation command and the source file.

    base_compile=

    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"

    suppress_opt=yes

    suppress_output=

    arg_mode=normal

    libobj=

    later=

 

    for arg

    do

      case "$arg_mode" in

      arg  )

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

        lastarg="$arg"

        arg_mode=normal

        ;;

 

      target )

        libobj="$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 $EXIT_FAILURE

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

          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

 

      # Aesthetically quote the previous argument.

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

 

      case $lastarg in

      # Double-quote args containing other shell metacharacters.

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

      ;;

    target)

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

      exit $EXIT_FAILURE

      ;;

    *)

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

    *.java) xform=java ;;

    esac

 

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

 

    case $libobj in

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

    *)

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

      exit $EXIT_FAILURE

      ;;

    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

    done

 

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

    fi

 

    # Delete any leftover library objects.

    if test "$build_old_libs" = yes; then

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

    else

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

    fi

 

    $run $rm $removelist

    trap "$run $rm $removelist; exit $EXIT_FAILURE" 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

      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 $EXIT_FAILURE" 1 2 15

    else

      output_obj=

      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

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

        $show "Waiting for $lockfile to be removed"

        sleep 2

      done

    elif test "$need_locks" = warn; then

      if test -f "$lockfile"; then

        $echo "\

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

      fi

      $echo $srcfile > "$lockfile"

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

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

      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'

 

EOF

 

      # Allow error messages only from the first compilation.

      if test "$suppress_opt" = yes; then

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

      fi

    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"

      $run $rm "$obj" "$output_obj"

      $show "$command"

      if $run eval "$command"; then :

      else

        $run $rm $removelist

        exit $EXIT_FAILURE

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

      fi

 

      # Just move the object if needed

      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

          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

      $run $rm "$lockfile"

    fi

 

    exit $EXIT_SUCCESS

    ;;

 

  # libtool link mode

  link | relink)

    modename="$modename: link"

    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

      # flag for every libtool invocation.

      # 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

    no_install=no

    objs=

    non_pic_objects=

    precious_files_regex=

    prefer_static_libs=no

    preload=no

    prev=

    prevarg=

    release=

    rpath=

    xrpath=

    perm_rpath=

    temp_rpath=

    thread_safe=no

    vinfo=

    vinfo_number=no

 

    func_infer_tag $base_compile

 

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

    for arg

    do

      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

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

    while test "$#" -gt 0; do

      arg="$1"

      shift

      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

        case $prev in

        output)

          compile_command="$compile_command @OUTPUT@"

          finalize_command="$finalize_command @OUTPUT@"

          ;;

        esac

 

        case $prev in

        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

          case $arg in

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

            continue

            ;;

          esac

          ;;

        expsyms)

          export_symbols="$arg"

          if test ! -f "$arg"; then

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

            exit $EXIT_FAILURE

          fi

          prev=

          continue

          ;;

        expsyms_regex)

          export_symbols_regex="$arg"

          prev=

          continue

          ;;

        inst_prefix)

          inst_prefix_dir="$arg"

          prev=

          continue

          ;;

        precious_regex)

          precious_files_regex="$arg"

          prev=

          continue

          ;;

        release)

          release="-$arg"

          prev=

          continue

          ;;

        objectlist)

          if test -f "$arg"; then

            save_arg=$arg

            moreargs=

            for fil in `cat $save_arg`

            do

#             moreargs="$moreargs $fil"

              arg=$fil

              # A libtool-controlled object.

 

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

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

                pic_object=

                non_pic_object=

 

                # Read the .lo file

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

                case $arg in

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

                *) . ./$arg ;;

                esac

 

                if test -z "$pic_object" || \

                   test -z "$non_pic_object" ||

                   test "$pic_object" = none && \

                   test "$non_pic_object" = none; then

                  $echo "$modename: cannot find name of object for \`$arg'" 1>&2

                  exit $EXIT_FAILURE

                fi

 

                # Extract subdirectory from the argument.

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

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

                  xdir=

                else

                  xdir="$xdir/"

                fi

 

                if test "$pic_object" != none; then

                  # Prepend the subdirectory the object is found in.

                  pic_object="$xdir$pic_object"

 

                  if test "$prev" = dlfiles; then

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

                      dlfiles="$dlfiles $pic_object"

                      prev=

                      continue

                    else

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

                      prev=dlprefiles

                    fi

                  fi

 

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

                  if test "$prev" = dlprefiles; then

                    # Preload the old-style object.

                    dlprefiles="$dlprefiles $pic_object"

                    prev=

                  fi

 

                  # A PIC object.

                  libobjs="$libobjs $pic_object"

                  arg="$pic_object"

                fi

 

                # Non-PIC object.

                if test "$non_pic_object" != none; then

                  # Prepend the subdirectory the object is found in.

                  non_pic_object="$xdir$non_pic_object"

 

                  # A standard non-PIC object

                  non_pic_objects="$non_pic_objects $non_pic_object"

                  if test -z "$pic_object" || test "$pic_object" = none ; then

                    arg="$non_pic_object"

                  fi

                fi

              else

                # Only an error if not doing a dry-run.

                if test -z "$run"; then

                  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2

                  exit $EXIT_FAILURE

                else

                  # Dry-run case.

 

                  # Extract subdirectory from the argument.

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

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

                    xdir=

                  else

                    xdir="$xdir/"

                  fi

 

                  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`

                  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`

                  libobjs="$libobjs $pic_object"

                  non_pic_objects="$non_pic_objects $non_pic_object"

                fi

              fi

            done

          else

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

            exit $EXIT_FAILURE

          fi

          arg=$save_arg

          prev=

          continue

          ;;

        rpath | xrpath)

          # We need an absolute path.

          case $arg in

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

          *)

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

            exit $EXIT_FAILURE

            ;;

          esac

          if test "$prev" = rpath; then

            case "$rpath " in

            *" $arg "*) ;;

            *) rpath="$rpath $arg" ;;

            esac

          else

            case "$xrpath " in

            *" $arg "*) ;;

            *) xrpath="$xrpath $arg" ;;

            esac

          fi

          prev=

          continue

          ;;

        xcompiler)

          compiler_flags="$compiler_flags $qarg"

          prev=

          compile_command="$compile_command $qarg"

          finalize_command="$finalize_command $qarg"

          continue

          ;;

        xlinker)

          linker_flags="$linker_flags $qarg"

          compiler_flags="$compiler_flags $wl$qarg"

          prev=

          compile_command="$compile_command $wl$qarg"

          finalize_command="$finalize_command $wl$qarg"

          continue

          ;;